From 8c671dee59c5c096a5af965ab48093916a76bdbf Mon Sep 17 00:00:00 2001 From: chrin Date: Thu, 12 May 2022 09:36:50 +0200 Subject: [PATCH] investigated cafeMutex not resolved for py35 on RH7 --- INSTALL | 15 +- autogen_sfbd.sh | 2 +- autogen_sfbd.sh- | 306 + autogen_slsbd.sh- | 286 + configurePSI.ac | 2 +- configurePSI.ac-Mar10 | 1191 ++ examples/cafeTest/#makfile7# | 3 + examples/cafeTest/cafeTest | Bin 0 -> 329704 bytes examples/cafeTest/cafeTest-- | Bin 0 -> 798576 bytes include/cafe.h | 3 +- include/cafeCache.h | 4 + include/global.h | 2 +- include/instant.h | 7 - include/makefile | 233 +- libtool | 22 +- makefile | 453 +- src/#makefile# | 778 + src/PyCafe_sls_py37.cpp | 32471 ++++++++++++++++++--------------- src/cafe.cpp | 2 +- src/conduit.cpp | 51 +- src/connect.cpp | 2 +- src/granules.cpp | 4 +- src/makefile | 347 +- src/makefile.am | 2 +- src/methodCallbacks.cpp | 3 +- 25 files changed, 20970 insertions(+), 15219 deletions(-) create mode 100644 autogen_sfbd.sh- create mode 100644 autogen_slsbd.sh- create mode 100644 configurePSI.ac-Mar10 create mode 100644 examples/cafeTest/#makfile7# create mode 100755 examples/cafeTest/cafeTest create mode 100755 examples/cafeTest/cafeTest-- create mode 100644 src/#makefile# diff --git a/INSTALL b/INSTALL index 007e939..7d1c323 100644 --- a/INSTALL +++ b/INSTALL @@ -1,8 +1,8 @@ Installation Instructions ************************* -Copyright (C) 1994-1996, 1999-2002, 2004-2013 Free Software Foundation, -Inc. +Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005, +2006, 2007, 2008, 2009 Free Software Foundation, Inc. Copying and distribution of this file, with or without modification, are permitted in any medium without royalty provided the copyright @@ -226,11 +226,6 @@ order to use an ANSI C compiler: and if that doesn't work, install pre-built binaries of GCC for HP-UX. - HP-UX `make' updates targets which have the same time stamps as -their prerequisites, which makes it generally unusable when shipped -generated files such as `configure' are involved. Use GNU `make' -instead. - On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot parse its `' header file. The option `-nodtk' can be used as a workaround. If GNU CC is not installed, it is therefore recommended @@ -309,10 +304,9 @@ causes the specified `gcc' to be used as the C compiler (unless it is overridden in the site shell script). Unfortunately, this technique does not work for `CONFIG_SHELL' due to -an Autoconf limitation. Until the limitation is lifted, you can use -this workaround: +an Autoconf bug. Until the bug is fixed you can use this workaround: - CONFIG_SHELL=/bin/bash ./configure CONFIG_SHELL=/bin/bash + CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash `configure' Invocation ====================== @@ -368,3 +362,4 @@ operates. `configure' also accepts some other, not widely useful, options. Run `configure --help' for more details. + diff --git a/autogen_sfbd.sh b/autogen_sfbd.sh index f78ca14..3ba1831 100644 --- a/autogen_sfbd.sh +++ b/autogen_sfbd.sh @@ -23,7 +23,7 @@ automake --force --add-missing --copy #Used by ./configure #Assumes format ${EPICS}/base-3.14.12 #source cafeVersion-gcc-7.3.0 -CAFE_V="cafe-1.15.0" +CAFE_V="cafe-1.15.1" #For later check of existence of HOST_ARCH for $EPICS/include/os/$HOST_ARCH #Assume Linux but check if Darwin CAFE_HOST_FLAG_DARWIN=$(echo ${EPICS_HOST_ARCH} | grep -c "Darwin") diff --git a/autogen_sfbd.sh- b/autogen_sfbd.sh- new file mode 100644 index 0000000..3ba1831 --- /dev/null +++ b/autogen_sfbd.sh- @@ -0,0 +1,306 @@ +### psi specific - select compiler +#source +# default is sf +# +module unload gcc +module load gcc/7.3.0 +### psi specific - end + +rm -f configure.ac +ln -s configurePSI.ac configure.ac + +rm -f ./aclocal.m4 +rm -rf ./autom4te.cache +aclocal --force -I m4 +/opt/gfa/python-3.7/latest/bin/libtoolize --force --copy #select libtools 2.4.6 +#libtoolize --force --copy +autoconf --force #interprets configure.ac +autoheader --force +automake --force --add-missing --copy +#autoreconf not wanted + +#Check what the EPICS RELEASE IS from ${EPICS}/base +#Used by ./configure +#Assumes format ${EPICS}/base-3.14.12 +#source cafeVersion-gcc-7.3.0 +CAFE_V="cafe-1.15.1" +#For later check of existence of HOST_ARCH for $EPICS/include/os/$HOST_ARCH +#Assume Linux but check if Darwin +CAFE_HOST_FLAG_DARWIN=$(echo ${EPICS_HOST_ARCH} | grep -c "Darwin") +export CAFE_HOST_FLAG_DARWIN=$CAFE_HOST_FLAG_DARWIN + +RETURN_ON_WRONG_INPUT=true +RETURN_FLAG=false + +EPICS_BASE=$(readlink ${EPICS}/base) +#EB=$(readlink /afs/psi.ch/project/cafe/gitworkspace/CAFE/cpp/base) +echo $EPICS_BASE +if [ -z "$EPICS_BASE" ] +then + EPICS_BASE='base-7' #7.0 = 7+0 = 7 for major release +fi + +echo 'input' "$0" "$1" "$2" +echo $EPICS_BASE + +FACILITY=$(echo "$1" | tr '[:upper:]' '[:lower:]') +CACLIENT=$(echo "$2" | tr '[:upper:]' '[:lower:]') + +FACILITY_DEFAULT="sf" +CACLIENT_DEFAULT="python" + +FACILITY_TEMP="" +CACLIENT_TEMP="" + +echo 'input arg. facility/target' $FACILITY $CACLIENT + +if [ -n "$FACILITY" ] +then + if [ "$FACILITY" = "matlab" ] || [ "$FACILITY" = "python" ] || \ + [ "$FACILITY" = "py310" ] || [ "$FACILITY" = "py38" ] || \ + [ "$FACILITY" = "py37" ] || [ "$FACILITY" = "py35" ] || \ + [ "$FACILITY" = "julia" ] || [ "$FACILITY" = "cpp" ] || \ + [ "$FACILITY" = "cc" ] || [ "$FACILITY" = "py34" ] + then + CACLIENT_TEMP=$FACILITY + FACILITY_TEMP=$2 + fi +fi + +if [ -n "$CACLIENT" ] +then + if [ "$CACLIENT" = "sls" ] || [ "$CACLIENT" = "sls2" ] || \ + [ "$CACLIENT" = "sf" ] || [ "$CACLIENT" = "swissfel" ] || \ + [ "$CACLIENT" = "sfel" ] || [ "$CACLIENT" = "hipa" ] + then + if [ -z $FACILITY_TEMP ] + then + FACILITY_TEMP=$CACLIENT + CACLIENT_TEMP=$1 + fi + fi +fi + + + +if [ -z "$FACILITY" ] +then + FACILITY="sf" + echo "FACILITY = " $FACILITY + if [ -z $CACLIENT ] + then + CACLIENT=$CACLIENT_DEFAULT + fi +elif [ "$FACILITY" = "sls" ] || [ "$FACILITY" = "sls2" ] || \ + [ "$FACILITY" = "sf" ] || [ "$FACILITY" = "swissfel" ] || \ + [ "$FACILITY" = "sfel" ] || [ "$FACILITY" = "hipa" ] +then + echo "FACILITY = " $FACILITY +elif [ -n "$FACILITY_TEMP" ] +then + if [ "$FACILITY_TEMP" = "sls" ] || [ "$FACILITY_TEMP" = "sls2" ] || \ + [ "$FACILITY_TEMP" = "sf" ] || [ "$FACILITY_TEMP" = "swissfel" ] || \ + [ "$FACILITY_TEMP" = "sfel" ] || [ "$FACILITY_TEMP" = "hipa" ] + then + + + FACILITY=$FACILITY_TEMP + else + if [ -n "$2" ] + then + echo "***UNRECOGNIZED INPUT FACILITY***" $FACILITY + echo "***VALID VALUES ARE: sls sls2 sf hipa" + RETURN_FLAG=true + fi + echo "***OTHERWISE THE DEFAULT FACILITY IS:" $FACILITY_DEFAULT + FACILITY=$FACILITY_DEFAULT + fi +else + echo "***UNRECOGNIZED INPUT FACILITY***" $FACILITY + echo "***VALID VALUES ARE: sls sls2 sf hipa" + RETURN_FLAG=true + echo "***OTHERWISE THE DEFAULT FACILITY IS: " $FACILITY_DEFAULT + FACILITY=$FACILITY_DEFAULT +fi + +if [ -n "$CACLIENT" ] +then + if [ "$CACLIENT" = "matlab" ] || [ "$CACLIENT" = "python" ] || \ + [ "$CACLIENT" = "py310" ] || [ "$CACLIENT" = "py38" ] || \ + [ "$CACLIENT" = "py37" ] || [ "$CACLIENT" = "py35" ] || \ + [ "$CACLIENT" = "julia" ] || [ "$CACLIENT" = "cpp" ] || \ + [ "$CACLIENT" = "cc" ] || [ "$CACLIENT" = "py34" ] + then + echo "CA TARGET = " $CACLIENT + else + if [ -n "$CACLIENT_TEMP" ] + then + if [ "$CACLIENT_TEMP" = "matlab" ] || [ "$CACLIENT_TEMP" = "python" ] || \ + [ "$CACLIENT_TEMP" = "py310" ] || [ "$CACLIENT_TEMP" = "py38" ] || \ + [ "$CACLIENT_TEMP" = "py37" ] || [ "$CACLIENT_TEMP" = "py35" ] || \ + [ "$CACLIENT_TEMP" = "julia" ] || [ "$CACLIENT_TEMP" = "cpp" ] || \ + [ "$CACLIENT_TEMP" = "cc" ] || [ "$CACLIENT_TEMP" = "py34" ] + then + CACLIENT=$CACLIENT_TEMP + else + echo "***UNRECOGNIZED INPUT CA TARGET***" $CACLIENT + echo "***VALID VALUES ARE: cpp matlab python" + RETURN_FLAG=true + echo "***OTHERWISE THE DEFAULT CA TARGET IS:" $CACLIENT_DEFAULT + CACLIENT=$CACLIENT_DEFAULT + fi + else + echo "***UNRECOGNIZED INPUT CA TARGET***" $CACLIENT + echo "***VALID VALUES ARE: cpp matlab python" + RETURN_FLAG=true + echo "***OTHERWISE THE DEFAULT CA TARGET IS:" $CACLIENT_DEFAULT + CACLIENT=$CACLIENT_DEFAULT + fi + fi +else + CACLIENT=$CACLIENT_DEFAULT +fi + + + +if [ $RETURN_ON_WRONG_INPUT = true ] ; then + if [ $RETURN_FLAG = true ] ; then + return 1 2>/dev/null + exit 1 + fi +fi + +echo "FACILITY SELECTED = " $FACILITY +echo "CA TARGET SELECTED = " $CACLIENT + +ENABLE_OPTIONS="--enable-boost-inc" + +if [ "$FACILITY" = "sfel" ] || [ "$FACILITY" = "swissfel" ] +then + FACILITY="sf" +fi + +if [ "$CACLIENT" = "python" ] || [ "$CACLIENT" = "julia" ] +then + CACLIENT="py37" +fi + + +if [ "$FACILITY" = "sls2" ] +then + ENABLE_OPTIONS+=" --enable-epics7" + #CAFE_V+="-sls2" +else + ENABLE_OPTIONS+=" --enable-epics3" + if [ "$FACILITY" = "sf" ] && [ "$CACLIENT" != "matlab" ] + then + CAFE_V+="-sf" + elif [ "$FACILITY" = "sls" ] && [ "$CACLIENT" != "matlab" ] + then + CAFE_V+="-epics3" + fi + +fi + + +if [ "$CACLIENT" = "py34" ] +then + ENABLE_OPTIONS+=" --enable-python34" + ENABLE_OPTIONS+=" --enable-qt4py34" + CAFE_V+="-py34" +elif [ "$CACLIENT" = "py35" ] +then + ENABLE_OPTIONS+=" --enable-python35" + ENABLE_OPTIONS+=" --enable-qt4" + CAFE_V+="-py35" +elif [ "$CACLIENT" = "py37" ] +then + ENABLE_OPTIONS+=" --enable-python37" + ENABLE_OPTIONS+=" --enable-qt5" + CAFE_V+="-py37" +elif [ "$CACLIENT" = "py38" ] +then + ENABLE_OPTIONS+=" --enable-python38" + ENABLE_OPTIONS+=" --enable-qt5py38" + CAFE_V+="-py38" +elif [ "$CACLIENT" = "py310" ] +then + ENABLE_OPTIONS+=" --enable-python310" + #ENABLE_OPTIONS+=" --enable-qt5py310" + CAFE_V+="-py310" +else + ENABLE_OPTIONS+=" --enable-qt5" +fi + +if [ "$FACILITY" = "sf" ] && [ "$CACLIENT" != "matlab" ] +then + #rm -f src/PyCafe.cpp + #ln -s PyCafe3.cpp src/PyCafe.cpp + ENABLE_OPTIONS+=" --enable-json" + ENABLE_OPTIONS+=" --enable-zeromq" + ENABLE_OPTIONS+=" --enable-curl" + ENABLE_OPTIONS+=" --enable-lz4" +#else + #rm -f src/PyCafe.cpp + #ln -s PyCafe_sls.cpp src/PyCafe.cpp +fi + +CAFE_V+="-gcc-"$GCC_VERSION + +echo "$CAFE_V" + +#echo 'EPICS BASE IS='$EPICS_BASE +#echo 'EPICS BASE DIR='${EPICS}/base-7.0.4.1 + +EB1=$(echo $EPICS_BASE | sed -e "s/[a-zA-Z]*-//g") +EBMAJ=$(echo $EB1 | sed -e "s/[[:punct:]].*//g") +EBMIN1=$(echo $EB1 | sed -e "s/^[[:digit:]]*[[:punct:]]//g") +EBMIN=$(echo $EBMIN1 | sed -e "s/[[:punct:]][[:digit:]]*//g") +EBPAT=$(echo $EB1 | sed -e "s/[[:digit:]]*[[:punct:]]//g") +echo EPICS_MAJOR=$EBMAJ +echo EPICS_MINOR=$EBMIN +echo EPICS_PATCH=$EBPAT +#echo $EBMIN1 + +export CAFE_EPICS_V_MAJOR=$EBMAJ +export CAFE_EPICS_V_MINOR=$EBMIN +export CAFE_EPICS_V_PATCH=$EBPAT + +#ENABLE_OPTIONS+=" --enable-qt5" +##ENABLE_OPTIONS+=" --enable-qt4" +#ENABLE_OPTIONS+=" --enable-python37" +##ENABLE_OPTIONS+=" --enable-python35" +#ENABLE_OPTIONS+=" --enable-json" +#ENABLE_OPTIONS+=" --enable-zeromq" +#ENABLE_OPTIONS+=" --enable-curl" +#ENABLE_OPTIONS+=" --enable-lz4" + +echo 'ENABLE_OPTIONS='$ENABLE_OPTIONS + +./configure \ + --prefix=/opt/gfa/cafe/cpp/${CAFE_V} \ + --libdir=/opt/gfa/cafe/cpp/${CAFE_V}/lib/${EPICS_HOST_ARCH} \ + ${ENABLE_OPTIONS} \ + --with-boost-inc=/opt/gfa/cafe/boost/boost_1_61_0/include \ + --with-epics3=${EPICS}/base \ + --with-python310=/ioc/python/latest \ + --with-python38=/opt/gfa/python-3.8/latest \ + --with-python37=/opt/gfa/python-3.7/latest \ + --with-python35=/opt/gfa/python-3.5/latest \ + --with-python34=/opt/psi/Programming/psi-python34/2.1.0 \ + --with-qt5py310=/ioc/python/latest \ + --with-qt5py38=/opt/gfa/python-3.8/latest \ + --with-qt5=/opt/gfa/python-3.7/latest \ + --with-qt4=/opt/gfa/python-3.5/latest \ + --with-qt4py34=/opt/psi/Programming/psi-python34/2.1.0 \ + --with-json=/sf/bd/deps/zmq/json/jsoncpp-src-0.6.0-rc2 \ + --with-zeromq=/sf/bd/deps/zmq/zeromq-4.2.3-gcc-6.3.0 \ + --with-curl=/sf/bd/deps/zmq/curl-7.55.1 \ + --with-lz4=/sf/bd/deps/zmq/lz4/lib \ + --with-epics7=${EPICS}/base-7.0.6 +unset CAFE_EPICS_V_PATCH +unset CAFE_EPICS_V_MINOR +unset CAFE_EPICS_V_MAJOR + +unset CAFE_HOST_FLAG_DARWIN + diff --git a/autogen_slsbd.sh- b/autogen_slsbd.sh- new file mode 100644 index 0000000..0715e81 --- /dev/null +++ b/autogen_slsbd.sh- @@ -0,0 +1,286 @@ +### psi specific - select compiler +#source +# default is sf +# +module unload gcc +module load gcc/7.3.0 +### psi specific - end + +rm -f configure.ac +ln -s configurePSI.ac configure.ac + +rm -f ./aclocal.m4 +rm -rf ./autom4te.cache +aclocal --force -I m4 +/opt/gfa/python-3.7/latest/bin/libtoolize --force --copy #select libtools 2.4.6 +autoconf --force #interprets configure.ac +autoheader --force +automake --force --add-missing --copy +#autoreconf not wanted + +#Check what the EPICS RELEASE IS from ${EPICS}/base +#Used by ./configure +#Assumes format ${EPICS}/base-3.14.12 +#source cafeVersion-gcc-7.3.0 +CAFE_V="cafe-1.15.1" +#For later check of existence of HOST_ARCH for $EPICS/include/os/$HOST_ARCH +#Assume Linux but check if Darwin +CAFE_HOST_FLAG_DARWIN=$(echo ${EPICS_HOST_ARCH} | grep -c "Darwin") +export CAFE_HOST_FLAG_DARWIN=$CAFE_HOST_FLAG_DARWIN + +RETURN_ON_WRONG_INPUT=true +RETURN_FLAG=false + +EPICS_BASE=$(readlink ${EPICS}/base) +#EB=$(readlink /afs/psi.ch/project/cafe/gitworkspace/CAFE/cpp/base) +echo $EPICS_BASE +if [ -z "$EPICS_BASE" ] +then + EPICS_BASE='base-7.4.1' #7.0 = 7+0 = 7 for major release +fi + +echo 'input' "$0" "$1" "$2" +echo $EPICS_BASE + +FACILITY=$(echo "$1" | tr '[:upper:]' '[:lower:]') +CACLIENT=$(echo "$2" | tr '[:upper:]' '[:lower:]') + +FACILITY_DEFAULT="sf" +CACLIENT_DEFAULT="python" + +FACILITY_TEMP="" +CACLIENT_TEMP="" + +echo 'input arg. facility/target' $FACILITY $CACLIENT + +if [ -n "$FACILITY" ] +then + if [ "$FACILITY" = "matlab" ] || [ "$FACILITY" = "python" ] || \ + [ "$FACILITY" = "py37" ] || [ "$FACILITY" = "py35" ] || \ + [ "$FACILITY" = "julia" ] || [ "$FACILITY" = "cpp" ] || \ + [ "$FACILITY" = "cc" ] + then + CACLIENT_TEMP=$FACILITY + FACILITY_TEMP=$2 + fi +fi + +if [ -n "$CACLIENT" ] +then + if [ "$CACLIENT" = "sls" ] || [ "$CACLIENT" = "sls2" ] || \ + [ "$CACLIENT" = "sf" ] || [ "$CACLIENT" = "swissfel" ] || \ + [ "$CACLIENT" = "sfel" ] || [ "$CACLIENT" = "hipa" ] + then + if [ -z $FACILITY_TEMP ] + then + FACILITY_TEMP=$CACLIENT + CACLIENT_TEMP=$1 + fi + fi +fi + + + +if [ -z "$FACILITY" ] +then + FACILITY="sf" + echo "FACILITY = " $FACILITY + if [ -z $CACLIENT ] + then + CACLIENT=$CACLIENT_DEFAULT + fi +elif [ "$FACILITY" = "sls" ] || [ "$FACILITY" = "sls2" ] || \ + [ "$FACILITY" = "sf" ] || [ "$FACILITY" = "swissfel" ] || \ + [ "$FACILITY" = "sfel" ] || [ "$FACILITY" = "hipa" ] +then + echo "FACILITY = " $FACILITY +elif [ -n "$FACILITY_TEMP" ] +then + if [ "$FACILITY_TEMP" = "sls" ] || [ "$FACILITY_TEMP" = "sls2" ] || \ + [ "$FACILITY_TEMP" = "sf" ] || [ "$FACILITY_TEMP" = "swissfel" ] || \ + [ "$FACILITY_TEMP" = "sfel" ] || [ "$FACILITY_TEMP" = "hipa" ] + then + + + FACILITY=$FACILITY_TEMP + else + if [ -n "$2" ] + then + echo "***UNRECOGNIZED INPUT FACILITY***" $FACILITY + echo "***VALID VALUES ARE: sls sls2 sf hipa" + RETURN_FLAG=true + fi + echo "***OTHERWISE THE DEFAULT FACILITY IS:" $FACILITY_DEFAULT + FACILITY=$FACILITY_DEFAULT + fi +else + echo "***UNRECOGNIZED INPUT FACILITY***" $FACILITY + echo "***VALID VALUES ARE: sls sls2 sf hipa" + RETURN_FLAG=true + echo "***OTHERWISE THE DEFAULT FACILITY IS: " $FACILITY_DEFAULT + FACILITY=$FACILITY_DEFAULT +fi + +if [ -n "$CACLIENT" ] +then + if [ "$CACLIENT" = "matlab" ] || [ "$CACLIENT" = "python" ] || \ + [ "$CACLIENT" = "py37" ] || [ "$CACLIENT" = "py35" ] || \ + [ "$CACLIENT" = "julia" ] || [ "$CACLIENT" = "cpp" ] || \ + [ "$CACLIENT" = "cc" ] + then + echo "CA TARGET = " $CACLIENT + else + if [ -n "$CACLIENT_TEMP" ] + then + if [ "$CACLIENT_TEMP" = "matlab" ] || [ "$CACLIENT_TEMP" = "python" ] || \ + [ "$CACLIENT_TEMP" = "py37" ] || [ "$CACLIENT_TEMP" = "py35" ] || \ + [ "$CACLIENT_TEMP" = "julia" ] || [ "$CACLIENT_TEMP" = "cpp" ] || \ + [ "$CACLIENT_TEMP" = "cc" ] + then + CACLIENT=$CACLIENT_TEMP + else + echo "***UNRECOGNIZED INPUT CA TARGET***" $CACLIENT + echo "***VALID VALUES ARE: cpp matlab python" + RETURN_FLAG=true + echo "***OTHERWISE THE DEFAULT CA TARGET IS:" $CACLIENT_DEFAULT + CACLIENT=$CACLIENT_DEFAULT + fi + else + echo "***UNRECOGNIZED INPUT CA TARGET***" $CACLIENT + echo "***VALID VALUES ARE: cpp matlab python" + RETURN_FLAG=true + echo "***OTHERWISE THE DEFAULT CA TARGET IS:" $CACLIENT_DEFAULT + CACLIENT=$CACLIENT_DEFAULT + fi + fi +else + CACLIENT=$CACLIENT_DEFAULT +fi + + + +if [ $RETURN_ON_WRONG_INPUT = true ] ; then + if [ $RETURN_FLAG = true ] ; then + return 1 2>/dev/null + exit 1 + fi +fi + +echo "FACILITY SELECTED = " $FACILITY +echo "CA TARGET SELECTED = " $CACLIENT + +ENABLE_OPTIONS="--enable-boost-inc" + +if [ "$FACILITY" = "sfel" ] || [ "$FACILITY" = "swissfel" ] +then + FACILITY="sf" +fi + +if [ "$CACLIENT" = "python" ] || [ "$CACLIENT" = "julia" ] +then + CACLIENT="py37" +fi + + +if [ "$FACILITY" = "sls2" ] +then + ENABLE_OPTIONS+=" --enable-epics7" + CAFE_V+="-sls2" +else + ENABLE_OPTIONS+=" --enable-epics3" + if [ "$FACILITY" = "sf" ] && [ "$CACLIENT" != "matlab" ] + then + CAFE_V+="-sf" + fi +fi + +if [ "$CACLIENT" = "py35" ] +then + ENABLE_OPTIONS+=" --enable-python35" + ENABLE_OPTIONS+=" --enable-qt4" + CAFE_V+="-py35" +elif [ "$CACLIENT" = "py37" ] +then + ENABLE_OPTIONS+=" --enable-python37" + ENABLE_OPTIONS+=" --enable-qt5" + CAFE_V+="-py37" +#else + #ENABLE_OPTIONS+=" --enable-qt5" +elif [ "$CACLIENT" = "py34" ] +then + ENABLE_OPTIONS+=" --enable-python34" + ENABLE_OPTIONS+=" --enable-qt4" + CAFE_V+="-py34" +#else + #ENABLE_OPTIONS+=" --enable-qt5" +fi + + +if [ "$FACILITY" = "sf" ] && [ "$CACLIENT" != "matlab" ] +then + #rm -f src/PyCafe.cpp + #ln -s PyCafe3.cpp src/PyCafe.cpp + ENABLE_OPTIONS+=" --enable-json" + ENABLE_OPTIONS+=" --enable-zeromq" + ENABLE_OPTIONS+=" --enable-curl" + ENABLE_OPTIONS+=" --enable-lz4" +#else + #rm -f src/PyCafe.cpp + #ln -s PyCafe_sls.cpp src/PyCafe.cpp +fi + +CAFE_V+="-gcc-"$GCC_VERSION + +echo "CAFE VERSION: $CAFE_V" + +#echo 'EPICS BASE IS='$EPICS_BASE +#echo 'EPICS BASE DIR='${EPICS}/base-7.0.4.1 + +EB1=$(echo $EPICS_BASE | sed -e "s/[a-zA-Z]*-//g") +EBMAJ=$(echo $EB1 | sed -e "s/[[:punct:]].*//g") +EBMIN1=$(echo $EB1 | sed -e "s/^[[:digit:]]*[[:punct:]]//g") +EBMIN=$(echo $EBMIN1 | sed -e "s/[[:punct:]][[:digit:]]*//g") +EBPAT=$(echo $EB1 | sed -e "s/[[:digit:]]*[[:punct:]]//g") +echo EPICS_MAJOR=$EBMAJ +echo EPICS_MINOR=$EBMIN +echo EPICS_PATCH=$EBPAT +#echo $EBMIN1 + +export CAFE_EPICS_V_MAJOR=$EBMAJ +export CAFE_EPICS_V_MINOR=$EBMIN +export CAFE_EPICS_V_PATCH=$EBPAT + +#ENABLE_OPTIONS+=" --enable-qt5" +##ENABLE_OPTIONS+=" --enable-qt4" +#ENABLE_OPTIONS+=" --enable-python37" +##ENABLE_OPTIONS+=" --enable-python35" +#ENABLE_OPTIONS+=" --enable-json" +#ENABLE_OPTIONS+=" --enable-zeromq" +#ENABLE_OPTIONS+=" --enable-curl" +#ENABLE_OPTIONS+=" --enable-lz4" + +echo 'ENABLE_OPTIONS='$ENABLE_OPTIONS +echo 'EPICS='${EPICS} + +./configure \ + --prefix=/opt/gfa/cafe/cpp/${CAFE_V} \ + --libdir=/opt/gfa/cafe/cpp/${CAFE_V}/lib/${EPICS_HOST_ARCH} \ + ${ENABLE_OPTIONS} \ + --with-boost-inc=/afs/psi.ch/project/cafe/gitlab/CAFE/boost/boost_1_61_0/include \ + --with-epics7=${EPICS}/base-7.0.4.1 \ + --with-epics3=${EPICS}/base \ + --with-python37=/opt/gfa/python-3.7/latest \ + --with-python35=/opt/gfa/python-3.5/latest \ + --with-python34=/opt/psi/Programming/psi-python34/2.1.0 \ + --with-qt5=/opt/gfa/python-3.7/latest \ + --with-qt4=/opt/gfa/python-3.5/latest \ + --with-json=/opt/gfa/zmsglog/json/jsoncpp-src-0.6.0-rc2 \ + --with-zeromq=/opt/gfa/zmq/zeromq-4.2.3-gcc-6.3.0 \ + --with-curl=/opt/gfa/zmq/curl-7.55.1 \ + --with-lz4=/opt/gfa/zmq/lz4/lib + +unset CAFE_EPICS_V_PATCH +unset CAFE_EPICS_V_MINOR +unset CAFE_EPICS_V_MAJOR + +unset CAFE_HOST_FLAG_DARWIN diff --git a/configurePSI.ac b/configurePSI.ac index 22946be..3c63c36 100644 --- a/configurePSI.ac +++ b/configurePSI.ac @@ -9,7 +9,7 @@ # Standard macros AC_PREREQ(2.63) AC_COPYRIGHT([CAFE,Jan Chrin, 2010-2021]) -AC_INIT([CAFE], [1.15.0], [Bug reports to: jan.chrin@psi.ch]) +AC_INIT([CAFE], [1.15.1], [Bug reports to: jan.chrin@psi.ch]) AC_CONFIG_AUX_DIR(./) diff --git a/configurePSI.ac-Mar10 b/configurePSI.ac-Mar10 new file mode 100644 index 0000000..54a8d3f --- /dev/null +++ b/configurePSI.ac-Mar10 @@ -0,0 +1,1191 @@ +## CAFE (Channel Access interFacE) +## Author: Jan Chrin, GFA, PSI +## +## configure.ac is processed by autoconf +## +## output: configure.in file for building the cafe library +## + +# Standard macros +AC_PREREQ(2.63) +AC_COPYRIGHT([CAFE,Jan Chrin, 2010-2021]) +AC_INIT([CAFE], [1.15.0], [Bug reports to: jan.chrin@psi.ch]) + +AC_CONFIG_AUX_DIR(./) + +AC_CONFIG_MACRO_DIR([m4]) +m4_pattern_allow([AC_CONFIG_MACRO]) + +AM_INIT_AUTOMAKE([gnu subdir-objects]) +AC_CONFIG_SRCDIR([./include/cafe.h]) + +AC_LANG_CPLUSPLUS + +AC_CONFIG_HEADER([./include/config.h:./include/config.in]) +AC_PROG_CXX + +# library creation +AC_PROG_LIBTOOL +AM_PROG_LIBTOOL + +LT_PREREQ([2.4.6]) +LT_INIT + + +#AX_CHECK_COMPILE_FLAG([-std=c++14], [CPPFLAGS="$CPPFLAGS -std=c++14"]) + +AC_LANG([C++]) + +AC_DEFINE_UNQUOTED(HAVE_LINUX, 1, [linux dependency (sleep)]) + +CPPFLAGS=" -fexceptions -fPIC -std=c++1z" + +# provide include directories +AC_SUBST([CAFE_CPPFLAGS], '-I$(top_srcdir)/include ') + +##--------------------------------------------------------------------------- +##-- EPICS -- path and options +## +EPICS_PREFIX="" +EPICS_INCL_PATH="" +EPICS_LIB_PATH="" + + + +## Host Arch +if test x"${HOST_ARCH}" == x""; then + HOST_ARCH=Linux + #echo ${EPICS_HOST_ARCH} | grep -c 'SL6' + #echo ${EPICS_HOST_ARCH} | grep -c 'darwin' + if test x"${CAFE_HOST_FLAG_DARWIN}" == x"1"; then + HOST_ARCH=Darwin + fi + echo "HOST_ARCH="${HOST_ARCH} +fi + +echo "HOST_ARCH="${HOST_ARCH} + + +AC_ARG_ENABLE( + [epics3], + AC_HELP_STRING([--enable-epics3], + [enable epics use [default=no]]), + [HAVE_EPICS=true + HAVE_EPICS_3=true] +) + + +AC_ARG_ENABLE( + [epics7], + AC_HELP_STRING([--enable-epics7], + [enable epics use [default=no]]), + [HAVE_EPICS=true + HAVE_EPICS_7=true] +) + +if test x$HAVE_EPICS_3 == xtrue ; then + AC_ARG_WITH( + epics3, + AC_HELP_STRING( + [--with-epics3 location of EPICS], + [prefix where the epics libraries and include files are to be found]), + [#HAVE_EPICS=true + EPICS_PREFIX=$withval + EPICS_INCL_PATH="-I"${EPICS_PREFIX}"/include/ \ +-I"${EPICS_PREFIX}"/include/os/"${HOST_ARCH} + EPICS_LIB_PATH=${EPICS_PREFIX}"/lib/"${EPICS_HOST_ARCH} + ## Add epics release + EPICS_MAJOR_DEFAULT="3" + EPICS_MINOR_DEFAULT="14" + EPICS_PATCH_DEFAULT="12" + ] +) +fi + +if test x$HAVE_EPICS_7 == xtrue ; then + AC_ARG_WITH( + epics7, + AC_HELP_STRING( + [--with-epics7 location of EPICS], + [prefix where the epics libraries and include files are to be found]), + [#HAVE_EPICS=true + EPICS_PREFIX=$withval + EPICS_INCL_PATH="-I"${EPICS_PREFIX}"/include/ \ +-I"${EPICS_PREFIX}"/include/os/"${HOST_ARCH} + EPICS_INCL_PATH=${EPICS_INCL_PATH}" \ +-I"${EPICS_PREFIX}"/include/compiler/gcc" + EPICS_LIB_PATH=${EPICS_PREFIX}"/lib/"${EPICS_HOST_ARCH} + ## Add epics release + EPICS_MAJOR_DEFAULT="7" + EPICS_MINOR_DEFAULT="4" + EPICS_PATCH_DEFAULT="1" + ] +) +fi + +EPICS_MAJOR_REL=${EPICS_MAJOR_DEFAULT} +EPICS_MINOR_REL=${EPICS_MINOR_DEFAULT} +EPICS_PATCH_REL=${EPICS_PATCH_DEFAULT} + +#overwrite default with actual if determined +if test x"${CAFE_EPICS_V_MAJOR}" != x""; then + EPICS_MAJOR_REL=${CAFE_EPICS_V_MAJOR} +fi +if test x"${CAFE_EPICS_V_MINOR}" != x""; then + EPICS_MINOR_REL=${CAFE_EPICS_V_MINOR} +fi +if test x"${CAFE_EPICS_V_PATCH}" != x""; then + EPICS_PATCH_REL=${CAFE_EPICS_V_PATCH} +fi + +echo EPICS_MAJOR=$EPICS_MAJOR_REL +echo EPICS_MINOR=$EPICS_MINOR_REL +echo EPICS_PATCH=$EPICS_PATCH_REL + + +#echo "TEST ", $EPICS_LIB_PATH +## +##-- end EPICS -- path and options +##--------------------------------------------------------------------------- + +##=========================================================================== +##== Check for header files and libraries. +##=========================================================================== + +##--------------------------------------------------------------------------- +##-- EPICS -- check header files and libs +## +AC_LANG_PUSH([C++]) + +if test x$HAVE_EPICS == xtrue; then + + # Change flags: if all tests are successfull, accept these changes; if + # the tests are not successfull, use the old flags. + if test x"${EPICS_PREFIX}" != x"" ; then + TEMP_CPPFLAGS=${CPPFLAGS} + CPPFLAGS=${CPPFLAGS}" "${EPICS_INCL_PATH} + TEMP_LDFLAGS=${LDFLAGS} + LDFLAGS=${LDFLAGS}" -L"${EPICS_LIB_PATH}" -Wl,-rpath,"${EPICS_LIB_PATH} + #LDFLAGS=${LDFLAGS}" -L/opt/psi/Programming/gcc/7.3.0/lib64 -Wl,-rpath,/opt/psi/Programming/gcc/7.3.0/lib64" + #LDFLAGS=${LDFLAGS}" -L/opt/psi/Programming/gcc/7.3.0/lib -Wl,-rpath,/opt/psi/Programming/gcc/7.3.0/lib" + fi + + if test x$HAVE_EPICS == xtrue ; then + AC_CHECK_HEADERS( + [cadef.h], + [HAVE_EPICS=true], + [HAVE_EPICS=true + AC_MSG_WARN(cadef.h not not found!)], + []) + fi + + if test x$HAVE_EPICS == xtrue ; then + AC_CHECK_HEADERS( + [epicsTypes.h], + [HAVE_EPICS=true], + [HAVE_EPICS=true + AC_MSG_WARN(epicsTypes.h not found!)], + []) + fi + + if test x$HAVE_EPICS == xtrue ; then + AC_CHECK_LIB(ca,[main], + [HAVE_EPICS=true], + [HAVE_EPICS=false + AC_MSG_WARN(libca either not found or not operational!)]) + fi + + if test x$HAVE_EPICS == xtrue ; then + AC_CHECK_LIB(Com,[main], + [HAVE_EPICS=true], + [HAVE_EPICS=false + AC_MSG_WARN(libCom either not found or not operational!)]) + fi + + if test x$HAVE_EPICS == xtrue ; then + AC_CHECK_LIB(dl,[main], + [HAVE_EPICS=true], + [HAVE_EPICS=false + AC_MSG_WARN(libdl either not found or not operational!)]) + fi + + # If all checks are OK we add rlog to the CXXFLAGS. + if test x$HAVE_EPICS != xtrue ; then + + if test x"${EPICS_PREFIX}" != x"" ; then + CPPFLAGS=${TEMP_CPPFLAGS} + LDFLAGS=${TEMP_LDFLAGS} + fi + fi + + echo "LDFLAGS__> $LDFLAGS " + + if test x$HAVE_EPICS == xtrue ; then + AC_DEFINE_UNQUOTED(HAVE_EPICS, ${EPICS_MAJOR_REL}.${EPICS_MINOR_REL}.${EPICS_PATCH_REL},[epics version]) + AC_DEFINE_UNQUOTED(EPICS_MAJOR,${EPICS_MAJOR_REL}, [epics major release]) + AC_DEFINE_UNQUOTED(EPICS_MINOR,${EPICS_MINOR_REL}, [epics minor release]) + AC_DEFINE_UNQUOTED(EPICS_PATCH,${EPICS_PATCH_REL}, [epics patch release]) + echo "EPICS PATH ====================================>" ${EPICS_INCL_PATH} + echo "EPICS LIB ====================================>" ${EPICS_LIB_PATH} + fi +fi + +AC_LANG_POP + +## +##-- end EPICS -- check header files and libs +##--------------------------------------------------------------------------- + + +##--------------------------------------------------------------------------- +##-- BOOST -- path and options - +##-- Boost libraries are mainly header-only, i.e. they consist of header files +##-- containing templates and inline functions, and require no separately-compiled +##-- library binaries or special treatment when linking +## +BOOST_PREFIX="" +BOOST_INCL_PATH="" +BOOST_LIB_PATH="" +BOOST_OPTION="" + +AC_ARG_ENABLE( + [boost-inc], + AC_HELP_STRING([--enable-boost-inc], + [enable boost use [default=no]]), + [HAVE_BOOST_=true] +) + +AC_ARG_WITH( + boost-inc, + AC_HELP_STRING([--with-boost-inc = location of BOOST], + [prefix giving the boost base directory]), + [#HAVE_BOOST_=true + BOOST_PREFIX=$withval + BOOST_INCL_PATH="-I"${BOOST_PREFIX}"/boost -I"${BOOST_PREFIX} + ] +) + +AC_ARG_ENABLE( + [boost-lib], + AC_HELP_STRING([--enable-boost-lib], + [enable boost lib use [default=no]]), + [HAVE_BOOST_LIB_=true] +) + +AC_ARG_WITH( + boost-lib, + AC_HELP_STRING([--with-boost-lib = location of BOOST], + [prefix giving the boost base directory]), + [#HAVE_BOOST_LIB=true + BOOST_LIB_PATH=$withval + ] +) + +## +##-- end BOOST -- path and options +##--------------------------------------------------------- + + + +##--------------------------------------------------------------------------- +##-- BOOST -- check header files (and lib if selected) only +## +AC_LANG_PUSH([C++]) + +if test x$HAVE_BOOST_LIB_ == xtrue ; then + + TEMP_LDFLAGS=${LDFLAGS} + LDFLAGS=${LDFLAGS}" -L"${BOOST_LIB_PATH}" -Wl,-rpath,"${BOOST_LIB_PATH} + #echo ${BOOST_LIB_PATH} + #echo ${LDFLAGS} + + if test x$HAVE_BOOST_LIB_ == xtrue ; then + AC_CHECK_LIB(boost_thread,[main], + [], + [HAVE_BOOST_LIB=false + AC_MSG_WARN(boost_thread not found!)]) + fi + + # If all checks are OK we add boost lib version to the FLAGS. + if test x$HAVE_BOOST_LIB_ != xtrue ; then + LDFLAGS=${TEMP_LDFLAGS} + fi + + if test x$HAVE_BOOST_LIB_ == xtrue ; then + AC_DEFINE_UNQUOTED(HAVE_BOOST_THREAD, 1, [boost thread library]) + fi +fi + + +if test x$HAVE_BOOST_ == xtrue ; then + + # Change flags: if all tests are successful, accept these additions, + # else use the old flags. + if test x"${BOOST_PREFIX}" != x"" ; then + TEMP_CPPFLAGS=${CPPFLAGS} + CPPFLAGS=${CPPFLAGS}" "${BOOST_INCL_PATH} + echo ${BOOST_INCL_PATH} + echo ${CPPFLAGS} + fi + + if test x$HAVE_BOOST_ == xtrue ; then + AC_CHECK_HEADERS( + [multi_index_container.hpp], + [HAVE_BOOST_=true], + [HAVE_BOOST_=false + AC_MSG_WARN(multi_index_container.hpp not found!)], + []) + fi + + if test x$HAVE_BOOST_ != xtrue ; then + if test x"${BOOST_PREFIX}" != x"" ; then + CPPFLAGS=${TEMP_CPPFLAGS} + echo ${CPPFLAGS} + fi + fi + + if test x$HAVE_BOOST_ == xtrue ; then + AC_DEFINE_UNQUOTED(HAVE_BOOST, 1, [Availability of boost]) + echo "BOOST PATH ====================================>" ${BOOST_INCL_PATH} + fi +fi + +AC_LANG_POP + +## +##-- end BOOST-- check header files only +##----------------------------- + + +PYTHON_PREFIX="" +PYTHON_INCL_PATH="" +PYTHON_LIB_PATH="" +PYTHON_OPTION="" +##--------------------------------------------------------------------------- +##-- Python 3.5/3.7 -- path and options +##-- Python header files required for callbacks + + +AC_ARG_ENABLE( + [python35], + AC_HELP_STRING([--enable-python35], + [enable python use [default=no]]), + [HAVE_PYTHON_=true + HAVE_PY35_=true] +) + +if test x$HAVE_PY35_ == xtrue ; then + AC_ARG_WITH( + python35, + AC_HELP_STRING( + [--with-python35 = location of python], + [prefix giving the python base directory]), + [#HAVE_PYTHON_=true + PYTHON_PREFIX=$withval + PYTHON_INCL_PATH="-I"${PYTHON_PREFIX}/include/python3.5m + PYTHON_INCL_PATH=${PYTHON_INCL_PATH}" -I"${PYTHON_PREFIX}\ +"/lib/python3.5/site-packages/numpy/core/include" + PYTHON_LIB_PATH=${PYTHON_PREFIX}"/lib" + ] + ) +fi + +AC_ARG_ENABLE( + [python37], + AC_HELP_STRING([--enable-python37], + [enable python use [default=no]]), + [HAVE_PYTHON_=true + HAVE_PY37_=true + HAVE_PY35_=false] +) + +if test x$HAVE_PY37_ == xtrue ; then + AC_ARG_WITH( + python37, + AC_HELP_STRING( + [--with-python37 = location of python], + [prefix giving the python base directory]), + [#HAVE_PYTHON_=true + PYTHON_PREFIX=$withval + PYTHON_INCL_PATH="-I"${PYTHON_PREFIX}/include/python3.7m + PYTHON_INCL_PATH=${PYTHON_INCL_PATH}" -I"${PYTHON_PREFIX}\ +"/lib/python3.7/site-packages/numpy/core/include" + PYTHON_LIB_PATH=${PYTHON_PREFIX}"/lib" + ] + ) +fi + + +AC_ARG_ENABLE( + [python38], + AC_HELP_STRING([--enable-python38], + [enable python use [default=no]]), + [HAVE_PYTHON_=true + HAVE_PY38_=true + HAVE_PY37_=false + HAVE_PY35_=false] +) + +if test x$HAVE_PY38_ == xtrue ; then + AC_ARG_WITH( + python38, + AC_HELP_STRING( + [--with-python38 = location of python], + [prefix giving the python base directory]), + [#HAVE_PYTHON_=true + PYTHON_PREFIX=$withval + PYTHON_INCL_PATH="-I"${PYTHON_PREFIX}/include/python3.8 + PYTHON_INCL_PATH=${PYTHON_INCL_PATH}" -I"${PYTHON_PREFIX}\ +"/lib/python3.8/site-packages/numpy/core/include" + PYTHON_LIB_PATH=${PYTHON_PREFIX}"/lib" + ] + ) +fi + + +AC_ARG_ENABLE( + [python310], + AC_HELP_STRING([--enable-python310], + [enable python use [default=no]]), + [HAVE_PYTHON_=true + HAVE_PY310_=true + HAVE_PY38_=false + HAVE_PY37_=false + HAVE_PY35_=false] +) + +if test x$HAVE_PY310_ == xtrue ; then + AC_ARG_WITH( + python310, + AC_HELP_STRING( + [--with-python310 = location of python], + [prefix giving the python base directory]), + [#HAVE_PYTHON_=true + PYTHON_PREFIX=$withval + PYTHON_INCL_PATH="-I"${PYTHON_PREFIX}/include/python3.10 + PYTHON_INCL_PATH=${PYTHON_INCL_PATH}" -I"${PYTHON_PREFIX}\ +"/lib/python3.10/site-packages/numpy/core/include" + PYTHON_LIB_PATH=${PYTHON_PREFIX}"/lib" + ] + ) +fi + + + +## +##--------------------------------------------------------------------------- + + +## +##-- end PYTHON -- path and options +##--------------------------------------------------------------------------- + + + +##--------------------------------------------------------------------------- +##-- Python -- check header files and library +## +AC_LANG_PUSH([C++]) + +if test x$HAVE_PYTHON_ == xtrue ; then + + #Change flags: if all tests are successful, accept these additions, + # else use the old flags. + if test x"${PYTHON_PREFIX}" != x"" ; then + TEMP_CPPFLAGS=${CPPFLAGS} + CPPFLAGS=${CPPFLAGS}" "${PYTHON_INCL_PATH} + TEMP_LDFLAGS=${LDFLAGS} + LDFLAGS=${LDFLAGS}" -L"${PYTHON_LIB_PATH}" -Wl,-rpath,"${PYTHON_LIB_PATH} + echo ${PYTHON_INCL_PATH} + echo ${CPPFLAGS} + fi + + #if test x$HAVE_PYTHON_ == xtrue ; then + AC_CHECK_HEADERS( + [Python.h], + [HAVE_PYTHON_=true], + [HAVE_PYTHON_=false + AC_MSG_WARN(Python.h not found!)], + []) + #fi + + + if test x$HAVE_PY310_ == xtrue ; then + + AC_CHECK_LIB(python3.10,[main], [], + [HAVE_PYTHON_=false + AC_MSG_WARN(libpython3.10 not found!)] + ) + fi + + if test x$HAVE_PY38_ == xtrue ; then + + AC_CHECK_LIB(python3.8,[main], [], + [HAVE_PYTHON_=false + AC_MSG_WARN(libpython3.8 not found!)] + ) + fi + + if test x$HAVE_PY37_ == xtrue ; then + + AC_CHECK_LIB(python3.7m,[main], [], + [HAVE_PYTHON_=false + AC_MSG_WARN(libpython3.7m not found!)] + ) + fi + + if test x$HAVE_PY35_ == xtrue ; then + + AC_CHECK_LIB(python3.5m,[main], [], + [HAVE_PYTHON_=false + AC_MSG_WARN(libpython3.5m not found!)] + ) + fi + + # If all checks are OK we add Qt version 4 to the FLAGS. + + if test x$HAVE_PYTHON_ != xtrue ; then + if test x"${PYTHON_PREFIX}" != x"" ; then + CPPFLAGS=${TEMP_CPPFLAGS} + LDFLAGS=${TEMP_LDFLAGS} + echo ${CPPFLAGS} + fi + fi + + + if test x$HAVE_PYTHON_ == xtrue ; then + AC_DEFINE_UNQUOTED(HAVE_PYTHON, 1, [Availability of python]) + ##_PYCAFE_EXT IF FLAG SET ELSE USE DEFAULT PYCAFE_API_H + AC_DEFINE_UNQUOTED(HAVE_PYCAFE_EXT, 1, [pycafe extern C]) + echo "PYTHON PATH ====================================>" ${PYTHON_INCL_PATH} + echo "PYTHON LIB ====================================>" ${PYTHON_LIB_PATH} + fi +fi + +AC_LANG_POP +## +##-- end Python 3.7(3.8 -- check header files and library +##----------------------------- + + + + + +##--------------------------------------------------------------------------- +##-- Qt4/5 -- path and options +## +QT_PREFIX="" +QT_INCL_PATH="" +QT_LIB_PATH="" + + +AC_ARG_ENABLE( + [qt4], + AC_HELP_STRING([--enable-qt4], + [enable Qt version 4 use [default=no]]), + [HAVE_QT_=true + HAVE_QT_4_=true] +) + + +#Only if enable flag is set +if test x$HAVE_QT_4_ == xtrue ; then + AC_ARG_WITH( + qt4, + AC_HELP_STRING([--with-qt4=PREFIX], + [prefix, parent directory where the Qt version 4 library is installed]), + [#HAVE_QT_=true + QT_PREFIX=$withval + QT_INCL_BASE=" -I"${QT_PREFIX}"/include" + QT_INCL_PATH=${QT_INCL_BASE} + QT_INCL_PATH=${QT_INCL_PATH}" "${QT_INCL_BASE}"/QtCore" + QT_INCL_PATH=${QT_INCL_PATH}" "${QT_INCL_BASE}"/QtXml" + QT_LIB_PATH=${QT_PREFIX}"/lib " + ] + ) +fi + +AC_ARG_ENABLE( + [qt5], + AC_HELP_STRING([--enable-qt5], + [enable Qt version 5 use [default=no]]), + [HAVE_QT_=true + HAVE_QT_5_=true + HAVE_QT_4_=false] +) + + + +#Only if enable flag is set +if test x$HAVE_QT_5_ == xtrue ; then + AC_ARG_WITH( + qt5, + AC_HELP_STRING([--with-qt5=PREFIX], + [prefix, parent directory where the Qt version 5 library is installed]), + [#HAVE_QT_=true + QT_PREFIX=$withval + QT_INCL_BASE=" -I"${QT_PREFIX}"/include/qt" + QT_INCL_PATH=${QT_INCL_BASE} + QT_INCL_PATH=${QT_INCL_PATH}" "${QT_INCL_BASE}"/QtCore" + QT_INCL_PATH=${QT_INCL_PATH}" "${QT_INCL_BASE}"/QtXml" + QT_LIB_PATH=${QT_PREFIX}"/lib " + ] + ) +fi + + +AC_ARG_ENABLE( + [qt5py38], + AC_HELP_STRING([--enable-qt5py38], + [enable Qt version 5 use [default=no]]), + [HAVE_QT_=true + HAVE_QT_5py38_=true + HAVE_QT_5_=false + HAVE_QT_4_=false] +) + + +#Only if enable flag is set +if test x$HAVE_QT_5py38_ == xtrue ; then + AC_ARG_WITH( + qt5py38, + AC_HELP_STRING([--with-qt5py38=PREFIX], + [prefix, parent directory where the Qt version 5 library is installed]), + [#HAVE_QT_=true + QT_PREFIX=$withval + QT_INCL_BASE=" -I"${QT_PREFIX}"/include/qt" + QT_INCL_PATH=${QT_INCL_BASE} + QT_INCL_PATH=${QT_INCL_PATH}" "${QT_INCL_BASE}"/QtCore" + QT_INCL_PATH=${QT_INCL_PATH}" "${QT_INCL_BASE}"/QtXml" + QT_LIB_PATH=${QT_PREFIX}"/lib " + ] + ) +fi + + + +AC_ARG_ENABLE( + [qt5py310], + AC_HELP_STRING([--enable-qt5py310], + [enable Qt version 5 use [default=no]]), + [HAVE_QT_=true + HAVE_QT_5py310_=true + HAVE_QT_5py38_=false + HAVE_QT_5_=false + HAVE_QT_4_=false] +) + + +#Only if enable flag is set +if test x$HAVE_QT_5py310_ == xtrue ; then + AC_ARG_WITH( + qt5py310, + AC_HELP_STRING([--with-qt5py310=PREFIX], + [prefix, parent directory where the Qt version 5 library is installed]), + [#HAVE_QT_=true + QT_PREFIX=$withval + QT_INCL_BASE=" -I"${QT_PREFIX}"/include/qt" + QT_INCL_PATH=${QT_INCL_BASE} + QT_INCL_PATH=${QT_INCL_PATH}" "${QT_INCL_BASE}"/QtCore" + QT_INCL_PATH=${QT_INCL_PATH}" "${QT_INCL_BASE}"/QtXml" + QT_LIB_PATH=${QT_PREFIX}"/lib " + ] + ) +fi + + +## +##--------------------------------------------------------------------------- + +##--------------------------------------------------------------------------- +##-- Qt version 5 -- check header files and libs +## +AC_LANG_PUSH([C++]) + +if test x$HAVE_QT_ == xtrue ; then + + # Change flags: if all tests are successfull, accept this changes; if + # the tests are not successfull, use the old flags. + if test x"${QT_PREFIX}" != x"" ; then + TEMP_CPPFLAGS=${CPPFLAGS} + CPPFLAGS=${CPPFLAGS}" "${QT_INCL_PATH} + TEMP_LDFLAGS=${LDFLAGS} + LDFLAGS=${LDFLAGS}" -L"${QT_LIB_PATH}" -Wl,-rpath,"${QT_LIB_PATH} + fi + + + #if test x$HAVE_QT_ == xtrue ; then + AC_CHECK_HEADERS( + [qxml.h], + [HAVE_QT_=true], + [HAVE_QT_=false + AC_MSG_WARN(qxml.h not found!)], + []) + #fi + + + if test x$HAVE_QT_4_ == xtrue ; then + AC_CHECK_LIB(QtCore,[main], + [], + [HAVE_QT_=false + AC_MSG_WARN(libQtCore not found!)]) + fi + + if test x$HAVE_QT_4_ == xtrue ; then + AC_CHECK_LIB(QtXml,[main], + [], + [HAVE_QT_=false + AC_MSG_WARN(libQtXml not found!)]) + fi + + if test x$HAVE_QT_5_ == xtrue ; then + AC_CHECK_LIB(Qt5Core,[write], + [], + [HAVE_QT_=true #force true if there but not found + AC_MSG_WARN(libQt5Core not checked for!)]) + fi + + if test x$HAVE_QT_5_ == xtrue ; then + AC_CHECK_LIB(Qt5Xml,[qt_version_tag], + [], + [HAVE_QT_=true + AC_MSG_WARN(libQt5Xml not checked for!)]) + fi + + + + + # If all checks are OK we add Qt version 5 to the FLAGS. + if test x$HAVE_QT_ != xtrue ; then + if test x"${QT_PREFIX}" != x"" ; then + CPPFLAGS=${TEMP_CPPFLAGS} + LDFLAGS=${TEMP_LDFLAGS} + fi + fi + + if test x$HAVE_QT_ == xtrue ; then + AC_DEFINE_UNQUOTED(HAVE_QT, 1,[Availability of Qt version 5 confirmed]) + AC_DEFINE_UNQUOTED(HAVE_LIBQTXML, 1, [Availability of Qt version 5 confirmed]) + AC_DEFINE(QT_NO_VERSION_TAGGING, 1,[Availability of Qt version 5 confirmed]) + echo "QT PATH ====================================>" ${QT_INCL_PATH} + echo "QT LIB ====================================>" ${QT_LIB_PATH} + fi + +fi + +AC_LANG_POP +## +##-- end QT5 -- check header files and libs + + +##--------------------------------------------------------------------------- +##--------------------------------------------------------------------------- +##-- JSON -- path and options - +##-- JSON header files required +## + +JSON_PREFIX="" +JSON_INCL_PATH="" +JSON_LIB_PATH="" +JSON_OPTION="" + +AC_ARG_ENABLE( + [json], + AC_HELP_STRING([--enable-json-inc], + [enable json use [default=no]]), + [HAVE_JSON_=true] +) + + +if test x$HAVE_JSON_ == xtrue ; then + AC_ARG_WITH( + json, + AC_HELP_STRING( + [--with-json= location of json], + [prefix giving the json base directory]), + [HAVE_JSON_=true + JSON_PREFIX=$withval + JSON_INCL_PATH="-I"${JSON_PREFIX}"/include" + JSON_LIB_PATH=${JSON_PREFIX}"/libs/linux-gcc-6.3.0" + ] +) +fi +## +##-- end JSON -- path and options +##--------------------------------------------------------- + + + + +##--------------------------------------------------------------------------- +##-- JSON -- check header files only +## +AC_LANG_PUSH([C++]) + +if test x$HAVE_JSON_ == xtrue ; then + + # Change flags: if all tests are successful, accept these additions, + # else use the old flags. + if test x"${JSON_PREFIX}" != x"" ; then + TEMP_CPPFLAGS=${CPPFLAGS} + CPPFLAGS=${CPPFLAGS}" "${JSON_INCL_PATH} + TEMP_LDFLAGS=${LDFLAGS} + LDFLAGS=${LDFLAGS}" -L"${JSON_LIB_PATH}" -Wl,-rpath,"${JSON_LIB_PATH} + echo ${JSON_INCL_PATH} + echo ${CPPFLAGS} + fi + + #if test x$HAVE_JSON_ == xtrue ; then + AC_CHECK_HEADERS( + [json/json.h], + [HAVE_JSON_=true], + [HAVE_JSON_=false + AC_MSG_WARN(json.h not found!)], + []) + #fi + + + if test x$HAVE_JSON_ == xtrue ; then + AC_CHECK_LIB(json_linux-gcc-6.3.0_libmt,[main], + [], + [HAVE_JSON=false + AC_MSG_WARN(libjson_linux-gcc-6.3.0_libmt not found!)]) + fi + + + # If all checks are OK we add json to the FLAGS. + if test x$HAVE_JSON_ != xtrue ; then + if test x"${JSON_PREFIX}" != x"" ; then + CPPFLAGS=${TEMP_CPPFLAGS} + LDFLAGS=${TEMP_LDFLAGS} + echo ${CPPFLAGS} + fi + fi + + + if test x$HAVE_JSON_ == xtrue ; then + AC_DEFINE_UNQUOTED(HAVE_JSON, 1, [Availability of json]) + echo "JSON PATH ====================================>" ${JSON_INCL_PATH} + echo "JSON LIB ====================================>" ${JSON_LIB_PATH} + fi +fi + +AC_LANG_POP +## +##-- end JSON-- check header files only +##----------------------------- + +##--------------------------------------------------------------------------- +##--------------------------------------------------------------------------- +##-- Zeromq -- path and options - +##-- Zeromq header files required +## + +ZEROMQ_PREFIX="" +ZEROMQ_INCL_PATH="" +ZEROMQ_LIB_PATH="" +ZEROMQ_OPTION="" + +AC_ARG_ENABLE( + [zeromq], + AC_HELP_STRING([--enable-zeromq], + [enable zeromq use [default=no]]), + [HAVE_ZEROMQ_=true] +) + +if test x$HAVE_ZEROMQ_ == xtrue ; then + AC_ARG_WITH( + zeromq, + AC_HELP_STRING( + [--with-zeromq = location of zeromq], + [prefix giving the zeromq base directory]), + [HAVE_ZEROMQ_=true + ZEROMQ_PREFIX=$withval + ZEROMQ_INCL_PATH="-I"${ZEROMQ_PREFIX}"/include" + ZEROMQ_LIB_PATH=${ZEROMQ_PREFIX}"/lib" + ] + ) +fi + +## +##-- end ZEROMQ -- path and options +##--------------------------------------------------------- + + +##--------------------------------------------------------------------------- +##-- ZEROMQ -- check header files and library +# +AC_LANG_PUSH([C++]) + +if test x"$HAVE_ZEROMQ_" == xtrue ; then + + # Change flags: if all tests are successful, accept these additions, + # else use the old flags. + if test x"${ZEROMQ_PREFIX}" != x"" ; then + TEMP_CPPFLAGS=${CPPFLAGS} + CPPFLAGS=${CPPFLAGS}" "${ZEROMQ_INCL_PATH} + TEMP_LDFLAGS=${LDFLAGS} + LDFLAGS=${LDFLAGS}" -L"${ZEROMQ_LIB_PATH}" -Wl,-rpath,"${ZEROMQ_LIB_PATH} + echo ${ZEROMQ_INCL_PATH} + echo ${CPPFLAGS} + fi + + #if test x$HAVE_ZEROMQ_ == xtrue ; then + AC_CHECK_HEADERS( + [zmq.h], + [HAVE_ZEROMQ_=true], + [HAVE_ZEROMQ_=false + AC_MSG_WARN(zmq.h not found!)], + []) + #fi + + if test x$HAVE_ZEROMQ_ == xtrue ; then + AC_CHECK_LIB(zmq,[main], + [], + [HAVE_ZEROMQ_=false + AC_MSG_WARN(libzmq not found!)]) + fi + + + # If all checks are OK we add Zeromq to the FLAGS. + + if test x$HAVE_ZEROMQ_ != xtrue ; then + if test x"${ZEROMQ_PREFIX}" != x"" ; then + CPPFLAGS=${TEMP_CPPFLAGS} + LDFLAGS=${TEMP_LDFLAGS} + echo ${CPPFLAGS} + fi + fi + + + if test x$HAVE_ZEROMQ_ == xtrue ; then + AC_DEFINE_UNQUOTED(HAVE_ZEROMQ, 1, [Availability of zeromq]) + echo "ZMQ PATH ====================================>" ${ZEROMQ_INCL_PATH} + echo "ZMQ LIB ====================================>" ${ZEROMQ_LIB_PATH} + fi +fi + +AC_LANG_POP +## +##-- end ZEROMQ-- check header files and lib +##----------------------------- + + +##--------------------------------------------------------------------------- +##--------------------------------------------------------------------------- +##-- CURL -- path and options - +##-- CURL header files required +## + +CURL_PREFIX="" +CURL_INCL_PATH="" +CURL_LIB_PATH="" +CURL_OPTION="" + +AC_ARG_ENABLE( + [curl], + AC_HELP_STRING([--enable-curl], + [enable curl use [default=no]]), + [HAVE_CURL_=true] +) + +if test x$HAVE_CURL_ == xtrue ; then + AC_ARG_WITH( + curl, + AC_HELP_STRING( + [--with-curl = location of curl], + [prefix giving the curl base directory]), + [HAVE_CURL_=true + CURL_PREFIX=$withval + CURL_INCL_PATH="-I"${CURL_PREFIX}"/include" + CURL_LIB_PATH=${CURL_PREFIX}"/lib/.libs" + ] + ) +fi + +## +##-- end CURL -- path and options +##--------------------------------------------------------- + + +##--------------------------------------------------------------------------- +##-- CURL -- check header files only +## +AC_LANG_PUSH([C++]) + +if test x$HAVE_CURL_ == xtrue ; then + + # Change flags: if all tests are successful, accept these additions, + # else use the old flags. + if test x"${CURL_PREFIX}" != x"" ; then + TEMP_CPPFLAGS=${CPPFLAGS} + CPPFLAGS=${CPPFLAGS}" "${CURL_INCL_PATH} + TEMP_LDFLAGS=${LDFLAGS} + LDFLAGS=${LDFLAGS}" -L"${CURL_LIB_PATH}" -Wl,-rpath,"${CURL_LIB_PATH} + echo ${CURL_INCL_PATH} + echo ${CPPFLAGS} + fi + + #if test x$HAVE_CURL_ == xtrue ; then + AC_CHECK_HEADERS( + [curl/curl.h], + [HAVE_CURL_=true], + [HAVE_CURL_=false + AC_MSG_WARN(curl/curl.h not found!)], + []) + #fi + + if test x$HAVE_CURL_ == xtrue ; then + AC_CHECK_LIB(curl,[main], + [], + [HAVE_CURL=false + AC_MSG_WARN(libcurl not found!)]) + fi + + + # If all checks are OK we add curl to the FLAGS. + + if test x$HAVE_CURL_ != xtrue ; then + if test x"${CURL_PREFIX}" != x"" ; then + CPPFLAGS=${TEMP_CPPFLAGS} + LDFLAGS=${TEMP_LDFLAGS} + echo ${CPPFLAGS} + fi + fi + + + if test x$HAVE_CURL_ == xtrue ; then + AC_DEFINE_UNQUOTED(HAVE_CURL, 1, [Availability of curl]) + echo "CURL PATH ====================================>" ${CURL_INCL_PATH} + echo "CURL LIB ====================================>" ${CURL_LIB_PATH} + fi +fi + +AC_LANG_POP +## +##-- end CURL-- check header files only +##----------------------------- + + + +##--------------------------------------------------------------------------- +##--------------------------------------------------------------------------- +##-- LZ4 -- path and options - +##-- LZ4 header files required +## + +LZ4_PREFIX="" +LZ4_INCL_PATH="" +LZ4_LIB_PATH="" +LZ4_OPTION="" + +AC_ARG_ENABLE( + [lz4], + AC_HELP_STRING([--enable-lz4], + [enable LZ4 use [default=no]]), + [HAVE_LZ4_=true] +) + +if test x$HAVE_LZ4_ == xtrue ; then + AC_ARG_WITH( + lz4, + AC_HELP_STRING( + [--with-lz4 = location of lz4], + [prefix giving the lz4 base directory]), + [#HAVE_LZ4_=true + LZ4_PREFIX=$withval + LZ4_INCL_PATH="-I"${LZ4_PREFIX} + LZ4_LIB_PATH=${LZ4_PREFIX} + ] +) +fi + +## +##-- end LZ4 -- path and options +##--------------------------------------------------------- + + +##--------------------------------------------------------------------------- +##-- LZ4 -- check header files and library +## + +AC_LANG_PUSH([C++]) + +if test x$HAVE_LZ4_ == xtrue ; then + + # Change flags: if all tests are successful, accept these additions, + # else use the old flags. + if test x"${LZ4_PREFIX}" != x"" ; then + TEMP_CPPFLAGS=${CPPFLAGS} + CPPFLAGS=${CPPFLAGS}" "${LZ4_INCL_PATH} + TEMP_LDFLAGS=${LDFLAGS} + LDFLAGS=${LDFLAGS}" -L"${LZ4_LIB_PATH}" -Wl,-rpath,"${LZ4_LIB_PATH} + echo ${LZ4_INCL_PATH} + echo ${CPPFLAGS} + fi + + #if test x$HAVE_LZ4_ == xtrue ; then + AC_CHECK_HEADERS( + [lz4.h], + [HAVE_LZ4_=true], + [HAVE_LZ4_=false + AC_MSG_WARN(lz4.h not found!)], + []) + #fi + + if test x$HAVE_LZ4_ == xtrue ; then + AC_CHECK_LIB(lz4,[main], + [], + [HAVE_LZ4=false + AC_MSG_WARN(liblz4 not found!)]) + fi + + + # If all checks are OK we add LZ4 to the FLAGS. + + if test x$HAVE_LZ4_ != xtrue ; then + if test x"${LZ4_PREFIX}" != x"" ; then + CPPFLAGS=${TEMP_CPPFLAGS} + LDFLAGS=${TEMP_LDFLAGS} + echo ${CPPFLAGS} + fi + fi + + if test x$HAVE_LZ4_ == xtrue ; then + AC_DEFINE_UNQUOTED(HAVE_LZ4, 1, [Availability of LZ4]) + echo "LZ4 PATH ====================================>" ${LZ4_INCL_PATH} + echo "LZ4 LIB ====================================>" ${LZ4_LIB_PATH} + fi +fi + +AC_LANG_POP +## +##-- end LZ4-- check header files only +##----------------------------- + +CPPFLAGS=$CPPFLAGS +echo "REPORTING -> current CPPFLAGS = "$CPPFLAGS +LDFLAGS=$LDFLAGS +echo "REPORTING -> current LDFLAGS = "$LDFLAGS + +## +##-- end Check +##-- + +# Generate makefiles + +AC_SUBST(AM_CPPFLAGS, $CPPFLAGS) +AC_SUBST(AM_LDFLAGS, $LDFLAGS) + +#echo "HAVE_PYTHON_="$HAVE_PYTHON_ +#echo "HAVE_ZEROMQ_="$HAVE_ZEROMQ_ + +AM_CONDITIONAL(HAVE_PYTHON_, test x$HAVE_PYTHON_ == xtrue) +AM_CONDITIONAL(HAVE_PYCAFE_EXT_, test x$HAVE_PYTHON_ == xtrue) +AM_CONDITIONAL(HAVE_ZEROMQ_, test x$HAVE_ZEROMQ_ == xtrue) + +AC_CONFIG_FILES([makefile + src/makefile + include/makefile]) + +AC_OUTPUT diff --git a/examples/cafeTest/#makfile7# b/examples/cafeTest/#makfile7# new file mode 100644 index 0000000..b28b04f --- /dev/null +++ b/examples/cafeTest/#makfile7# @@ -0,0 +1,3 @@ + + + diff --git a/examples/cafeTest/cafeTest b/examples/cafeTest/cafeTest new file mode 100755 index 0000000000000000000000000000000000000000..22d7c9b1d91ca85d5f08b7c456049fa3c28bc7e4 GIT binary patch literal 329704 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
  • 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 literal 0 HcmV?d00001 diff --git a/examples/cafeTest/cafeTest-- b/examples/cafeTest/cafeTest-- new file mode 100755 index 0000000000000000000000000000000000000000..68c92a903c4fdb3b2a4c98f220ac0056ed23e1b4 GIT binary patch literal 798576 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
    !J7gj|DGb%jz7 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%0AiW+7LDD1f^JxxjhW?!9>h*PCY|9X%V-Q^V;5 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 literal 0 HcmV?d00001 diff --git a/include/cafe.h b/include/cafe.h index 9230c90..3ec0efb 100644 --- a/include/cafe.h +++ b/include/cafe.h @@ -7,12 +7,13 @@ #ifndef CAFE_H #define CAFE_H + #include #include #include #include #include -#include + #if HAVE_PYTHON_H #include #endif diff --git a/include/cafeCache.h b/include/cafeCache.h index 0033e16..68bfe67 100644 --- a/include/cafeCache.h +++ b/include/cafeCache.h @@ -182,6 +182,10 @@ int getCache(const unsigned int handle, dbr_long_t * _val, dbr_short_t &alarm return cafeLatte.getCache(handle, DBR_TIME_LONG, _val, alarmStatus, alarmSeverity, ts); }; //4 +int getCacheCharArray(const unsigned int handle, dbr_char_t * _val) +{ + return cafeCappuccino.getCache(handle, DBR_CHAR, _val); +}; int getCache(const unsigned int handle, dbr_char_t * _val) { return cafeCappuccino.getCache(handle, DBR_CHAR, _val); diff --git a/include/global.h b/include/global.h index 582a127..ed885df 100644 --- a/include/global.h +++ b/include/global.h @@ -9,7 +9,7 @@ #ifndef GLOBAL_H #define GLOBAL_H - +#include #include #include #include diff --git a/include/instant.h b/include/instant.h index 0bf59fe..3c5c5cc 100644 --- a/include/instant.h +++ b/include/instant.h @@ -456,13 +456,8 @@ public: }; - - //include - - - /** * \brief Set values of data type CTYPE * \param _handle input: handle to CAFEConduit object @@ -819,8 +814,6 @@ template int Instant::getCache(const unsigned int _handle }; //unlock } - - //ifNeverConnected - return error if ( (*it_handle).getChannelRegalia().getCafeConnectionState() == ICAFE_CS_NEVER_CONN) { diff --git a/include/makefile b/include/makefile index 345af33..99ecdf2 100644 --- a/include/makefile +++ b/include/makefile @@ -1,8 +1,9 @@ -# makefile.in generated by automake 1.13.4 from makefile.am. +# makefile.in generated by automake 1.11.1 from makefile.am. # include/makefile. Generated from makefile.in by configure. -# Copyright (C) 1994-2013 Free Software Foundation, Inc. - +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. @@ -15,51 +16,6 @@ -am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' -am__make_running_with_option = \ - case $${target_option-} in \ - ?) ;; \ - *) echo "am__make_running_with_option: internal error: invalid" \ - "target option '$${target_option-}' specified" >&2; \ - exit 1;; \ - esac; \ - has_opt=no; \ - sane_makeflags=$$MAKEFLAGS; \ - if $(am__is_gnu_make); then \ - sane_makeflags=$$MFLAGS; \ - else \ - case $$MAKEFLAGS in \ - *\\[\ \ ]*) \ - bs=\\; \ - sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ - | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ - esac; \ - fi; \ - skip_next=no; \ - strip_trailopt () \ - { \ - flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ - }; \ - for flg in $$sane_makeflags; do \ - test $$skip_next = yes && { skip_next=no; continue; }; \ - case $$flg in \ - *=*|--*) continue;; \ - -*I) strip_trailopt 'I'; skip_next=yes;; \ - -*I?*) strip_trailopt 'I';; \ - -*O) strip_trailopt 'O'; skip_next=yes;; \ - -*O?*) strip_trailopt 'O';; \ - -*l) strip_trailopt 'l'; skip_next=yes;; \ - -*l?*) strip_trailopt 'l';; \ - -[dEDm]) skip_next=yes;; \ - -[JT]) skip_next=yes;; \ - esac; \ - case $$flg in \ - *$$target_option*) has_opt=yes; break;; \ - esac; \ - done; \ - test $$has_opt = yes -am__make_dryrun = (target_option=n; $(am__make_running_with_option)) -am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/cafe pkgincludedir = $(includedir)/cafe pkglibdir = $(libdir)/cafe @@ -89,8 +45,8 @@ host_triplet = x86_64-unknown-linux-gnu am__append_2 = PyCafe.h #am__append_3 = PyCafe_api.h subdir = include -DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \ - $(am__include_HEADERS_DIST) +DIST_COMMON = $(am__include_HEADERS_DIST) $(srcdir)/makefile.am \ + $(srcdir)/makefile.in ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \ $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \ @@ -102,25 +58,8 @@ mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/./include/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = -AM_V_P = $(am__v_P_$(V)) -am__v_P_ = $(am__v_P_$(AM_DEFAULT_VERBOSITY)) -am__v_P_0 = false -am__v_P_1 = : -AM_V_GEN = $(am__v_GEN_$(V)) -am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY)) -am__v_GEN_0 = @echo " GEN " $@; -am__v_GEN_1 = -AM_V_at = $(am__v_at_$(V)) -am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY)) -am__v_at_0 = @ -am__v_at_1 = SOURCES = DIST_SOURCES = -am__can_run_installinfo = \ - case $$AM_UPDATE_INFO_DIR in \ - n|no|NO) false;; \ - *) (install-info --version) >/dev/null 2>&1;; \ - esac am__include_HEADERS_DIST = config.h cafe.h cafeCache.h cafeConvert.h \ cafeDataType.h cafeDataTypeHelper.h cafeEnum.h \ cafeEnumStrings.h cafeRoast.h cafeVectors.h cafeXML.h \ @@ -158,50 +97,26 @@ am__nobase_list = $(am__nobase_strip_setup); \ am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' -am__uninstall_files_from_dir = { \ - test -z "$$files" \ - || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ - || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ - $(am__cd) "$$dir" && rm -f $$files; }; \ - } am__installdirs = "$(DESTDIR)$(includedir)" HEADERS = $(include_HEADERS) -am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) -# Read a list of newline-separated strings from the standard input, -# and print each of them once, without duplicates. Input order is -# *not* preserved. -am__uniquify_input = $(AWK) '\ - BEGIN { nonempty = 0; } \ - { items[$$0] = 1; nonempty = 1; } \ - END { if (nonempty) { for (i in items) print i; }; } \ -' -# Make sure the list of sources is unique. This is necessary because, -# e.g., the same source file might be shared among _SOURCES variables -# for different programs/libraries. -am__define_uniq_tagged_files = \ - list='$(am__tagged_files)'; \ - unique=`for i in $$list; do \ - if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ - done | $(am__uniquify_input)` ETAGS = etags CTAGS = ctags DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) -ACLOCAL = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing aclocal-1.13 -AMTAR = $${TAR-tar} -AM_CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base-7.0.6/include/ -I/usr/local/epics/base-7.0.6/include/os/Linux -I/usr/local/epics/base-7.0.6/include/compiler/gcc -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml -AM_DEFAULT_VERBOSITY = 1 -AM_LDFLAGS = -L/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -Wl,-rpath,/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib +ACLOCAL = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run aclocal-1.11 +AMTAR = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run tar +AM_CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml +AM_LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib AR = ar -AUTOCONF = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing autoconf -AUTOHEADER = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing autoheader -AUTOMAKE = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing automake-1.13 +AUTOCONF = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run autoconf +AUTOHEADER = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run autoheader +AUTOMAKE = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run automake-1.11 AWK = gawk CAFE_CPPFLAGS = -I$(top_srcdir)/include CC = /opt/psi/Programming/gcc/7.3.0/bin/gcc CCDEPMODE = depmode=gcc3 CFLAGS = -g -O2 CPP = /opt/psi/Programming/gcc/7.3.0/bin/gcc -E -CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base-7.0.6/include/ -I/usr/local/epics/base-7.0.6/include/os/Linux -I/usr/local/epics/base-7.0.6/include/compiler/gcc -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml +CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml CXX = /opt/psi/Programming/gcc/7.3.0/bin/g++ CXXCPP = /opt/psi/Programming/gcc/7.3.0/bin/g++ -E CXXDEPMODE = depmode=gcc3 @@ -215,17 +130,17 @@ DUMPBIN = ECHO_C = ECHO_N = -n ECHO_T = -EGREP = /usr/bin/grep -E +EGREP = /bin/grep -E EXEEXT = -FGREP = /usr/bin/grep -F -GREP = /usr/bin/grep +FGREP = /bin/grep -F +GREP = /bin/grep INSTALL = /usr/bin/install -c INSTALL_DATA = ${INSTALL} -m 644 INSTALL_PROGRAM = ${INSTALL} INSTALL_SCRIPT = ${INSTALL} INSTALL_STRIP_PROGRAM = $(install_sh) -c -s LD = /usr/bin/ld -m elf_x86_64 -LDFLAGS = -L/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -Wl,-rpath,/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib +LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib LIBOBJS = LIBS = -lQtXml -lQtCore -lpython3.5m LIBTOOL = $(SHELL) $(top_builddir)/libtool @@ -233,9 +148,9 @@ LIPO = LN_S = ln -s LTLIBOBJS = LT_SYS_LIBRARY_PATH = -MAKEINFO = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing makeinfo +MAKEINFO = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run makeinfo MANIFEST_TOOL = : -MKDIR_P = /usr/bin/mkdir -p +MKDIR_P = /bin/mkdir -p NM = /usr/bin/nm -B NMEDIT = OBJDUMP = objdump @@ -245,17 +160,16 @@ OTOOL64 = PACKAGE = cafe PACKAGE_BUGREPORT = Bug reports to: jan.chrin@psi.ch PACKAGE_NAME = CAFE -PACKAGE_STRING = CAFE 1.15.0 +PACKAGE_STRING = CAFE 1.15.1 PACKAGE_TARNAME = cafe -PACKAGE_URL = -PACKAGE_VERSION = 1.15.0 +PACKAGE_VERSION = 1.15.1 PATH_SEPARATOR = : RANLIB = ranlib -SED = /usr/bin/sed +SED = /bin/sed SET_MAKE = SHELL = /bin/sh STRIP = strip -VERSION = 1.15.0 +VERSION = 1.15.1 abs_builddir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/include abs_srcdir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/include abs_top_builddir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp @@ -267,8 +181,8 @@ ac_ct_DUMPBIN = am__include = include am__leading_dot = . am__quote = -am__tar = $${TAR-tar} chof - "$$tardir" -am__untar = $${TAR-tar} xf - +am__tar = ${AMTAR} chof - "$$tardir" +am__untar = ${AMTAR} xf - bindir = ${exec_prefix}/bin build = x86_64-unknown-linux-gnu build_alias = @@ -290,15 +204,15 @@ htmldir = ${docdir} includedir = ${prefix}/include infodir = ${datarootdir}/info install_sh = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/install-sh -libdir = /opt/gfa/cafe/cpp/cafe-1.15.0-py35-gcc-7.3.0/lib/RHEL7-x86_64 +libdir = /opt/gfa/cafe/cpp/cafe-1.15.1-epics3-py35-gcc-7.3.0/lib/SL6-x86_64 libexecdir = ${exec_prefix}/libexec localedir = ${datarootdir}/locale localstatedir = ${prefix}/var mandir = ${datarootdir}/man -mkdir_p = $(MKDIR_P) +mkdir_p = /bin/mkdir -p oldincludedir = /usr/include pdfdir = ${docdir} -prefix = /opt/gfa/cafe/cpp/cafe-1.15.0-py35-gcc-7.3.0 +prefix = /opt/gfa/cafe/cpp/cafe-1.15.1-epics3-py35-gcc-7.3.0 program_transform_name = s,x,x, psdir = ${docdir} sbindir = ${exec_prefix}/sbin @@ -363,11 +277,8 @@ clean-libtool: -rm -rf .libs _libs install-includeHEADERS: $(include_HEADERS) @$(NORMAL_INSTALL) + test -z "$(includedir)" || $(MKDIR_P) "$(DESTDIR)$(includedir)" @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ - if test -n "$$list"; then \ - echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \ - $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \ - fi; \ for p in $$list; do \ if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ echo "$$d$$p"; \ @@ -381,17 +292,30 @@ uninstall-includeHEADERS: @$(NORMAL_UNINSTALL) @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ - dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir) + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(includedir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(includedir)" && rm -f $$files -ID: $(am__tagged_files) - $(am__define_uniq_tagged_files); mkid -fID $$unique -tags: tags-am -TAGS: tags +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS -tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) set x; \ here=`pwd`; \ - $(am__define_uniq_tagged_files); \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ shift; \ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ test -n "$$unique" || unique=$$empty_fix; \ @@ -403,11 +327,15 @@ tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $$unique; \ fi; \ fi -ctags: ctags-am - -CTAGS: ctags -ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) - $(am__define_uniq_tagged_files); \ +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ test -z "$(CTAGS_ARGS)$$unique" \ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ $$unique @@ -416,21 +344,6 @@ GTAGS: here=`$(am__cd) $(top_builddir) && pwd` \ && $(am__cd) $(top_srcdir) \ && gtags -i $(GTAGS_ARGS) "$$here" -cscopelist: cscopelist-am - -cscopelist-am: $(am__tagged_files) - list='$(am__tagged_files)'; \ - case "$(srcdir)" in \ - [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ - *) sdir=$(subdir)/$(srcdir) ;; \ - esac; \ - for i in $$list; do \ - if test -f "$$i"; then \ - echo "$(subdir)/$$i"; \ - else \ - echo "$$sdir/$$i"; \ - fi; \ - done >> $(top_builddir)/cscope.files distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags @@ -482,15 +395,10 @@ install-am: all-am installcheck: installcheck-am install-strip: - if test -z '$(STRIP)'; then \ - $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ - install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ - install; \ - else \ - $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ - install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ - "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ - fi + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install mostlyclean-generic: clean-generic: @@ -570,19 +478,18 @@ uninstall-am: uninstall-includeHEADERS .MAKE: install-am install-strip -.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ - clean-libtool cscopelist-am ctags ctags-am distclean \ - distclean-generic distclean-libtool distclean-tags distdir dvi \ - dvi-am html html-am info info-am install install-am \ - install-data install-data-am install-dvi install-dvi-am \ - install-exec install-exec-am install-html install-html-am \ +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ + clean-libtool ctags distclean distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am \ install-includeHEADERS install-info install-info-am \ install-man install-pdf install-pdf-am install-ps \ install-ps-am install-strip installcheck installcheck-am \ installdirs maintainer-clean maintainer-clean-generic \ mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \ - ps ps-am tags tags-am uninstall uninstall-am \ - uninstall-includeHEADERS + ps ps-am tags uninstall uninstall-am uninstall-includeHEADERS # Tell versions [3.59,3.63) of GNU make to not export all variables. diff --git a/libtool b/libtool index b24eff2..4389ba1 100755 --- a/libtool +++ b/libtool @@ -1,6 +1,6 @@ #! /bin/sh -# Generated automatically by config.status (cafe) 1.15.0 -# Libtool was configured on host sf-lc7a.psi.ch: +# Generated automatically by config.status (cafe) 1.15.1 +# Libtool was configured on host gfa-lc6-64: # NOTE: Changes made to this file will be lost: look at ltmain.sh. # Provide generalized library-building support services. @@ -76,19 +76,19 @@ build=x86_64-unknown-linux-gnu build_os=linux-gnu # A sed program that does not truncate output. -SED="/usr/bin/sed" +SED="/bin/sed" # Sed that helps us avoid accidentally triggering echo(1) options like -n. Xsed="$SED -e 1s/^X//" # A grep program that handles long lines. -GREP="/usr/bin/grep" +GREP="/bin/grep" # An ERE matcher. -EGREP="/usr/bin/grep -E" +EGREP="/bin/grep -E" # A literal string matcher. -FGREP="/usr/bin/grep -F" +FGREP="/bin/grep -F" # A BSD- or MS-compatible name lister. NM="/usr/bin/nm -B" @@ -97,7 +97,7 @@ NM="/usr/bin/nm -B" LN_S="ln -s" # What is the maximum length of a command? -max_cmd_len=1572864 +max_cmd_len=1966080 # Object file suffix (normally "o"). objext=o @@ -192,7 +192,7 @@ nm_file_list_spec="@" lt_sysroot= # Command to truncate a binary pipe. -lt_truncate_bin="/usr/bin/dd bs=4096 count=1" +lt_truncate_bin="/bin/dd bs=4096 count=1" # The name of the directory that contains temporary libtool files. objdir=.libs @@ -285,7 +285,7 @@ hardcode_into_libs=yes sys_lib_search_path_spec="/afs/psi.ch/sys/psi.x86_64_slp6/Programming/gcc/7.3.0/lib/gcc/x86_64-pc-linux-gnu/7.3.0 /afs/psi.ch/sys/psi.x86_64_slp6/Programming/gcc/7.3.0/lib/gcc /opt/psi/Programming/gcc/7.3.0/lib64 /afs/psi.ch/sys/psi.x86_64_slp6/Programming/gcc/7.3.0/lib64 /lib64 /usr/lib64 /opt/psi/Programming/gcc/7.3.0/lib /afs/psi.ch/sys/psi.x86_64_slp6/Programming/gcc/7.3.0/lib /lib /usr/lib " # Detected run-time system search path for libraries. -sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib64/atlas /usr/lib64//bind9-export/ /usr/lib64/dyninst /usr/lib64/mysql /usr/lib/oracle/12.2/client64/lib /usr/lib64/tcl8.5/tclx8.4 " +sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib64/atlas /usr/lib64/ctapi /prod/sls/lib /prod /usr/lib64/llvm /usr/lib64/mysql /usr/lib/oracle/12.1/client64/lib /usr/lib64/papi-4.1.3 /usr/lib64/papi-5.1.1/usr/lib /usr/lib/qt-3.3/lib /usr/lib64/qt-3.3/lib /usr/lib64/tcl8.5/tclx8.4 /usr/lib64/tcl8.5 /usr/lib/vmware-tools/lib/libvmGuestLib.so /usr/lib/vmware-tools/lib/libvmGuestLibJava.so /usr/lib/vmware-tools/lib/libDeployPkg.so /usr/lib64/xulrunner " # Explicit LT_SYS_LIBRARY_PATH set during ./configure time. configure_time_lt_sys_library_path="" @@ -11819,8 +11819,8 @@ compiler_lib_search_dirs="/afs/psi.ch/sys/psi.x86_64_slp6/Programming/gcc/7.3.0/ # Dependencies to place before and after the objects being linked to # create a shared library. -predep_objects="/lib/../lib64/crti.o /afs/psi.ch/sys/psi.x86_64_slp6/Programming/gcc/7.3.0/bin/../lib/gcc/x86_64-pc-linux-gnu/7.3.0/crtbeginS.o" -postdep_objects="/afs/psi.ch/sys/psi.x86_64_slp6/Programming/gcc/7.3.0/bin/../lib/gcc/x86_64-pc-linux-gnu/7.3.0/crtendS.o /lib/../lib64/crtn.o" +predep_objects="/usr/lib/../lib64/crti.o /afs/psi.ch/sys/psi.x86_64_slp6/Programming/gcc/7.3.0/bin/../lib/gcc/x86_64-pc-linux-gnu/7.3.0/crtbeginS.o" +postdep_objects="/afs/psi.ch/sys/psi.x86_64_slp6/Programming/gcc/7.3.0/bin/../lib/gcc/x86_64-pc-linux-gnu/7.3.0/crtendS.o /usr/lib/../lib64/crtn.o" predeps="" postdeps="-lstdc++ -lm -lgcc_s -lc -lgcc_s" diff --git a/makefile b/makefile index 755983f..6d74ccd 100644 --- a/makefile +++ b/makefile @@ -1,8 +1,9 @@ -# makefile.in generated by automake 1.13.4 from makefile.am. +# makefile.in generated by automake 1.11.1 from makefile.am. # makefile. Generated from makefile.in by configure. -# Copyright (C) 1994-2013 Free Software Foundation, Inc. - +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. @@ -15,51 +16,6 @@ -am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' -am__make_running_with_option = \ - case $${target_option-} in \ - ?) ;; \ - *) echo "am__make_running_with_option: internal error: invalid" \ - "target option '$${target_option-}' specified" >&2; \ - exit 1;; \ - esac; \ - has_opt=no; \ - sane_makeflags=$$MAKEFLAGS; \ - if $(am__is_gnu_make); then \ - sane_makeflags=$$MFLAGS; \ - else \ - case $$MAKEFLAGS in \ - *\\[\ \ ]*) \ - bs=\\; \ - sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ - | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ - esac; \ - fi; \ - skip_next=no; \ - strip_trailopt () \ - { \ - flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ - }; \ - for flg in $$sane_makeflags; do \ - test $$skip_next = yes && { skip_next=no; continue; }; \ - case $$flg in \ - *=*|--*) continue;; \ - -*I) strip_trailopt 'I'; skip_next=yes;; \ - -*I?*) strip_trailopt 'I';; \ - -*O) strip_trailopt 'O'; skip_next=yes;; \ - -*O?*) strip_trailopt 'O';; \ - -*l) strip_trailopt 'l'; skip_next=yes;; \ - -*l?*) strip_trailopt 'l';; \ - -[dEDm]) skip_next=yes;; \ - -[JT]) skip_next=yes;; \ - esac; \ - case $$flg in \ - *$$target_option*) has_opt=yes; break;; \ - esac; \ - done; \ - test $$has_opt = yes -am__make_dryrun = (target_option=n; $(am__make_running_with_option)) -am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/cafe pkgincludedir = $(includedir)/cafe pkglibdir = $(libdir)/cafe @@ -79,16 +35,14 @@ POST_UNINSTALL = : build_triplet = x86_64-unknown-linux-gnu host_triplet = x86_64-unknown-linux-gnu subdir = . -DIST_COMMON = INSTALL NEWS README AUTHORS ChangeLog \ - $(srcdir)/makefile.in $(srcdir)/makefile.am \ - $(top_srcdir)/configure $(am__configure_deps) \ - $(top_srcdir)/./include/config.in $(include_HEADERS) \ - .//AUTHORS COPYING .//COPYING .//ChangeLog .//INSTALL .//NEWS \ - .//README config.guess .//config.guess config.sub \ - .//config.sub install-sh .//install-sh missing .//missing \ - ltmain.sh .//ltmain.sh $(top_srcdir)/./config.guess \ - $(top_srcdir)/./config.sub $(top_srcdir)/./install-sh \ - $(top_srcdir)/./ltmain.sh $(top_srcdir)/./missing +DIST_COMMON = README $(am__configure_deps) $(include_HEADERS) \ + $(srcdir)/makefile.am $(srcdir)/makefile.in \ + $(top_srcdir)/./include/config.in $(top_srcdir)/configure \ + .//AUTHORS .//COPYING .//ChangeLog .//INSTALL .//NEWS \ + .//README .//config.guess .//config.sub .//depcomp \ + .//install-sh .//ltmain.sh .//missing AUTHORS COPYING \ + ChangeLog INSTALL NEWS config.guess config.sub depcomp \ + install-sh ltmain.sh missing ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \ $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \ @@ -102,33 +56,15 @@ mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/./include/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = -AM_V_P = $(am__v_P_$(V)) -am__v_P_ = $(am__v_P_$(AM_DEFAULT_VERBOSITY)) -am__v_P_0 = false -am__v_P_1 = : -AM_V_GEN = $(am__v_GEN_$(V)) -am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY)) -am__v_GEN_0 = @echo " GEN " $@; -am__v_GEN_1 = -AM_V_at = $(am__v_at_$(V)) -am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY)) -am__v_at_0 = @ -am__v_at_1 = SOURCES = DIST_SOURCES = -RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ - ctags-recursive dvi-recursive html-recursive info-recursive \ - install-data-recursive install-dvi-recursive \ - install-exec-recursive install-html-recursive \ - install-info-recursive install-pdf-recursive \ - install-ps-recursive install-recursive installcheck-recursive \ - installdirs-recursive pdf-recursive ps-recursive \ - tags-recursive uninstall-recursive -am__can_run_installinfo = \ - case $$AM_UPDATE_INFO_DIR in \ - n|no|NO) false;; \ - *) (install-info --version) >/dev/null 2>&1;; \ - esac +RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ + html-recursive info-recursive install-data-recursive \ + install-dvi-recursive install-exec-recursive \ + install-html-recursive install-info-recursive \ + install-pdf-recursive install-ps-recursive install-recursive \ + installcheck-recursive installdirs-recursive pdf-recursive \ + ps-recursive uninstall-recursive am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; am__vpath_adj = case $$p in \ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ @@ -150,53 +86,23 @@ am__nobase_list = $(am__nobase_strip_setup); \ am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' -am__uninstall_files_from_dir = { \ - test -z "$$files" \ - || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ - || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ - $(am__cd) "$$dir" && rm -f $$files; }; \ - } am__installdirs = "$(DESTDIR)$(includedir)" HEADERS = $(include_HEADERS) RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ distclean-recursive maintainer-clean-recursive -am__recursive_targets = \ - $(RECURSIVE_TARGETS) \ - $(RECURSIVE_CLEAN_TARGETS) \ - $(am__extra_recursive_targets) -AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ - cscope distdir dist dist-all distcheck -am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) -# Read a list of newline-separated strings from the standard input, -# and print each of them once, without duplicates. Input order is -# *not* preserved. -am__uniquify_input = $(AWK) '\ - BEGIN { nonempty = 0; } \ - { items[$$0] = 1; nonempty = 1; } \ - END { if (nonempty) { for (i in items) print i; }; } \ -' -# Make sure the list of sources is unique. This is necessary because, -# e.g., the same source file might be shared among _SOURCES variables -# for different programs/libraries. -am__define_uniq_tagged_files = \ - list='$(am__tagged_files)'; \ - unique=`for i in $$list; do \ - if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ - done | $(am__uniquify_input)` +AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \ + $(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \ + distdir dist dist-all distcheck ETAGS = etags CTAGS = ctags -CSCOPE = cscope DIST_SUBDIRS = $(SUBDIRS) DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) distdir = $(PACKAGE)-$(VERSION) top_distdir = $(distdir) am__remove_distdir = \ - if test -d "$(distdir)"; then \ - find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ - && rm -rf "$(distdir)" \ - || { sleep 5 && rm -rf "$(distdir)"; }; \ - else :; fi -am__post_remove_distdir = $(am__remove_distdir) + { test ! -d "$(distdir)" \ + || { find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ + && rm -fr "$(distdir)"; }; } am__relativize = \ dir0=`pwd`; \ sed_first='s,^\([^/]*\)/.*$$,\1,'; \ @@ -224,27 +130,23 @@ am__relativize = \ reldir="$$dir2" DIST_ARCHIVES = $(distdir).tar.gz GZIP_ENV = --best -DIST_TARGETS = dist-gzip distuninstallcheck_listfiles = find . -type f -print -am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ - | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' distcleancheck_listfiles = find . -type f -print -ACLOCAL = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing aclocal-1.13 -AMTAR = $${TAR-tar} -AM_CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base-7.0.6/include/ -I/usr/local/epics/base-7.0.6/include/os/Linux -I/usr/local/epics/base-7.0.6/include/compiler/gcc -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml -I$(top_srcdir)/include -AM_DEFAULT_VERBOSITY = 1 -AM_LDFLAGS = -L/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -Wl,-rpath,/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib @CAFE_LIBS@ +ACLOCAL = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run aclocal-1.11 +AMTAR = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run tar +AM_CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml -I$(top_srcdir)/include +AM_LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib @CAFE_LIBS@ AR = ar -AUTOCONF = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing autoconf -AUTOHEADER = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing autoheader -AUTOMAKE = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing automake-1.13 +AUTOCONF = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run autoconf +AUTOHEADER = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run autoheader +AUTOMAKE = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run automake-1.11 AWK = gawk CAFE_CPPFLAGS = -I$(top_srcdir)/include CC = /opt/psi/Programming/gcc/7.3.0/bin/gcc CCDEPMODE = depmode=gcc3 CFLAGS = -g -O2 CPP = /opt/psi/Programming/gcc/7.3.0/bin/gcc -E -CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base-7.0.6/include/ -I/usr/local/epics/base-7.0.6/include/os/Linux -I/usr/local/epics/base-7.0.6/include/compiler/gcc -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml +CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml CXX = /opt/psi/Programming/gcc/7.3.0/bin/g++ CXXCPP = /opt/psi/Programming/gcc/7.3.0/bin/g++ -E CXXDEPMODE = depmode=gcc3 @@ -258,17 +160,17 @@ DUMPBIN = ECHO_C = ECHO_N = -n ECHO_T = -EGREP = /usr/bin/grep -E +EGREP = /bin/grep -E EXEEXT = -FGREP = /usr/bin/grep -F -GREP = /usr/bin/grep +FGREP = /bin/grep -F +GREP = /bin/grep INSTALL = /usr/bin/install -c INSTALL_DATA = ${INSTALL} -m 644 INSTALL_PROGRAM = ${INSTALL} INSTALL_SCRIPT = ${INSTALL} INSTALL_STRIP_PROGRAM = $(install_sh) -c -s LD = /usr/bin/ld -m elf_x86_64 -LDFLAGS = -L/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -Wl,-rpath,/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib +LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib LIBOBJS = LIBS = -lQtXml -lQtCore -lpython3.5m LIBTOOL = $(SHELL) $(top_builddir)/libtool @@ -276,9 +178,9 @@ LIPO = LN_S = ln -s LTLIBOBJS = LT_SYS_LIBRARY_PATH = -MAKEINFO = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing makeinfo +MAKEINFO = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run makeinfo MANIFEST_TOOL = : -MKDIR_P = /usr/bin/mkdir -p +MKDIR_P = /bin/mkdir -p NM = /usr/bin/nm -B NMEDIT = OBJDUMP = objdump @@ -288,17 +190,16 @@ OTOOL64 = PACKAGE = cafe PACKAGE_BUGREPORT = Bug reports to: jan.chrin@psi.ch PACKAGE_NAME = CAFE -PACKAGE_STRING = CAFE 1.15.0 +PACKAGE_STRING = CAFE 1.15.1 PACKAGE_TARNAME = cafe -PACKAGE_URL = -PACKAGE_VERSION = 1.15.0 +PACKAGE_VERSION = 1.15.1 PATH_SEPARATOR = : RANLIB = ranlib -SED = /usr/bin/sed +SED = /bin/sed SET_MAKE = SHELL = /bin/sh STRIP = strip -VERSION = 1.15.0 +VERSION = 1.15.1 abs_builddir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp abs_srcdir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp abs_top_builddir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp @@ -310,8 +211,8 @@ ac_ct_DUMPBIN = am__include = include am__leading_dot = . am__quote = -am__tar = $${TAR-tar} chof - "$$tardir" -am__untar = $${TAR-tar} xf - +am__tar = ${AMTAR} chof - "$$tardir" +am__untar = ${AMTAR} xf - bindir = ${exec_prefix}/bin build = x86_64-unknown-linux-gnu build_alias = @@ -333,15 +234,15 @@ htmldir = ${docdir} includedir = ${prefix}/include infodir = ${datarootdir}/info install_sh = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/install-sh -libdir = /opt/gfa/cafe/cpp/cafe-1.15.0-py35-gcc-7.3.0/lib/RHEL7-x86_64 +libdir = /opt/gfa/cafe/cpp/cafe-1.15.1-epics3-py35-gcc-7.3.0/lib/SL6-x86_64 libexecdir = ${exec_prefix}/libexec localedir = ${datarootdir}/locale localstatedir = ${prefix}/var mandir = ${datarootdir}/man -mkdir_p = $(MKDIR_P) +mkdir_p = /bin/mkdir -p oldincludedir = /usr/include pdfdir = ${docdir} -prefix = /opt/gfa/cafe/cpp/cafe-1.15.0-py35-gcc-7.3.0 +prefix = /opt/gfa/cafe/cpp/cafe-1.15.1-epics3-py35-gcc-7.3.0 program_transform_name = s,x,x, psdir = ${docdir} sbindir = ${exec_prefix}/sbin @@ -358,7 +259,7 @@ ACLOCAL_AMFLAGS = -I m4 all: all-recursive .SUFFIXES: -am--refresh: makefile +am--refresh: @: $(srcdir)/makefile.in: $(srcdir)/makefile.am $(am__configure_deps) @for dep in $?; do \ @@ -394,8 +295,10 @@ $(ACLOCAL_M4): $(am__aclocal_m4_deps) $(am__aclocal_m4_deps): ./include/config.h: ./include/stamp-h1 - @if test ! -f $@; then rm -f ./include/stamp-h1; else :; fi - @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) ./include/stamp-h1; else :; fi + @if test ! -f $@; then \ + rm -f ./include/stamp-h1; \ + $(MAKE) $(AM_MAKEFLAGS) ./include/stamp-h1; \ + else :; fi ./include/stamp-h1: $(top_srcdir)/./include/config.in $(top_builddir)/config.status @rm -f ./include/stamp-h1 @@ -418,11 +321,8 @@ distclean-libtool: -rm -f libtool config.lt install-includeHEADERS: $(include_HEADERS) @$(NORMAL_INSTALL) + test -z "$(includedir)" || $(MKDIR_P) "$(DESTDIR)$(includedir)" @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ - if test -n "$$list"; then \ - echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \ - $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \ - fi; \ for p in $$list; do \ if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ echo "$$d$$p"; \ @@ -436,28 +336,27 @@ uninstall-includeHEADERS: @$(NORMAL_UNINSTALL) @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ - dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir) + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(includedir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(includedir)" && rm -f $$files # This directory's subdirectories are mostly independent; you can cd -# into them and run 'make' without going through this Makefile. -# To change the values of 'make' variables: instead of editing Makefiles, -# (1) if the variable is set in 'config.status', edit 'config.status' -# (which will cause the Makefiles to be regenerated when you run 'make'); -# (2) otherwise, pass the desired values on the 'make' command line. -$(am__recursive_targets): - @fail=; \ - if $(am__make_keepgoing); then \ - failcom='fail=yes'; \ - else \ - failcom='exit 1'; \ - fi; \ +# into them and run `make' without going through this Makefile. +# To change the values of `make' variables: instead of editing Makefiles, +# (1) if the variable is set in `config.status', edit `config.status' +# (which will cause the Makefiles to be regenerated when you run `make'); +# (2) otherwise, pass the desired values on the `make' command line. +$(RECURSIVE_TARGETS): + @fail= failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ dot_seen=no; \ target=`echo $@ | sed s/-recursive//`; \ - case "$@" in \ - distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ - *) list='$(SUBDIRS)' ;; \ - esac; \ - for subdir in $$list; do \ + list='$(SUBDIRS)'; for subdir in $$list; do \ echo "Making $$target in $$subdir"; \ if test "$$subdir" = "."; then \ dot_seen=yes; \ @@ -472,12 +371,57 @@ $(am__recursive_targets): $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ fi; test -z "$$fail" -ID: $(am__tagged_files) - $(am__define_uniq_tagged_files); mkid -fID $$unique -tags: tags-recursive -TAGS: tags +$(RECURSIVE_CLEAN_TARGETS): + @fail= failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + rev=''; for subdir in $$list; do \ + if test "$$subdir" = "."; then :; else \ + rev="$$subdir $$rev"; \ + fi; \ + done; \ + rev="$$rev ."; \ + target=`echo $@ | sed s/-recursive//`; \ + for subdir in $$rev; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done && test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done +ctags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ + done -tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) set x; \ here=`pwd`; \ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ @@ -493,7 +437,12 @@ tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ fi; \ done; \ - $(am__define_uniq_tagged_files); \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ shift; \ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ test -n "$$unique" || unique=$$empty_fix; \ @@ -505,11 +454,15 @@ tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $$unique; \ fi; \ fi -ctags: ctags-recursive - -CTAGS: ctags -ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) - $(am__define_uniq_tagged_files); \ +ctags: CTAGS +CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ test -z "$(CTAGS_ARGS)$$unique" \ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ $$unique @@ -518,31 +471,9 @@ GTAGS: here=`$(am__cd) $(top_builddir) && pwd` \ && $(am__cd) $(top_srcdir) \ && gtags -i $(GTAGS_ARGS) "$$here" -cscope: cscope.files - test ! -s cscope.files \ - || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS) -clean-cscope: - -rm -f cscope.files -cscope.files: clean-cscope cscopelist -cscopelist: cscopelist-recursive - -cscopelist-am: $(am__tagged_files) - list='$(am__tagged_files)'; \ - case "$(srcdir)" in \ - [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ - *) sdir=$(subdir)/$(srcdir) ;; \ - esac; \ - for i in $$list; do \ - if test -f "$$i"; then \ - echo "$(subdir)/$$i"; \ - else \ - echo "$$sdir/$$i"; \ - fi; \ - done >> $(top_builddir)/cscope.files distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags - -rm -f cscope.out cscope.in.out cscope.po.out cscope.files distdir: $(DISTFILES) $(am__remove_distdir) @@ -578,10 +509,13 @@ distdir: $(DISTFILES) done @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ - $(am__make_dryrun) \ - || test -d "$(distdir)/$$subdir" \ - || $(MKDIR_P) "$(distdir)/$$subdir" \ - || exit 1; \ + test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + fi; \ + done + @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ $(am__relativize); \ new_distdir=$$reldir; \ @@ -610,36 +544,36 @@ distdir: $(DISTFILES) || chmod -R a+r "$(distdir)" dist-gzip: distdir tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz - $(am__post_remove_distdir) + $(am__remove_distdir) dist-bzip2: distdir - tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2 - $(am__post_remove_distdir) + tardir=$(distdir) && $(am__tar) | bzip2 -9 -c >$(distdir).tar.bz2 + $(am__remove_distdir) -dist-lzip: distdir - tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz - $(am__post_remove_distdir) +dist-lzma: distdir + tardir=$(distdir) && $(am__tar) | lzma -9 -c >$(distdir).tar.lzma + $(am__remove_distdir) dist-xz: distdir - tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz - $(am__post_remove_distdir) + tardir=$(distdir) && $(am__tar) | xz -c >$(distdir).tar.xz + $(am__remove_distdir) dist-tarZ: distdir tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z - $(am__post_remove_distdir) + $(am__remove_distdir) dist-shar: distdir shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz - $(am__post_remove_distdir) + $(am__remove_distdir) dist-zip: distdir -rm -f $(distdir).zip zip -rq $(distdir).zip $(distdir) - $(am__post_remove_distdir) + $(am__remove_distdir) -dist dist-all: - $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:' - $(am__post_remove_distdir) +dist dist-all: distdir + tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz + $(am__remove_distdir) # This target untars the dist file and tries a VPATH configuration. Then # it guarantees that the distribution is self-contained by making another @@ -650,8 +584,8 @@ distcheck: dist GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\ *.tar.bz2*) \ bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ - *.tar.lz*) \ - lzip -dc $(distdir).tar.lz | $(am__untar) ;;\ + *.tar.lzma*) \ + lzma -dc $(distdir).tar.lzma | $(am__untar) ;;\ *.tar.xz*) \ xz -dc $(distdir).tar.xz | $(am__untar) ;;\ *.tar.Z*) \ @@ -661,9 +595,9 @@ distcheck: dist *.zip*) \ unzip $(distdir).zip ;;\ esac - chmod -R a-w $(distdir) - chmod u+w $(distdir) - mkdir $(distdir)/_build $(distdir)/_inst + chmod -R a-w $(distdir); chmod u+w $(distdir) + mkdir $(distdir)/_build + mkdir $(distdir)/_inst chmod a-w $(distdir) test -d $(distdir)/_build || exit 0; \ dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ @@ -671,7 +605,6 @@ distcheck: dist && am__cwd=`pwd` \ && $(am__cd) $(distdir)/_build \ && ../configure --srcdir=.. --prefix="$$dc_install_base" \ - $(AM_DISTCHECK_CONFIGURE_FLAGS) \ $(DISTCHECK_CONFIGURE_FLAGS) \ && $(MAKE) $(AM_MAKEFLAGS) \ && $(MAKE) $(AM_MAKEFLAGS) dvi \ @@ -695,21 +628,13 @@ distcheck: dist && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ && cd "$$am__cwd" \ || exit 1 - $(am__post_remove_distdir) + $(am__remove_distdir) @(echo "$(distdir) archives ready for distribution: "; \ list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' distuninstallcheck: - @test -n '$(distuninstallcheck_dir)' || { \ - echo 'ERROR: trying to run $@ with an empty' \ - '$$(distuninstallcheck_dir)' >&2; \ - exit 1; \ - }; \ - $(am__cd) '$(distuninstallcheck_dir)' || { \ - echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \ - exit 1; \ - }; \ - test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \ + @$(am__cd) '$(distuninstallcheck_dir)' \ + && test `$(distuninstallcheck_listfiles) | wc -l` -le 1 \ || { echo "ERROR: files left after uninstall:" ; \ if test -n "$(DESTDIR)"; then \ echo " (check DESTDIR support)"; \ @@ -743,15 +668,10 @@ install-am: all-am installcheck: installcheck-recursive install-strip: - if test -z '$(STRIP)'; then \ - $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ - install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ - install; \ - else \ - $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ - install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ - "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ - fi + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install mostlyclean-generic: clean-generic: @@ -833,24 +753,25 @@ ps-am: uninstall-am: uninstall-includeHEADERS -.MAKE: $(am__recursive_targets) install-am install-strip +.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) ctags-recursive \ + install-am install-strip tags-recursive -.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \ - am--refresh check check-am clean clean-cscope clean-generic \ - clean-libtool cscope cscopelist-am ctags ctags-am dist \ - dist-all dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ \ - dist-xz dist-zip distcheck distclean distclean-generic \ - distclean-hdr distclean-libtool distclean-tags distcleancheck \ - distdir distuninstallcheck dvi dvi-am html html-am info \ - info-am install install-am install-data install-data-am \ - install-dvi install-dvi-am install-exec install-exec-am \ - install-html install-html-am install-includeHEADERS \ - install-info install-info-am install-man install-pdf \ - install-pdf-am install-ps install-ps-am install-strip \ - installcheck installcheck-am installdirs installdirs-am \ - maintainer-clean maintainer-clean-generic mostlyclean \ - mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ - tags tags-am uninstall uninstall-am uninstall-includeHEADERS +.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ + all all-am am--refresh check check-am clean clean-generic \ + clean-libtool ctags ctags-recursive dist dist-all dist-bzip2 \ + dist-gzip dist-lzma dist-shar dist-tarZ dist-xz dist-zip \ + distcheck distclean distclean-generic distclean-hdr \ + distclean-libtool distclean-tags distcleancheck distdir \ + distuninstallcheck dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-includeHEADERS install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs installdirs-am maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic \ + mostlyclean-libtool pdf pdf-am ps ps-am tags tags-recursive \ + uninstall uninstall-am uninstall-includeHEADERS # Tell versions [3.59,3.63) of GNU make to not export all variables. diff --git a/src/#makefile# b/src/#makefile# new file mode 100644 index 0000000..47a54b1 --- /dev/null +++ b/src/#makefile# @@ -0,0 +1,778 @@ +# makefile.in generated by automake 1.13.4 from makefile.am. +# src/makefile. Generated from makefile.in by configure. + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + + + +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/cafe +pkgincludedir = $(includedir)/cafe +pkglibdir = $(libdir)/cafe +pkglibexecdir = $(libexecdir)/cafe +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = x86_64-unknown-linux-gnu +host_triplet = x86_64-unknown-linux-gnu +am__append_1 = PyCafe.cpp +#am__append_2 = zbsCafeService.cpp zbsDataHolders.cpp \ +# bitshuffle/bitshuffle_core.c bitshuffle/bitshuffle.c bitshuffle/iochain.c + +subdir = src +DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \ + $(top_srcdir)/./depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \ + $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \ + $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/./include/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +libcafe_la_LIBADD = +am__libcafe_la_SOURCES_DIST = cafe.cpp cafeCache.cpp cafeGroup.cpp \ + cafeVectors.cpp cafeXML.cpp callbackHandlerCreate.cpp \ + callbackHandlerMonitor.cpp conduit.cpp connect.cpp \ + connectCallbacks.cpp exceptionsHelper.cpp granules.cpp \ + handleHelper.cpp loadCollectionXMLParser.cpp \ + loadGroupXMLParser.cpp methodCallbacks.cpp helper.cpp \ + policyHelper.cpp conduitGroup.cpp connectGroup.cpp \ + transpose.cpp restorePVGroupXMLParser.cpp PyCafe.cpp \ + zbsCafeService.cpp zbsDataHolders.cpp \ + bitshuffle/bitshuffle_core.c bitshuffle/bitshuffle.c \ + bitshuffle/iochain.c +am__objects_1 = PyCafe.lo +am__dirstamp = $(am__leading_dot)dirstamp +#am__objects_2 = zbsCafeService.lo zbsDataHolders.lo \ +# bitshuffle/bitshuffle_core.lo \ +# bitshuffle/bitshuffle.lo \ +# bitshuffle/iochain.lo +am_libcafe_la_OBJECTS = cafe.lo cafeCache.lo cafeGroup.lo \ + cafeVectors.lo cafeXML.lo callbackHandlerCreate.lo \ + callbackHandlerMonitor.lo conduit.lo connect.lo \ + connectCallbacks.lo exceptionsHelper.lo granules.lo \ + handleHelper.lo loadCollectionXMLParser.lo \ + loadGroupXMLParser.lo methodCallbacks.lo helper.lo \ + policyHelper.lo conduitGroup.lo connectGroup.lo transpose.lo \ + restorePVGroupXMLParser.lo $(am__objects_1) $(am__objects_2) +libcafe_la_OBJECTS = $(am_libcafe_la_OBJECTS) +AM_V_lt = $(am__v_lt_$(V)) +am__v_lt_ = $(am__v_lt_$(AM_DEFAULT_VERBOSITY)) +am__v_lt_0 = --silent +am__v_lt_1 = +libcafe_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(libcafe_la_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_P = $(am__v_P_$(V)) +am__v_P_ = $(am__v_P_$(AM_DEFAULT_VERBOSITY)) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_$(V)) +am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY)) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_$(V)) +am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY)) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = -I. -I$(top_builddir)/./include +depcomp = $(SHELL) $(top_srcdir)/./depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CFLAGS) $(CFLAGS) +AM_V_CC = $(am__v_CC_$(V)) +am__v_CC_ = $(am__v_CC_$(AM_DEFAULT_VERBOSITY)) +am__v_CC_0 = @echo " CC " $@; +am__v_CC_1 = +CCLD = $(CC) +LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CCLD = $(am__v_CCLD_$(V)) +am__v_CCLD_ = $(am__v_CCLD_$(AM_DEFAULT_VERBOSITY)) +am__v_CCLD_0 = @echo " CCLD " $@; +am__v_CCLD_1 = +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_$(V)) +am__v_CXX_ = $(am__v_CXX_$(AM_DEFAULT_VERBOSITY)) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_$(V)) +am__v_CXXLD_ = $(am__v_CXXLD_$(AM_DEFAULT_VERBOSITY)) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libcafe_la_SOURCES) +DIST_SOURCES = $(am__libcafe_la_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing aclocal-1.13 +AMTAR = $${TAR-tar} + +#if HAVE_PYCAFE_EXT_ +#libcafe_la_SOURCES += PyCafe.cpp +#endif +#else +#if HAVE_PYTHON_ +#libcafe_la_SOURCES += pycafe/PyCafe.cpp +#endif +AM_CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base-7.0.6/include/ -I/usr/local/epics/base-7.0.6/include/os/Linux -I/usr/local/epics/base-7.0.6/include/compiler/gcc -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml -I$(top_srcdir)/include +AM_DEFAULT_VERBOSITY = 1 +AM_LDFLAGS = -L/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -Wl,-rpath,/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib +AR = ar +AUTOCONF = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing autoconf +AUTOHEADER = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing autoheader +AUTOMAKE = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing automake-1.13 +AWK = gawk +CAFE_CPPFLAGS = -I$(top_srcdir)/include +CC = /opt/psi/Programming/gcc/7.3.0/bin/gcc +CCDEPMODE = depmode=gcc3 +CFLAGS = -g -O2 +CPP = /opt/psi/Programming/gcc/7.3.0/bin/gcc -E +CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base-7.0.6/include/ -I/usr/local/epics/base-7.0.6/include/os/Linux -I/usr/local/epics/base-7.0.6/include/compiler/gcc -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml +CXX = /opt/psi/Programming/gcc/7.3.0/bin/g++ +CXXCPP = /opt/psi/Programming/gcc/7.3.0/bin/g++ -E +CXXDEPMODE = depmode=gcc3 +CXXFLAGS = -g -O2 +CYGPATH_W = echo +DEFS = -DHAVE_CONFIG_H +DEPDIR = .deps +DLLTOOL = false +DSYMUTIL = +DUMPBIN = +ECHO_C = +ECHO_N = -n +ECHO_T = +EGREP = /usr/bin/grep -E +EXEEXT = +FGREP = /usr/bin/grep -F +GREP = /usr/bin/grep +INSTALL = /usr/bin/install -c +INSTALL_DATA = ${INSTALL} -m 644 +INSTALL_PROGRAM = ${INSTALL} +INSTALL_SCRIPT = ${INSTALL} +INSTALL_STRIP_PROGRAM = $(install_sh) -c -s +LD = /usr/bin/ld -m elf_x86_64 +LDFLAGS = -L/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -Wl,-rpath,/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib +LIBOBJS = +LIBS = -lQtXml -lQtCore -lpython3.5m +LIBTOOL = $(SHELL) $(top_builddir)/libtool +LIPO = +LN_S = ln -s +LTLIBOBJS = +LT_SYS_LIBRARY_PATH = +MAKEINFO = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing makeinfo +MANIFEST_TOOL = : +MKDIR_P = /usr/bin/mkdir -p +NM = /usr/bin/nm -B +NMEDIT = +OBJDUMP = objdump +OBJEXT = o +OTOOL = +OTOOL64 = +PACKAGE = cafe +PACKAGE_BUGREPORT = Bug reports to: jan.chrin@psi.ch +PACKAGE_NAME = CAFE +PACKAGE_STRING = CAFE 1.15.1 +PACKAGE_TARNAME = cafe +PACKAGE_URL = +PACKAGE_VERSION = 1.15.1 +PATH_SEPARATOR = : +RANLIB = ranlib +SED = /usr/bin/sed +SET_MAKE = +SHELL = /bin/sh +STRIP = strip +VERSION = 1.15.1 +abs_builddir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/src +abs_srcdir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/src +abs_top_builddir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp +abs_top_srcdir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp +ac_ct_AR = ar +ac_ct_CC = /opt/psi/Programming/gcc/7.3.0/bin/gcc +ac_ct_CXX = +ac_ct_DUMPBIN = +am__include = include +am__leading_dot = . +am__quote = +am__tar = $${TAR-tar} chof - "$$tardir" +am__untar = $${TAR-tar} xf - +bindir = ${exec_prefix}/bin +build = x86_64-unknown-linux-gnu +build_alias = +build_cpu = x86_64 +build_os = linux-gnu +build_vendor = unknown +builddir = . +datadir = ${datarootdir} +datarootdir = ${prefix}/share +docdir = ${datarootdir}/doc/${PACKAGE_TARNAME} +dvidir = ${docdir} +exec_prefix = ${prefix} +host = x86_64-unknown-linux-gnu +host_alias = +host_cpu = x86_64 +host_os = linux-gnu +host_vendor = unknown +htmldir = ${docdir} +includedir = ${prefix}/include +infodir = ${datarootdir}/info +install_sh = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/install-sh +libdir = /opt/gfa/cafe/cpp/cafe-1.15.1-py35-gcc-7.3.0/lib/RHEL7-x86_64 +libexecdir = ${exec_prefix}/libexec +localedir = ${datarootdir}/locale +localstatedir = ${prefix}/var +mandir = ${datarootdir}/man +mkdir_p = $(MKDIR_P) +oldincludedir = /usr/include +pdfdir = ${docdir} +prefix = /opt/gfa/cafe/cpp/cafe-1.15.1-py35-gcc-7.3.0 +program_transform_name = s,x,x, +psdir = ${docdir} +sbindir = ${exec_prefix}/sbin +sharedstatedir = ${prefix}/com +srcdir = . +sysconfdir = ${prefix}/etc +target_alias = +top_build_prefix = ../ +top_builddir = .. +top_srcdir = .. +lib_LTLIBRARIES = libcafe.la + +#10:2:9 11:2:10 12:0:11 12:1:11 13.0.12 13.1.12 13:2:12 13.4.12 +#current:revision:age +#maps in soname to: +#1st: current-age +#2nd: age +#3rd: revision +#1.9.1 1.10.2 1.11.0 1.11.1 1.12.0 1.12.1 1.12.2 1.12.4 +libcafe_la_LDFLAGS = -version-info 16:1:15 +libcafe_la_SOURCES = cafe.cpp cafeCache.cpp cafeGroup.cpp \ + cafeVectors.cpp cafeXML.cpp callbackHandlerCreate.cpp \ + callbackHandlerMonitor.cpp conduit.cpp connect.cpp \ + connectCallbacks.cpp exceptionsHelper.cpp granules.cpp \ + handleHelper.cpp loadCollectionXMLParser.cpp \ + loadGroupXMLParser.cpp methodCallbacks.cpp helper.cpp \ + policyHelper.cpp conduitGroup.cpp connectGroup.cpp \ + transpose.cpp restorePVGroupXMLParser.cpp $(am__append_1) \ + $(am__append_2) +all: all-am + +.SUFFIXES: +.SUFFIXES: .c .cpp .lo .o .obj +$(srcdir)/makefile.in: $(srcdir)/makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu src/makefile +.PRECIOUS: makefile +makefile: $(srcdir)/makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } +bitshuffle/$(am__dirstamp): + @$(MKDIR_P) bitshuffle + @: > bitshuffle/$(am__dirstamp) +bitshuffle/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) bitshuffle/$(DEPDIR) + @: > bitshuffle/$(DEPDIR)/$(am__dirstamp) +bitshuffle/bitshuffle_core.lo: bitshuffle/$(am__dirstamp) \ + bitshuffle/$(DEPDIR)/$(am__dirstamp) +bitshuffle/bitshuffle.lo: bitshuffle/$(am__dirstamp) \ + bitshuffle/$(DEPDIR)/$(am__dirstamp) +bitshuffle/iochain.lo: bitshuffle/$(am__dirstamp) \ + bitshuffle/$(DEPDIR)/$(am__dirstamp) + +libcafe.la: $(libcafe_la_OBJECTS) $(libcafe_la_DEPENDENCIES) $(EXTRA_libcafe_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libcafe_la_LINK) -rpath $(libdir) $(libcafe_la_OBJECTS) $(libcafe_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + -rm -f bitshuffle/*.$(OBJEXT) + -rm -f bitshuffle/*.lo + +distclean-compile: + -rm -f *.tab.c + +include ./$(DEPDIR)/PyCafe.Plo +include ./$(DEPDIR)/cafe.Plo +include ./$(DEPDIR)/cafeCache.Plo +include ./$(DEPDIR)/cafeGroup.Plo +include ./$(DEPDIR)/cafeVectors.Plo +include ./$(DEPDIR)/cafeXML.Plo +include ./$(DEPDIR)/callbackHandlerCreate.Plo +include ./$(DEPDIR)/callbackHandlerMonitor.Plo +include ./$(DEPDIR)/conduit.Plo +include ./$(DEPDIR)/conduitGroup.Plo +include ./$(DEPDIR)/connect.Plo +include ./$(DEPDIR)/connectCallbacks.Plo +include ./$(DEPDIR)/connectGroup.Plo +include ./$(DEPDIR)/exceptionsHelper.Plo +include ./$(DEPDIR)/granules.Plo +include ./$(DEPDIR)/handleHelper.Plo +include ./$(DEPDIR)/helper.Plo +include ./$(DEPDIR)/loadCollectionXMLParser.Plo +include ./$(DEPDIR)/loadGroupXMLParser.Plo +include ./$(DEPDIR)/methodCallbacks.Plo +include ./$(DEPDIR)/policyHelper.Plo +include ./$(DEPDIR)/restorePVGroupXMLParser.Plo +include ./$(DEPDIR)/transpose.Plo +include ./$(DEPDIR)/zbsCafeService.Plo +include ./$(DEPDIR)/zbsDataHolders.Plo +include bitshuffle/$(DEPDIR)/bitshuffle.Plo +include bitshuffle/$(DEPDIR)/bitshuffle_core.Plo +include bitshuffle/$(DEPDIR)/iochain.Plo + +.c.o: + $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ + $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ + $(am__mv) $$depbase.Tpo $$depbase.Po +# $(AM_V_CC)source='$<' object='$@' libtool=no \ +# DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \ +# $(AM_V_CC_no)$(COMPILE) -c -o $@ $< + +.c.obj: + $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ + $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ + $(am__mv) $$depbase.Tpo $$depbase.Po +# $(AM_V_CC)source='$<' object='$@' libtool=no \ +# DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \ +# $(AM_V_CC_no)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.c.lo: + $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ + $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ + $(am__mv) $$depbase.Tpo $$depbase.Plo +# $(AM_V_CC)source='$<' object='$@' libtool=yes \ +# DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \ +# $(AM_V_CC_no)$(LTCOMPILE) -c -o $@ $< + +.cpp.o: + $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ + $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ + $(am__mv) $$depbase.Tpo $$depbase.Po +# $(AM_V_CXX)source='$<' object='$@' libtool=no \ +# DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) \ +# $(AM_V_CXX_no)$(CXXCOMPILE) -c -o $@ $< + +.cpp.obj: + $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ + $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ + $(am__mv) $$depbase.Tpo $$depbase.Po +# $(AM_V_CXX)source='$<' object='$@' libtool=no \ +# DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) \ +# $(AM_V_CXX_no)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cpp.lo: + $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ + $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ + $(am__mv) $$depbase.Tpo $$depbase.Plo +# $(AM_V_CXX)source='$<' object='$@' libtool=yes \ +# DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) \ +# $(AM_V_CXX_no)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + -rm -rf bitshuffle/.libs bitshuffle/_libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: makefile $(LTLIBRARIES) +installdirs: + for dir in "$(DESTDIR)$(libdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + -rm -f bitshuffle/$(DEPDIR)/$(am__dirstamp) + -rm -f bitshuffle/$(am__dirstamp) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) bitshuffle/$(DEPDIR) + -rm -f makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) bitshuffle/$(DEPDIR) + -rm -f makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \ + ctags-am distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/src/PyCafe_sls_py37.cpp b/src/PyCafe_sls_py37.cpp index 62e3ec1..c666ee5 100644 --- a/src/PyCafe_sls_py37.cpp +++ b/src/PyCafe_sls_py37.cpp @@ -6,30 +6,29 @@ "depends": [ "/opt/gfa/cafe/boost/boost_1_61_0/include/boost/multi_index_container.hpp", "/opt/gfa/cafe/boost/boost_1_61_0/include/boost/smart_ptr/shared_ptr.hpp", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/PVCtrlHolder.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/PVDataHolder.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/PVGroup.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/cafe.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/cafeDataType.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/cafeEnum.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/caopCodes.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/channelRegalia.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/defines.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/exceptions.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/handleHelper.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/policies.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/policyHelper.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/statusCodes.h", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include/tmDateMap.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/PVCtrlHolder.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/PVDataHolder.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/PVGroup.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/cafe.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/cafeDataType.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/cafeEnum.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/caopCodes.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/channelRegalia.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/defines.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/exceptions.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/handleHelper.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/policies.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/policyHelper.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/statusCodes.h", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include/tmDateMap.h", + "/opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/numpy/core/include/numpy/arrayobject.h", + "/opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/numpy/core/include/numpy/ufuncobject.h", "/opt/gfa/python-3.7/latest/include/python3.7m/Python.h", "/opt/gfa/python-3.7/latest/include/python3.7m/pythread.h", - "/opt/gfa/python-3.7/latest/lib/python3.7/site-packages/numpy/core/include/numpy/arrayobject.h", - "/opt/gfa/python-3.7/latest/lib/python3.7/site-packages/numpy/core/include/numpy/ufuncobject.h", "/usr/local/epics/base-7.0.6/include/cadef.h", "/usr/local/epics/base-7.0.6/include/caerr.h", "/usr/local/epics/base-7.0.6/include/caeventmask.h", "/usr/local/epics/base-7.0.6/include/db_access.h", - "/usr/local/epics/base-7.0.6/include/epicsMutex.h", "/usr/local/epics/base-7.0.6/include/epicsTime.h" ], "include_dirs": [ @@ -39,9 +38,9 @@ "/usr/local/epics/base-7.0.6/include/compiler/gcc", "/opt/gfa/cafe/boost/boost_1_61_0/include", "/opt/gfa/cafe/boost/boost_1_61_0/include/boost", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/include", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/include", ".", - "/opt/gfa/python-3.7/latest/lib/python3.7/site-packages/numpy/core/include" + "/opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/numpy/core/include" ], "language": "c++", "libraries": [ @@ -52,7 +51,7 @@ ], "library_dirs": [ "/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/lib/RHEL7-x86_64", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/lib/RHEL7-x86_64", "/opt/psi/Programming/gcc/7.3.0/lib64", "/opt/psi/Programming/gcc/7.3.0/lib", "/opt/gfa/python-3.7/latest/lib" @@ -60,7 +59,7 @@ "name": "PyCafe", "runtime_library_dirs": [ "/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64", - "/opt/gfa/cafe/cpp/cafe-1.15.0-py37-gcc-7.3.0/lib/RHEL7-x86_64", + "/opt/gfa/cafe/cpp/cafe-1.15.1-py37-gcc-7.3.0/lib/RHEL7-x86_64", "/opt/psi/Programming/gcc/7.3.0/lib64", "/opt/psi/Programming/gcc/7.3.0/lib" ], @@ -708,7 +707,6 @@ static CYTHON_INLINE float __PYX_NAN() { #include "numpy/ufuncobject.h" #include "boost/multi_index_container.hpp" #include "boost/smart_ptr/shared_ptr.hpp" -#include "epicsMutex.h" #include "cadef.h" #include "defines.h" #include "caeventmask.h" @@ -1081,7 +1079,7 @@ typedef struct { } __Pyx_BufFmt_Context; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< @@ -1090,7 +1088,7 @@ typedef struct { */ typedef npy_int8 __pyx_t_5numpy_int8_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< @@ -1099,7 +1097,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t; */ typedef npy_int16 __pyx_t_5numpy_int16_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< @@ -1108,7 +1106,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t; */ typedef npy_int32 __pyx_t_5numpy_int32_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< @@ -1117,7 +1115,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t; */ typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< @@ -1126,7 +1124,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t; */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< @@ -1135,7 +1133,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t; */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< @@ -1144,7 +1142,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t; */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< @@ -1153,7 +1151,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t; */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< @@ -1162,7 +1160,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t; */ typedef npy_float32 __pyx_t_5numpy_float32_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< @@ -1171,7 +1169,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; */ typedef npy_float64 __pyx_t_5numpy_float64_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< @@ -1180,7 +1178,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t; */ typedef npy_long __pyx_t_5numpy_int_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< @@ -1189,7 +1187,7 @@ typedef npy_long __pyx_t_5numpy_int_t; */ typedef npy_longlong __pyx_t_5numpy_long_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< @@ -1198,7 +1196,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t; */ typedef npy_longlong __pyx_t_5numpy_longlong_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< @@ -1207,7 +1205,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t; */ typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< @@ -1216,7 +1214,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< @@ -1225,7 +1223,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< @@ -1234,7 +1232,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; */ typedef npy_intp __pyx_t_5numpy_intp_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":809 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":809 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< @@ -1243,7 +1241,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t; */ typedef npy_uintp __pyx_t_5numpy_uintp_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< @@ -1252,7 +1250,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t; */ typedef npy_double __pyx_t_5numpy_float_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< @@ -1261,7 +1259,7 @@ typedef npy_double __pyx_t_5numpy_float_t; */ typedef npy_double __pyx_t_5numpy_double_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< @@ -1313,7 +1311,7 @@ struct __pyx_MemviewEnum_obj; struct __pyx_memoryview_obj; struct __pyx_memoryviewslice_obj; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< @@ -1322,7 +1320,7 @@ struct __pyx_memoryviewslice_obj; */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< @@ -1331,7 +1329,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":817 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":817 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< @@ -1340,7 +1338,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":819 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":819 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< @@ -1355,7 +1353,7 @@ struct __pyx_opt_args_6PyCafe_6CyCafe_checkForHandle; struct __pyx_opt_args_6PyCafe_6CyCafe_checkForHandleList; struct __pyx_opt_args_6PyCafe_6CyCafe_checkForGroupHandle; -/* "PyCafeDefs.pxi":1173 +/* "PyCafeDefs.pxi":1202 * ################################################################################# * * cdef pvdata PVDataHolderToStruct(PVDataHolder pvd, dt=None): # <<<<<<<<<<<<<< @@ -1367,7 +1365,7 @@ struct __pyx_opt_args_6PyCafe_PVDataHolderToStruct { PyObject *dt; }; -/* "PyCafeDefs.pxi":1296 +/* "PyCafeDefs.pxi":1327 * ################################################################################# * * cdef pvctrl PVCtrlHolderToStruct(PVCtrlHolder pvc, dt=None): # <<<<<<<<<<<<<< @@ -1379,7 +1377,7 @@ struct __pyx_opt_args_6PyCafe_PVCtrlHolderToStruct { PyObject *dt; }; -/* "PyCafe.pyx":322 +/* "PyCafe.pyx":321 * * cdef prepareCafeException( * self, int status, str _METHOD, # <<<<<<<<<<<<<< @@ -1392,7 +1390,7 @@ struct __pyx_opt_args_6PyCafe_6CyCafe_prepareCafeException { PyObject *pv_name; }; -/* "PyCafe.pyx":1645 +/* "PyCafe.pyx":1644 * ############################################################################ * ### Allow user to choose whether or not to open ##### * cpdef checkForHandle(self, str pv, bint force=True): # <<<<<<<<<<<<<< @@ -1404,7 +1402,7 @@ struct __pyx_opt_args_6PyCafe_6CyCafe_checkForHandle { int force; }; -/* "PyCafe.pyx":1658 +/* "PyCafe.pyx":1657 * * ############################################################################ * cpdef checkForHandleList(self, list pvList, bint force=True): # <<<<<<<<<<<<<< @@ -1416,7 +1414,7 @@ struct __pyx_opt_args_6PyCafe_6CyCafe_checkForHandleList { int force; }; -/* "PyCafe.pyx":1679 +/* "PyCafe.pyx":1678 * * ############################################################################ * cpdef checkForGroupHandle(self, str gName, bint force=True): # <<<<<<<<<<<<<< @@ -2337,6 +2335,25 @@ static PyObject* __Pyx_PyObject_Format(PyObject* s, PyObject* f); #define __Pyx_PyObject_Format(s, f) PyObject_Format(s, f) #endif +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + /* decode_c_string_utf16.proto */ static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { int byteorder = 0; @@ -2367,22 +2384,6 @@ static CYTHON_INLINE PyObject* __Pyx_decode_bytes( start, stop, encoding, errors, decode_func); } -/* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); -#endif - -/* SaveResetException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -#else -#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) -#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) -#endif - /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { @@ -2409,9 +2410,6 @@ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name /* append.proto */ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); -/* None.proto */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); - /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) @@ -2583,33 +2581,6 @@ static CYTHON_INLINE int __Pyx_IterFinish(void); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); -/* PyObjectCallMethod0.proto */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); - -/* RaiseNoneIterError.proto */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); - -/* UnpackTupleError.proto */ -static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); - -/* UnpackTuple2.proto */ -#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ - (likely(is_tuple || PyTuple_Check(tuple)) ?\ - (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ - __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ - (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ - __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) -static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( - PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); -static int __Pyx_unpack_tuple2_generic( - PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); - -/* dict_iter.proto */ -static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, - Py_ssize_t* p_orig_length, int* p_is_dict); -static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, - PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); - /* py_dict_values.proto */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d); @@ -2677,6 +2648,9 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); @@ -3510,6 +3484,7 @@ __PYX_EXTERN_C void cy_handle_handler_wrapper(void *, unsigned int); /*proto*/ __PYX_EXTERN_C void cy_connect_handler_wrapper(void *, unsigned int, std::string, int); /*proto*/ __PYX_EXTERN_C void cy_cb_handle_get_wrapper(void *, unsigned int); /*proto*/ __PYX_EXTERN_C void cy_cb_handle_put_wrapper(void *, unsigned int); /*proto*/ +static PyObject *__pyx_f_6PyCafe_encodeString(PyObject *); /*proto*/ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *, PyObject *); /*proto*/ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVDataHolder, struct __pyx_opt_args_6PyCafe_PVDataHolderToStruct *__pyx_optional_args); /*proto*/ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVCtrlHolder, struct __pyx_opt_args_6PyCafe_PVCtrlHolderToStruct *__pyx_optional_args); /*proto*/ @@ -3596,7 +3571,6 @@ static PyObject *__pyx_builtin_Ellipsis; static PyObject *__pyx_builtin_id; static PyObject *__pyx_builtin_IndexError; static const char __pyx_k_0[] = "({0})"; -static const char __pyx_k_1[] = "============//1//"; static const char __pyx_k_C[] = "C"; static const char __pyx_k_O[] = "O"; static const char __pyx_k_c[] = "c"; @@ -3650,13 +3624,12 @@ static const char __pyx_k_None[] = "None"; static const char __pyx_k_PV_2[] = "PV="; static const char __pyx_k_PV_3[] = " PV="; static const char __pyx_k_PV_4[] = "PV"; -static const char __pyx_k__103[] = "============"; -static const char __pyx_k__106[] = "======================================================"; -static const char __pyx_k__110[] = "=============="; -static const char __pyx_k__113[] = "["; -static const char __pyx_k__114[] = "]"; -static const char __pyx_k__135[] = " : "; -static const char __pyx_k__168[] = "."; +static const char __pyx_k__101[] = "======================================================"; +static const char __pyx_k__105[] = "=============="; +static const char __pyx_k__108[] = "["; +static const char __pyx_k__109[] = "]"; +static const char __pyx_k__130[] = " : "; +static const char __pyx_k__163[] = "."; static const char __pyx_k_args[] = "args"; static const char __pyx_k_base[] = "base"; static const char __pyx_k_bool[] = "bool"; @@ -3671,8 +3644,6 @@ static const char __pyx_k_int8[] = "int8"; static const char __pyx_k_intc[] = "intc"; static const char __pyx_k_intp[] = "intp"; static const char __pyx_k_keys[] = "keys"; -static const char __pyx_k_len1[] = "len1"; -static const char __pyx_k_len2[] = "len2"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_mask[] = "mask ="; static const char __pyx_k_mode[] = "mode"; @@ -3739,7 +3710,7 @@ static const char __pyx_k_uchar[] = "uchar"; static const char __pyx_k_uint8[] = "uint8"; static const char __pyx_k_uintc[] = "uintc"; static const char __pyx_k_uintp[] = "uintp"; -static const char __pyx_k_utf_8[] = "utf_8"; +static const char __pyx_k_utf_8[] = "utf-8"; static const char __pyx_k_value[] = "value = "; static const char __pyx_k_CyCafe[] = "CyCafe"; static const char __pyx_k_Cython[] = "Cython"; @@ -3756,6 +3727,7 @@ static const char __pyx_k_c_char[] = "c_char"; static const char __pyx_k_c_int8[] = "c_int8"; static const char __pyx_k_c_long[] = "c_long"; static const char __pyx_k_c_uint[] = "c_uint"; +static const char __pyx_k_client[] = "client"; static const char __pyx_k_ctypes[] = "ctypes"; static const char __pyx_k_decode[] = "decode"; static const char __pyx_k_double[] = "double"; @@ -3795,7 +3767,7 @@ static const char __pyx_k_uint64[] = "uint64"; static const char __pyx_k_unpack[] = "unpack"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_ushort[] = "ushort"; -static const char __pyx_k_utf_16[] = "utf_16"; +static const char __pyx_k_utf_16[] = "utf-16"; static const char __pyx_k_utf_32[] = "utf_32"; static const char __pyx_k_valSet[] = "valSet"; static const char __pyx_k_values[] = "values"; @@ -3814,6 +3786,7 @@ static const char __pyx_k_c_voidp[] = "c_voidp"; static const char __pyx_k_c_wchar[] = "c_wchar"; static const char __pyx_k_dbrBase[] = "dbrBase"; static const char __pyx_k_deltaMS[] = "deltaMS"; +static const char __pyx_k_dtcheck[] = "dtcheck"; static const char __pyx_k_float16[] = "float16"; static const char __pyx_k_float32[] = "float32"; static const char __pyx_k_float64[] = "float64"; @@ -3839,11 +3812,12 @@ static const char __pyx_k_numbers[] = "numbers"; static const char __pyx_k_pulseID[] = "pulseID ="; static const char __pyx_k_pv_name[] = "_pv_name"; static const char __pyx_k_pvgroup[] = "pvgroup"; +static const char __pyx_k_request[] = "request"; static const char __pyx_k_showMax[] = "showMax"; static const char __pyx_k_timeout[] = "timeout"; static const char __pyx_k_unicode[] = "unicode"; static const char __pyx_k_units_s[] = "units = %s"; -static const char __pyx_k_utf_8_2[] = "utf-8"; +static const char __pyx_k_utf_8_2[] = "utf_8"; static const char __pyx_k_valList[] = "valList"; static const char __pyx_k_value_2[] = "value ="; static const char __pyx_k_value_3[] = "value\t = "; @@ -3898,13 +3872,11 @@ static const char __pyx_k_status_d[] = "status = %d"; static const char __pyx_k_string_2[] = "string_"; static const char __pyx_k_tsDate_2[] = "tsDate"; static const char __pyx_k_userArgs[] = "userArgs ="; -static const char __pyx_k_utf_16_2[] = "utf-16"; +static const char __pyx_k_utf_16_2[] = "utf_16"; static const char __pyx_k_utf_32_2[] = "utf-32"; static const char __pyx_k_utf_none[] = "utf-none"; static const char __pyx_k_waveform[] = "waveform"; static const char __pyx_k_CafeError[] = "CafeError"; -static const char __pyx_k_Parameter[] = "Parameter:"; -static const char __pyx_k_SIGNATURE[] = "SIGNATURE:"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_c_ssize_t[] = "c_ssize_t"; static const char __pyx_k_c_wchar_p[] = "c_wchar_p"; @@ -3916,7 +3888,6 @@ static const char __pyx_k_getStatus[] = "getStatus"; static const char __pyx_k_groupOpen[] = "groupOpen"; static const char __pyx_k_handlesPV[] = "handlesPV"; static const char __pyx_k_has_error[] = " has error: "; -static const char __pyx_k_monitorid[] = "monitorid"; static const char __pyx_k_np_string[] = "np.string"; static const char __pyx_k_np_uint16[] = "np.uint16"; static const char __pyx_k_np_uint32[] = "np.uint32"; @@ -3950,7 +3921,6 @@ static const char __pyx_k_getPVGroup[] = "getPVGroup"; static const char __pyx_k_handleList[] = "handleList"; static const char __pyx_k_hostName_s[] = "hostName = %s"; static const char __pyx_k_memoryview[] = "memoryview"; -static const char __pyx_k_monitor_id[] = "monitor id"; static const char __pyx_k_np_float16[] = "np.float16"; static const char __pyx_k_np_float32[] = "np.float32"; static const char __pyx_k_np_float64[] = "np.float64"; @@ -3970,7 +3940,6 @@ static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_OrderedDict[] = "OrderedDict"; static const char __pyx_k_PickleError[] = "PickleError"; -static const char __pyx_k_SIGNATURE_2[] = "SIGNATURE//2//:"; static const char __pyx_k_UserWarning[] = "UserWarning"; static const char __pyx_k_alarmStatus[] = "alarmStatus = "; static const char __pyx_k_array_array[] = "array.array"; @@ -4016,6 +3985,7 @@ static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_version_info[] = "version_info"; static const char __pyx_k_CAFEException[] = "CAFEException"; static const char __pyx_k_CafeException[] = "------CafeException-----------------------------------------------------"; +static const char __pyx_k_END_TIME_CHAR[] = "END TIME CHAR"; static const char __pyx_k_accessWrite_d[] = "accessWrite = %d"; static const char __pyx_k_alarmSeverity[] = "alarmSeverity = "; static const char __pyx_k_alarmStatus_2[] = "alarmStatus"; @@ -4073,6 +4043,7 @@ static const char __pyx_k_verify_handlepv[] = "verify_handlepv"; static const char __pyx_k_waitForGetEvent[] = "waitForGetEvent"; static const char __pyx_k_Error_in_Element[] = "Error in Element "; static const char __pyx_k_getChannelDevice[] = "getChannelDevice"; +static const char __pyx_k_length_of_ui8val[] = "length of ui8val"; static const char __pyx_k_maskHasDBE_ALARM[] = "maskHasDBE_ALARM ="; static const char __pyx_k_maskHasDBE_VALUE[] = "maskHasDBE_VALUE ="; static const char __pyx_k_no_encoding_done[] = "no encoding done"; @@ -4132,7 +4103,7 @@ static const char __pyx_k_getDbrBaseInCallback[] = "getDbrBaseInCallback"; static const char __pyx_k_groupOpen_char_gname[] = "groupOpen(char * gname)"; static const char __pyx_k_initCallbackComplete[] = "initCallbackComplete"; static const char __pyx_k_strided_and_indirect[] = ""; -static const char __pyx_k_1_15_0_py37_gcc_7_3_0[] = "1.15.0-py37-gcc-7.3.0"; +static const char __pyx_k_1_15_1_py37_gcc_7_3_0[] = "1.15.1-py37-gcc-7.3.0"; static const char __pyx_k_Allowed_DBR_TYPEs_are[] = "Allowed DBR_TYPEs are:"; static const char __pyx_k_ICAFE_CA_OP_CONN_DOWN[] = "ICAFE_CA_OP_CONN_DOWN"; static const char __pyx_k_The_value_entered_was[] = "The value entered was"; @@ -4178,7 +4149,6 @@ static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cyt static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; static const char __pyx_k_reports_the_following_error[] = ") reports the following error:"; static const char __pyx_k_Error_in_def_getCompoundList[] = "Error in def getCompoundList: "; -static const char __pyx_k_dbr_mask_notify_milliseconds[] = "dbr, mask, notify_milliseconds)"; static const char __pyx_k_groupMonitorStop_ghandleName[] = "groupMonitorStop(ghandleName)"; static const char __pyx_k_in_PyCafe_def_getCompundList[] = " in PyCafe def getCompundList"; static const char __pyx_k_in_PyCafe_def_getScalarArray[] = " in PyCafe def getScalarArray"; @@ -4289,7 +4259,7 @@ static const char __pyx_k_getPVCache_handlePV_str_dt_nativ[] = "getPVCache(handl static const char __pyx_k_getPVGroup_ghandleName_str_dt_na[] = "getPVGroup(ghandleName, str dt='native')"; static const char __pyx_k_getScalarArray_handleList_str_dt[] = "getScalarArray(handleList, str dt, bint cacheFlag)"; static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; -static const char __pyx_k_groupMonitorStartWithCBList_ghan[] = "groupMonitorStartWithCBList(ghandleName, cb,"; +static const char __pyx_k_groupMonitorStartWithCBList_ghan[] = "groupMonitorStartWithCBList(ghandleName, cb,dbr, mask, notify_milliseconds)"; static const char __pyx_k_groupMonitorStart_ghandleName_cb[] = "groupMonitorStart(ghandleName, cb, dbr, mask)"; static const char __pyx_k_grouping_char_gname_list__pvlist[] = "grouping(char * gname, list _pvlist)"; static const char __pyx_k_handleMatch_list_member_should_b[] = "handleMatch list member should be of type if handle, else if PV"; @@ -4370,8 +4340,7 @@ static const char __pyx_k_First_input_argument_should_be_o_10[] = "First input a static const char __pyx_k_First_input_argument_should_be_o_11[] = "First input argument should be of type if group handle, else if group name"; static PyObject *__pyx_kp_u_0; static PyObject *__pyx_kp_u_0_1_2_3_4_5; -static PyObject *__pyx_kp_u_1; -static PyObject *__pyx_kp_u_1_15_0_py37_gcc_7_3_0; +static PyObject *__pyx_kp_u_1_15_1_py37_gcc_7_3_0; static PyObject *__pyx_kp_u_7_0_6; static PyObject *__pyx_n_s_ASCII; static PyObject *__pyx_kp_u_A_handle_can_never_hold_a_negati; @@ -4401,6 +4370,7 @@ static PyObject *__pyx_kp_u_DBR_PLAIN_0_DBR_STS_1_DBR_TIME_2; static PyObject *__pyx_kp_u_Data_to_be_presented_in_native_d; static PyObject *__pyx_kp_u_Datatype_unknown_returning_value; static PyObject *__pyx_kp_u_EGU; +static PyObject *__pyx_kp_u_END_TIME_CHAR; static PyObject *__pyx_kp_u_ENUM_string_value; static PyObject *__pyx_kp_u_ENUM_value; static PyObject *__pyx_kp_u_ERROR_GROUP_MEMBER_MISMATCH; @@ -4526,7 +4496,6 @@ static PyObject *__pyx_kp_u_PV_2; static PyObject *__pyx_kp_u_PV_3; static PyObject *__pyx_n_u_PV_4; static PyObject *__pyx_kp_u_PY_VERSION_HEX_is; -static PyObject *__pyx_kp_u_Parameter; static PyObject *__pyx_n_s_PickleError; static PyObject *__pyx_kp_u_Possible_types_are; static PyObject *__pyx_n_s_PyCafe; @@ -4538,8 +4507,6 @@ static PyObject *__pyx_kp_u_PyCafe_pyx_We_do_not_cater_for_t; static PyObject *__pyx_kp_u_PyCafe_pyx_getArray_array_type_d; static PyObject *__pyx_kp_u_Returning_memoryview; static PyObject *__pyx_n_s_RuntimeError; -static PyObject *__pyx_kp_u_SIGNATURE; -static PyObject *__pyx_kp_u_SIGNATURE_2; static PyObject *__pyx_kp_u_Second_input_argument_if_not_a_l; static PyObject *__pyx_kp_u_Second_input_argument_should_be; static PyObject *__pyx_kp_u_Second_input_argument_should_be_2; @@ -4577,14 +4544,13 @@ static PyObject *__pyx_kp_u_Warning_from_groupMonitorStart; static PyObject *__pyx_kp_u_Warning_from_groupMonitorStartW; static PyObject *__pyx_kp_u_Warning_from_monitorStart_for_h; static PyObject *__pyx_kp_u__10; -static PyObject *__pyx_kp_u__103; -static PyObject *__pyx_kp_u__106; -static PyObject *__pyx_kp_u__110; -static PyObject *__pyx_kp_u__113; -static PyObject *__pyx_kp_u__114; -static PyObject *__pyx_kp_u__135; +static PyObject *__pyx_kp_u__101; +static PyObject *__pyx_kp_u__105; +static PyObject *__pyx_kp_u__108; +static PyObject *__pyx_kp_u__109; +static PyObject *__pyx_kp_u__130; static PyObject *__pyx_kp_u__15; -static PyObject *__pyx_kp_u__168; +static PyObject *__pyx_kp_u__163; static PyObject *__pyx_kp_u__23; static PyObject *__pyx_kp_u__24; static PyObject *__pyx_kp_u__26; @@ -4677,6 +4643,7 @@ static PyObject *__pyx_n_s_checkForHandleList; static PyObject *__pyx_n_u_cinit; static PyObject *__pyx_n_s_class; static PyObject *__pyx_kp_u_className_s; +static PyObject *__pyx_n_u_client; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_u_close; static PyObject *__pyx_n_u_closeChannelKeepHandle; @@ -4701,7 +4668,6 @@ static PyObject *__pyx_n_s_dbrBase; static PyObject *__pyx_kp_u_dbrDataType; static PyObject *__pyx_kp_u_dbr_base_type_should_be_one_of_D; static PyObject *__pyx_kp_u_dbr_base_type_should_be_one_of_D_2; -static PyObject *__pyx_kp_u_dbr_mask_notify_milliseconds; static PyObject *__pyx_n_s_decode; static PyObject *__pyx_kp_u_decode_utf_16_error; static PyObject *__pyx_n_s_deepcopy; @@ -4716,6 +4682,7 @@ static PyObject *__pyx_kp_u_does_not_match_the_length_of_da_2; static PyObject *__pyx_n_s_double; static PyObject *__pyx_n_u_double; static PyObject *__pyx_n_s_dt; +static PyObject *__pyx_n_u_dtcheck; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_dtype_is_object; static PyObject *__pyx_n_s_empty; @@ -4901,8 +4868,7 @@ static PyObject *__pyx_n_s_keepGroupName; static PyObject *__pyx_n_s_keys; static PyObject *__pyx_n_s_kwargs; static PyObject *__pyx_kp_u_latin_1; -static PyObject *__pyx_n_u_len1; -static PyObject *__pyx_n_u_len2; +static PyObject *__pyx_kp_u_length_of_ui8val; static PyObject *__pyx_n_s_longlong; static PyObject *__pyx_kp_u_lowerAlarmLimit_f; static PyObject *__pyx_kp_u_lowerControlLimit_f; @@ -4934,8 +4900,6 @@ static PyObject *__pyx_kp_u_monitorStart_handlePV_object_cb; static PyObject *__pyx_n_s_monitorStop; static PyObject *__pyx_kp_u_monitorStopAll; static PyObject *__pyx_kp_u_monitorStop_handlePV_mpid_None; -static PyObject *__pyx_kp_u_monitor_id; -static PyObject *__pyx_n_u_monitorid; static PyObject *__pyx_n_s_monitorpolicy; static PyObject *__pyx_n_s_mpid; static PyObject *__pyx_n_u_mv; @@ -5048,6 +5012,7 @@ static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_kp_u_reports_the_following_error; +static PyObject *__pyx_n_u_request; static PyObject *__pyx_kp_u_s; static PyObject *__pyx_n_s_scalarOnly; static PyObject *__pyx_n_s_self; @@ -5151,12 +5116,12 @@ static PyObject *__pyx_kp_u_upperWarningLimit_f; static PyObject *__pyx_kp_u_userArgs; static PyObject *__pyx_n_s_ushort; static PyObject *__pyx_n_u_ushort; -static PyObject *__pyx_n_u_utf_16; -static PyObject *__pyx_kp_u_utf_16_2; +static PyObject *__pyx_kp_u_utf_16; +static PyObject *__pyx_n_u_utf_16_2; static PyObject *__pyx_n_u_utf_32; static PyObject *__pyx_kp_u_utf_32_2; -static PyObject *__pyx_n_u_utf_8; -static PyObject *__pyx_kp_u_utf_8_2; +static PyObject *__pyx_kp_u_utf_8; +static PyObject *__pyx_n_u_utf_8_2; static PyObject *__pyx_kp_u_utf_none; static PyObject *__pyx_n_s_valAction; static PyObject *__pyx_n_s_valList; @@ -5838,12 +5803,12 @@ static DBR_TYPE __pyx_k__91; static unsigned int __pyx_k__92; static DBR_TYPE __pyx_k__93; static unsigned int __pyx_k__94; -static DBR_TYPE __pyx_k__99; -static unsigned int __pyx_k__100; -static DBR_TYPE __pyx_k__115; -static unsigned int __pyx_k__116; -static DBR_TYPE __pyx_k__117; -static unsigned int __pyx_k__118; +static DBR_TYPE __pyx_k__97; +static unsigned int __pyx_k__98; +static DBR_TYPE __pyx_k__110; +static unsigned int __pyx_k__111; +static DBR_TYPE __pyx_k__112; +static unsigned int __pyx_k__113; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__6; @@ -5920,18 +5885,19 @@ static PyObject *__pyx_tuple__89; static PyObject *__pyx_tuple__90; static PyObject *__pyx_tuple__95; static PyObject *__pyx_tuple__96; -static PyObject *__pyx_tuple__97; -static PyObject *__pyx_tuple__98; -static PyObject *__pyx_slice__164; -static PyObject *__pyx_tuple__101; +static PyObject *__pyx_tuple__99; +static PyObject *__pyx_slice__159; +static PyObject *__pyx_tuple__100; static PyObject *__pyx_tuple__102; +static PyObject *__pyx_tuple__103; static PyObject *__pyx_tuple__104; -static PyObject *__pyx_tuple__105; +static PyObject *__pyx_tuple__106; static PyObject *__pyx_tuple__107; -static PyObject *__pyx_tuple__108; -static PyObject *__pyx_tuple__109; -static PyObject *__pyx_tuple__111; -static PyObject *__pyx_tuple__112; +static PyObject *__pyx_tuple__114; +static PyObject *__pyx_tuple__115; +static PyObject *__pyx_tuple__116; +static PyObject *__pyx_tuple__117; +static PyObject *__pyx_tuple__118; static PyObject *__pyx_tuple__119; static PyObject *__pyx_tuple__120; static PyObject *__pyx_tuple__121; @@ -5943,11 +5909,11 @@ static PyObject *__pyx_tuple__126; static PyObject *__pyx_tuple__127; static PyObject *__pyx_tuple__128; static PyObject *__pyx_tuple__129; -static PyObject *__pyx_tuple__130; static PyObject *__pyx_tuple__131; static PyObject *__pyx_tuple__132; static PyObject *__pyx_tuple__133; static PyObject *__pyx_tuple__134; +static PyObject *__pyx_tuple__135; static PyObject *__pyx_tuple__136; static PyObject *__pyx_tuple__137; static PyObject *__pyx_tuple__138; @@ -5971,27 +5937,22 @@ static PyObject *__pyx_tuple__155; static PyObject *__pyx_tuple__156; static PyObject *__pyx_tuple__157; static PyObject *__pyx_tuple__158; -static PyObject *__pyx_tuple__159; static PyObject *__pyx_tuple__160; static PyObject *__pyx_tuple__161; static PyObject *__pyx_tuple__162; -static PyObject *__pyx_tuple__163; +static PyObject *__pyx_tuple__164; static PyObject *__pyx_tuple__165; -static PyObject *__pyx_tuple__166; static PyObject *__pyx_tuple__167; static PyObject *__pyx_tuple__169; static PyObject *__pyx_tuple__170; +static PyObject *__pyx_tuple__171; static PyObject *__pyx_tuple__172; +static PyObject *__pyx_tuple__173; static PyObject *__pyx_tuple__174; -static PyObject *__pyx_tuple__175; -static PyObject *__pyx_tuple__176; -static PyObject *__pyx_tuple__177; -static PyObject *__pyx_tuple__178; -static PyObject *__pyx_tuple__179; static PyObject *__pyx_codeobj__33; -static PyObject *__pyx_codeobj__171; -static PyObject *__pyx_codeobj__173; -static PyObject *__pyx_codeobj__180; +static PyObject *__pyx_codeobj__166; +static PyObject *__pyx_codeobj__168; +static PyObject *__pyx_codeobj__175; /* Late includes */ /* "PyCafeDefs_pub.pxi":11 @@ -30679,7 +30640,486 @@ static PyObject *__pyx_pf_6PyCafe_7pvgroup_10__setstate_cython__(CYTHON_UNUSED s return __pyx_r; } -/* "PyCafeDefs.pxi":1120 +/* "PyCafeDefs.pxi":1118 + * ################################################################################## + * + * cdef encodeString(bytes_input): # <<<<<<<<<<<<<< + * bytesVal = bytes_input + * encoding = False + */ + +static PyObject *__pyx_f_6PyCafe_encodeString(PyObject *__pyx_v_bytes_input) { + PyObject *__pyx_v_bytesVal = NULL; + int __pyx_v_encoding; + PyObject *__pyx_v_strVal = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + __Pyx_RefNannySetupContext("encodeString", 0); + + /* "PyCafeDefs.pxi":1119 + * + * cdef encodeString(bytes_input): + * bytesVal = bytes_input # <<<<<<<<<<<<<< + * encoding = False + * if not encoding: + */ + __Pyx_INCREF(__pyx_v_bytes_input); + __pyx_v_bytesVal = __pyx_v_bytes_input; + + /* "PyCafeDefs.pxi":1120 + * cdef encodeString(bytes_input): + * bytesVal = bytes_input + * encoding = False # <<<<<<<<<<<<<< + * if not encoding: + * try: + */ + __pyx_v_encoding = 0; + + /* "PyCafeDefs.pxi":1121 + * bytesVal = bytes_input + * encoding = False + * if not encoding: # <<<<<<<<<<<<<< + * try: + * strVal = (bytesVal).decode('utf-8') + */ + __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); + if (__pyx_t_1) { + + /* "PyCafeDefs.pxi":1122 + * encoding = False + * if not encoding: + * try: # <<<<<<<<<<<<<< + * strVal = (bytesVal).decode('utf-8') + * encoding = True + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "PyCafeDefs.pxi":1123 + * if not encoding: + * try: + * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< + * encoding = True + * #print('utf-8 for umlauts CONFIRMED!') + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1123, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_kp_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_utf_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1123, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_strVal = __pyx_t_5; + __pyx_t_5 = 0; + + /* "PyCafeDefs.pxi":1124 + * try: + * strVal = (bytesVal).decode('utf-8') + * encoding = True # <<<<<<<<<<<<<< + * #print('utf-8 for umlauts CONFIRMED!') + * except UnicodeDecodeError: + */ + __pyx_v_encoding = 1; + + /* "PyCafeDefs.pxi":1122 + * encoding = False + * if not encoding: + * try: # <<<<<<<<<<<<<< + * strVal = (bytesVal).decode('utf-8') + * encoding = True + */ + } + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L9_try_end; + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "PyCafeDefs.pxi":1126 + * encoding = True + * #print('utf-8 for umlauts CONFIRMED!') + * except UnicodeDecodeError: # <<<<<<<<<<<<<< + * pass + * if not encoding: + */ + __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeDecodeError); + if (__pyx_t_8) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L5_exception_handled; + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "PyCafeDefs.pxi":1122 + * encoding = False + * if not encoding: + * try: # <<<<<<<<<<<<<< + * strVal = (bytesVal).decode('utf-8') + * encoding = True + */ + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L5_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + __pyx_L9_try_end:; + } + + /* "PyCafeDefs.pxi":1121 + * bytesVal = bytes_input + * encoding = False + * if not encoding: # <<<<<<<<<<<<<< + * try: + * strVal = (bytesVal).decode('utf-8') + */ + } + + /* "PyCafeDefs.pxi":1128 + * except UnicodeDecodeError: + * pass + * if not encoding: # <<<<<<<<<<<<<< + * try: + * strVal = (bytesVal).decode('utf-16') + */ + __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); + if (__pyx_t_1) { + + /* "PyCafeDefs.pxi":1129 + * pass + * if not encoding: + * try: # <<<<<<<<<<<<<< + * strVal = (bytesVal).decode('utf-16') + * encoding = True + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + /*try:*/ { + + /* "PyCafeDefs.pxi":1130 + * if not encoding: + * try: + * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< + * encoding = True + * #print('utf-16 for umlauts') + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1130, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_kp_u_utf_16) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_utf_16); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1130, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); + __pyx_t_5 = 0; + + /* "PyCafeDefs.pxi":1131 + * try: + * strVal = (bytesVal).decode('utf-16') + * encoding = True # <<<<<<<<<<<<<< + * #print('utf-16 for umlauts') + * except UnicodeDecodeError: + */ + __pyx_v_encoding = 1; + + /* "PyCafeDefs.pxi":1129 + * pass + * if not encoding: + * try: # <<<<<<<<<<<<<< + * strVal = (bytesVal).decode('utf-16') + * encoding = True + */ + } + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L16_try_end; + __pyx_L11_error:; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "PyCafeDefs.pxi":1133 + * encoding = True + * #print('utf-16 for umlauts') + * except UnicodeDecodeError: # <<<<<<<<<<<<<< + * pass + * if not encoding: + */ + __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeDecodeError); + if (__pyx_t_8) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L12_exception_handled; + } + goto __pyx_L13_except_error; + __pyx_L13_except_error:; + + /* "PyCafeDefs.pxi":1129 + * pass + * if not encoding: + * try: # <<<<<<<<<<<<<< + * strVal = (bytesVal).decode('utf-16') + * encoding = True + */ + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_3, __pyx_t_2); + goto __pyx_L1_error; + __pyx_L12_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_3, __pyx_t_2); + __pyx_L16_try_end:; + } + + /* "PyCafeDefs.pxi":1128 + * except UnicodeDecodeError: + * pass + * if not encoding: # <<<<<<<<<<<<<< + * try: + * strVal = (bytesVal).decode('utf-16') + */ + } + + /* "PyCafeDefs.pxi":1135 + * except UnicodeDecodeError: + * pass + * if not encoding: # <<<<<<<<<<<<<< + * try: + * strVal= (bytesVal).decode('latin-1') + */ + __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); + if (__pyx_t_1) { + + /* "PyCafeDefs.pxi":1136 + * pass + * if not encoding: + * try: # <<<<<<<<<<<<<< + * strVal= (bytesVal).decode('latin-1') + * encoding = True + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "PyCafeDefs.pxi":1137 + * if not encoding: + * try: + * strVal= (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< + * encoding = True + * #print('latin1 for umlauts') + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1137, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_kp_u_latin_1) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_latin_1); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1137, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); + __pyx_t_5 = 0; + + /* "PyCafeDefs.pxi":1138 + * try: + * strVal= (bytesVal).decode('latin-1') + * encoding = True # <<<<<<<<<<<<<< + * #print('latin1 for umlauts') + * except UnicodeDecodeError: + */ + __pyx_v_encoding = 1; + + /* "PyCafeDefs.pxi":1136 + * pass + * if not encoding: + * try: # <<<<<<<<<<<<<< + * strVal= (bytesVal).decode('latin-1') + * encoding = True + */ + } + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L23_try_end; + __pyx_L18_error:; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "PyCafeDefs.pxi":1140 + * encoding = True + * #print('latin1 for umlauts') + * except UnicodeDecodeError: # <<<<<<<<<<<<<< + * pass + * if not encoding: + */ + __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeDecodeError); + if (__pyx_t_8) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L19_exception_handled; + } + goto __pyx_L20_except_error; + __pyx_L20_except_error:; + + /* "PyCafeDefs.pxi":1136 + * pass + * if not encoding: + * try: # <<<<<<<<<<<<<< + * strVal= (bytesVal).decode('latin-1') + * encoding = True + */ + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L19_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + __pyx_L23_try_end:; + } + + /* "PyCafeDefs.pxi":1135 + * except UnicodeDecodeError: + * pass + * if not encoding: # <<<<<<<<<<<<<< + * try: + * strVal= (bytesVal).decode('latin-1') + */ + } + + /* "PyCafeDefs.pxi":1142 + * except UnicodeDecodeError: + * pass + * if not encoding: # <<<<<<<<<<<<<< + * strVal = bytes_input + * + */ + __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); + if (__pyx_t_1) { + + /* "PyCafeDefs.pxi":1143 + * pass + * if not encoding: + * strVal = bytes_input # <<<<<<<<<<<<<< + * + * return strVal + */ + __Pyx_INCREF(__pyx_v_bytes_input); + __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_v_bytes_input); + + /* "PyCafeDefs.pxi":1142 + * except UnicodeDecodeError: + * pass + * if not encoding: # <<<<<<<<<<<<<< + * strVal = bytes_input + * + */ + } + + /* "PyCafeDefs.pxi":1145 + * strVal = bytes_input + * + * return strVal # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(2, 1145, __pyx_L1_error) } + __Pyx_INCREF(__pyx_v_strVal); + __pyx_r = __pyx_v_strVal; + goto __pyx_L0; + + /* "PyCafeDefs.pxi":1118 + * ################################################################################## + * + * cdef encodeString(bytes_input): # <<<<<<<<<<<<<< + * bytesVal = bytes_input + * encoding = False + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("PyCafe.encodeString", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_bytesVal); + __Pyx_XDECREF(__pyx_v_strVal); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "PyCafeDefs.pxi":1149 * * ################################################################################## * cdef getMatchedDataType(dt, dtn): # <<<<<<<<<<<<<< @@ -30697,17 +31137,17 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje int __pyx_t_4; __Pyx_RefNannySetupContext("getMatchedDataType", 0); - /* "PyCafeDefs.pxi":1125 + /* "PyCafeDefs.pxi":1154 * # dtcheck: matching data type for pvd convert method * * cdef unsigned int dtcheck = dtn # <<<<<<<<<<<<<< * * if dt in ['uchar', 'uint8']: */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_dtn); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1125, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_dtn); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1154, __pyx_L1_error) __pyx_v_dtcheck = __pyx_t_1; - /* "PyCafeDefs.pxi":1127 + /* "PyCafeDefs.pxi":1156 * cdef unsigned int dtcheck = dtn * * if dt in ['uchar', 'uint8']: # <<<<<<<<<<<<<< @@ -30716,20 +31156,20 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uchar, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1127, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uchar, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1156, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint8, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1127, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint8, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1156, __pyx_L1_error) __pyx_t_3 = __pyx_t_4; __pyx_L4_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafeDefs.pxi":1128 + /* "PyCafeDefs.pxi":1157 * * if dt in ['uchar', 'uint8']: * dtcheck = CAFE_CHAR # <<<<<<<<<<<<<< @@ -30738,7 +31178,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_CHAR; - /* "PyCafeDefs.pxi":1127 + /* "PyCafeDefs.pxi":1156 * cdef unsigned int dtcheck = dtn * * if dt in ['uchar', 'uint8']: # <<<<<<<<<<<<<< @@ -30748,7 +31188,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1129 + /* "PyCafeDefs.pxi":1158 * if dt in ['uchar', 'uint8']: * dtcheck = CAFE_CHAR * elif dt in ['np.uint8']: # <<<<<<<<<<<<<< @@ -30757,12 +31197,12 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_uint8, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1129, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_uint8, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1158, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { - /* "PyCafeDefs.pxi":1130 + /* "PyCafeDefs.pxi":1159 * dtcheck = CAFE_CHAR * elif dt in ['np.uint8']: * dtcheck = CAFE_CHAR # <<<<<<<<<<<<<< @@ -30771,7 +31211,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_CHAR; - /* "PyCafeDefs.pxi":1129 + /* "PyCafeDefs.pxi":1158 * if dt in ['uchar', 'uint8']: * dtcheck = CAFE_CHAR * elif dt in ['np.uint8']: # <<<<<<<<<<<<<< @@ -30781,7 +31221,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1131 + /* "PyCafeDefs.pxi":1160 * elif dt in ['np.uint8']: * dtcheck = CAFE_CHAR * elif dt in ['ushort', 'uint16']: # <<<<<<<<<<<<<< @@ -30790,20 +31230,20 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_ushort, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1131, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_ushort, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1160, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L6_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint16, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1131, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint16, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1160, __pyx_L1_error) __pyx_t_3 = __pyx_t_4; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafeDefs.pxi":1132 + /* "PyCafeDefs.pxi":1161 * dtcheck = CAFE_CHAR * elif dt in ['ushort', 'uint16']: * dtcheck = CAFE_USHORT # <<<<<<<<<<<<<< @@ -30812,7 +31252,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_USHORT; - /* "PyCafeDefs.pxi":1131 + /* "PyCafeDefs.pxi":1160 * elif dt in ['np.uint8']: * dtcheck = CAFE_CHAR * elif dt in ['ushort', 'uint16']: # <<<<<<<<<<<<<< @@ -30822,7 +31262,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1133 + /* "PyCafeDefs.pxi":1162 * elif dt in ['ushort', 'uint16']: * dtcheck = CAFE_USHORT * elif dt in ['np.ushort', 'np.uint16']: # <<<<<<<<<<<<<< @@ -30831,20 +31271,20 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_ushort, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1133, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_ushort, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1162, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L8_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_uint16, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1133, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_uint16, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1162, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; __pyx_L8_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { - /* "PyCafeDefs.pxi":1134 + /* "PyCafeDefs.pxi":1163 * dtcheck = CAFE_USHORT * elif dt in ['np.ushort', 'np.uint16']: * dtcheck = CAFE_USHORT # <<<<<<<<<<<<<< @@ -30853,7 +31293,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_USHORT; - /* "PyCafeDefs.pxi":1133 + /* "PyCafeDefs.pxi":1162 * elif dt in ['ushort', 'uint16']: * dtcheck = CAFE_USHORT * elif dt in ['np.ushort', 'np.uint16']: # <<<<<<<<<<<<<< @@ -30863,7 +31303,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1135 + /* "PyCafeDefs.pxi":1164 * elif dt in ['np.ushort', 'np.uint16']: * dtcheck = CAFE_USHORT * elif dt in ['short', 'int16', 'int8', 'bool', 'byte']: # <<<<<<<<<<<<<< @@ -30872,38 +31312,38 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_short, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1135, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_short, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1164, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L10_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int16, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1135, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int16, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1164, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L10_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int8, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1135, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int8, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1164, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L10_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_bool, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1135, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_bool, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1164, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L10_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_byte, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1135, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_byte, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1164, __pyx_L1_error) __pyx_t_3 = __pyx_t_4; __pyx_L10_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafeDefs.pxi":1136 + /* "PyCafeDefs.pxi":1165 * dtcheck = CAFE_USHORT * elif dt in ['short', 'int16', 'int8', 'bool', 'byte']: * dtcheck = CAFE_SHORT # <<<<<<<<<<<<<< @@ -30912,7 +31352,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_SHORT; - /* "PyCafeDefs.pxi":1135 + /* "PyCafeDefs.pxi":1164 * elif dt in ['np.ushort', 'np.uint16']: * dtcheck = CAFE_USHORT * elif dt in ['short', 'int16', 'int8', 'bool', 'byte']: # <<<<<<<<<<<<<< @@ -30922,7 +31362,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1137 + /* "PyCafeDefs.pxi":1166 * elif dt in ['short', 'int16', 'int8', 'bool', 'byte']: * dtcheck = CAFE_SHORT * elif dt in ['np.short', 'np.int16', 'np.int8', 'np.bool_', 'np.byte']: # <<<<<<<<<<<<<< @@ -30931,38 +31371,38 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_short, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1137, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_short, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1166, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L15_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int16, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1137, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int16, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1166, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L15_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1137, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1166, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L15_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_bool, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1137, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_bool, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1166, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L15_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_byte, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1137, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_byte, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1166, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; __pyx_L15_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { - /* "PyCafeDefs.pxi":1138 + /* "PyCafeDefs.pxi":1167 * dtcheck = CAFE_SHORT * elif dt in ['np.short', 'np.int16', 'np.int8', 'np.bool_', 'np.byte']: * dtcheck = CAFE_SHORT # <<<<<<<<<<<<<< @@ -30971,7 +31411,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_SHORT; - /* "PyCafeDefs.pxi":1137 + /* "PyCafeDefs.pxi":1166 * elif dt in ['short', 'int16', 'int8', 'bool', 'byte']: * dtcheck = CAFE_SHORT * elif dt in ['np.short', 'np.int16', 'np.int8', 'np.bool_', 'np.byte']: # <<<<<<<<<<<<<< @@ -30981,7 +31421,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1139 + /* "PyCafeDefs.pxi":1168 * elif dt in ['np.short', 'np.int16', 'np.int8', 'np.bool_', 'np.byte']: * dtcheck = CAFE_SHORT * elif dt in ['int', 'int_', 'uint', 'ushort', 'int32', 'uint32']: # <<<<<<<<<<<<<< @@ -30990,44 +31430,44 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1139, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1168, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L20_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1139, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1168, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L20_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1139, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1168, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L20_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_ushort, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1139, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_ushort, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1168, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L20_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int32, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1139, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int32, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1168, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L20_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint32, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1139, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint32, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1168, __pyx_L1_error) __pyx_t_3 = __pyx_t_4; __pyx_L20_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafeDefs.pxi":1140 + /* "PyCafeDefs.pxi":1169 * dtcheck = CAFE_SHORT * elif dt in ['int', 'int_', 'uint', 'ushort', 'int32', 'uint32']: * dtcheck = CAFE_LONG # <<<<<<<<<<<<<< @@ -31036,7 +31476,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_LONG; - /* "PyCafeDefs.pxi":1139 + /* "PyCafeDefs.pxi":1168 * elif dt in ['np.short', 'np.int16', 'np.int8', 'np.bool_', 'np.byte']: * dtcheck = CAFE_SHORT * elif dt in ['int', 'int_', 'uint', 'ushort', 'int32', 'uint32']: # <<<<<<<<<<<<<< @@ -31046,7 +31486,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1141 + /* "PyCafeDefs.pxi":1170 * elif dt in ['int', 'int_', 'uint', 'ushort', 'int32', 'uint32']: * dtcheck = CAFE_LONG * elif dt in ['np.intc', 'np.int_', 'np.long', 'np.ushort', 'np.int32', 'np.uint32']: # <<<<<<<<<<<<<< @@ -31055,44 +31495,44 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_intc, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1141, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_intc, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1170, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L26_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1141, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1170, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L26_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_long, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1141, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_long, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1170, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L26_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_ushort, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1141, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_ushort, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1170, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L26_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int32, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1141, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int32, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1170, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L26_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_uint32, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1141, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_uint32, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1170, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; __pyx_L26_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { - /* "PyCafeDefs.pxi":1142 + /* "PyCafeDefs.pxi":1171 * dtcheck = CAFE_LONG * elif dt in ['np.intc', 'np.int_', 'np.long', 'np.ushort', 'np.int32', 'np.uint32']: * dtcheck = CAFE_LONG # <<<<<<<<<<<<<< @@ -31101,7 +31541,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_LONG; - /* "PyCafeDefs.pxi":1141 + /* "PyCafeDefs.pxi":1170 * elif dt in ['int', 'int_', 'uint', 'ushort', 'int32', 'uint32']: * dtcheck = CAFE_LONG * elif dt in ['np.intc', 'np.int_', 'np.long', 'np.ushort', 'np.int32', 'np.uint32']: # <<<<<<<<<<<<<< @@ -31111,7 +31551,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1143 + /* "PyCafeDefs.pxi":1172 * elif dt in ['np.intc', 'np.int_', 'np.long', 'np.ushort', 'np.int32', 'np.uint32']: * dtcheck = CAFE_LONG * elif dt in ['double', 'float', 'float_', 'float64', 'int64', 'uint64']: # <<<<<<<<<<<<<< @@ -31120,44 +31560,44 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_double, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1143, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_double, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1172, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L32_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1143, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1172, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L32_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1143, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1172, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L32_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float64, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1143, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float64, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1172, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L32_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int64, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1143, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_int64, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1172, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L32_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint64, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1143, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_uint64, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1172, __pyx_L1_error) __pyx_t_3 = __pyx_t_4; __pyx_L32_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafeDefs.pxi":1144 + /* "PyCafeDefs.pxi":1173 * dtcheck = CAFE_LONG * elif dt in ['double', 'float', 'float_', 'float64', 'int64', 'uint64']: * dtcheck = CAFE_DOUBLE # <<<<<<<<<<<<<< @@ -31166,7 +31606,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_DOUBLE; - /* "PyCafeDefs.pxi":1143 + /* "PyCafeDefs.pxi":1172 * elif dt in ['np.intc', 'np.int_', 'np.long', 'np.ushort', 'np.int32', 'np.uint32']: * dtcheck = CAFE_LONG * elif dt in ['double', 'float', 'float_', 'float64', 'int64', 'uint64']: # <<<<<<<<<<<<<< @@ -31176,7 +31616,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1145 + /* "PyCafeDefs.pxi":1174 * elif dt in ['double', 'float', 'float_', 'float64', 'int64', 'uint64']: * dtcheck = CAFE_DOUBLE * elif dt in ['np.float_', 'np.float64', 'np.long', 'np.ulong', 'np.int64', 'np.uint64']: # <<<<<<<<<<<<<< @@ -31185,44 +31625,44 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_float, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1145, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_float, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1174, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L38_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_float64, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1145, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_float64, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1174, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L38_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_long, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1145, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_long, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1174, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L38_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_ulong, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1145, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_ulong, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1174, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L38_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int64, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1145, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_int64, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1174, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L38_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_uint64, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1145, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_uint64, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1174, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; __pyx_L38_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { - /* "PyCafeDefs.pxi":1146 + /* "PyCafeDefs.pxi":1175 * dtcheck = CAFE_DOUBLE * elif dt in ['np.float_', 'np.float64', 'np.long', 'np.ulong', 'np.int64', 'np.uint64']: * dtcheck = CAFE_DOUBLE # <<<<<<<<<<<<<< @@ -31231,7 +31671,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_DOUBLE; - /* "PyCafeDefs.pxi":1145 + /* "PyCafeDefs.pxi":1174 * elif dt in ['double', 'float', 'float_', 'float64', 'int64', 'uint64']: * dtcheck = CAFE_DOUBLE * elif dt in ['np.float_', 'np.float64', 'np.long', 'np.ulong', 'np.int64', 'np.uint64']: # <<<<<<<<<<<<<< @@ -31241,7 +31681,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1147 + /* "PyCafeDefs.pxi":1176 * elif dt in ['np.float_', 'np.float64', 'np.long', 'np.ulong', 'np.int64', 'np.uint64']: * dtcheck = CAFE_DOUBLE * elif dt in ['float16', 'float32']: # <<<<<<<<<<<<<< @@ -31250,20 +31690,20 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float16, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1147, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float16, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1176, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L44_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float32, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1147, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_float32, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1176, __pyx_L1_error) __pyx_t_3 = __pyx_t_4; __pyx_L44_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafeDefs.pxi":1148 + /* "PyCafeDefs.pxi":1177 * dtcheck = CAFE_DOUBLE * elif dt in ['float16', 'float32']: * dtcheck = CAFE_FLOAT # <<<<<<<<<<<<<< @@ -31272,7 +31712,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_FLOAT; - /* "PyCafeDefs.pxi":1147 + /* "PyCafeDefs.pxi":1176 * elif dt in ['np.float_', 'np.float64', 'np.long', 'np.ulong', 'np.int64', 'np.uint64']: * dtcheck = CAFE_DOUBLE * elif dt in ['float16', 'float32']: # <<<<<<<<<<<<<< @@ -31282,7 +31722,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1149 + /* "PyCafeDefs.pxi":1178 * elif dt in ['float16', 'float32']: * dtcheck = CAFE_FLOAT * elif dt in ['np.float16', 'np.float32']: # <<<<<<<<<<<<<< @@ -31291,20 +31731,20 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_float16, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1149, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_float16, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1178, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L46_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_float32, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1149, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_float32, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1178, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; __pyx_L46_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { - /* "PyCafeDefs.pxi":1150 + /* "PyCafeDefs.pxi":1179 * dtcheck = CAFE_FLOAT * elif dt in ['np.float16', 'np.float32']: * dtcheck = CAFE_FLOAT # <<<<<<<<<<<<<< @@ -31313,7 +31753,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_FLOAT; - /* "PyCafeDefs.pxi":1149 + /* "PyCafeDefs.pxi":1178 * elif dt in ['float16', 'float32']: * dtcheck = CAFE_FLOAT * elif dt in ['np.float16', 'np.float32']: # <<<<<<<<<<<<<< @@ -31323,7 +31763,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1151 + /* "PyCafeDefs.pxi":1180 * elif dt in ['np.float16', 'np.float32']: * dtcheck = CAFE_FLOAT * elif dt in ['string', 'str', 'unicode', 'string_', 'str_', 'unicode_']: # <<<<<<<<<<<<<< @@ -31332,44 +31772,44 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_string, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1151, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_string, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1180, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L48_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_str, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1151, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_str, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1180, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L48_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_unicode, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1151, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_unicode, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1180, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L48_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_string_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1151, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_string_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1180, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L48_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_str_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1151, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_str_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1180, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L48_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_unicode_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1151, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_unicode_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1180, __pyx_L1_error) __pyx_t_3 = __pyx_t_4; __pyx_L48_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafeDefs.pxi":1152 + /* "PyCafeDefs.pxi":1181 * dtcheck = CAFE_FLOAT * elif dt in ['string', 'str', 'unicode', 'string_', 'str_', 'unicode_']: * dtcheck = CAFE_STRING # <<<<<<<<<<<<<< @@ -31378,7 +31818,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_STRING; - /* "PyCafeDefs.pxi":1151 + /* "PyCafeDefs.pxi":1180 * elif dt in ['np.float16', 'np.float32']: * dtcheck = CAFE_FLOAT * elif dt in ['string', 'str', 'unicode', 'string_', 'str_', 'unicode_']: # <<<<<<<<<<<<<< @@ -31388,7 +31828,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1153 + /* "PyCafeDefs.pxi":1182 * elif dt in ['string', 'str', 'unicode', 'string_', 'str_', 'unicode_']: * dtcheck = CAFE_STRING * elif dt in ['np.string', 'np.str', 'np.unicode', 'np.string_', 'np.str_', 'np.unicode_']: # <<<<<<<<<<<<<< @@ -31397,44 +31837,44 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_string, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1153, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_string, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1182, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L54_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_str, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1153, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_str, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1182, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L54_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_unicode, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1153, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_unicode, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1182, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L54_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_string_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1153, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_string_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1182, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L54_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_str_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1153, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_str_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1182, __pyx_L1_error) if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L54_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_unicode_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1153, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u_np_unicode_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(2, 1182, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; __pyx_L54_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { - /* "PyCafeDefs.pxi":1154 + /* "PyCafeDefs.pxi":1183 * dtcheck = CAFE_STRING * elif dt in ['np.string', 'np.str', 'np.unicode', 'np.string_', 'np.str_', 'np.unicode_']: * dtcheck = CAFE_STRING # <<<<<<<<<<<<<< @@ -31443,7 +31883,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __pyx_v_dtcheck = CAFE_STRING; - /* "PyCafeDefs.pxi":1153 + /* "PyCafeDefs.pxi":1182 * elif dt in ['string', 'str', 'unicode', 'string_', 'str_', 'unicode_']: * dtcheck = CAFE_STRING * elif dt in ['np.string', 'np.str', 'np.unicode', 'np.string_', 'np.str_', 'np.unicode_']: # <<<<<<<<<<<<<< @@ -31453,7 +31893,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1155 + /* "PyCafeDefs.pxi":1184 * elif dt in ['np.string', 'np.str', 'np.unicode', 'np.string_', 'np.str_', 'np.unicode_']: * dtcheck = CAFE_STRING * elif dt in ['native', '']: # <<<<<<<<<<<<<< @@ -31462,30 +31902,30 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_2 = __pyx_v_dt; - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_native, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1155, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_native, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1184, __pyx_L1_error) if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L60_bool_binop_done; } - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u__3, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1155, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_kp_u__3, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 1184, __pyx_L1_error) __pyx_t_3 = __pyx_t_4; __pyx_L60_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafeDefs.pxi":1156 + /* "PyCafeDefs.pxi":1185 * dtcheck = CAFE_STRING * elif dt in ['native', '']: * dtcheck = dtn # need a line here # <<<<<<<<<<<<<< * else: * print("Valid input parameters for data type are variations of: 'int', 'float', 'str', or 'native'") */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_dtn); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1156, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_dtn); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1185, __pyx_L1_error) __pyx_v_dtcheck = __pyx_t_1; - /* "PyCafeDefs.pxi":1155 + /* "PyCafeDefs.pxi":1184 * elif dt in ['np.string', 'np.str', 'np.unicode', 'np.string_', 'np.str_', 'np.unicode_']: * dtcheck = CAFE_STRING * elif dt in ['native', '']: # <<<<<<<<<<<<<< @@ -31495,7 +31935,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje goto __pyx_L3; } - /* "PyCafeDefs.pxi":1158 + /* "PyCafeDefs.pxi":1187 * dtcheck = dtn # need a line here * else: * print("Valid input parameters for data type are variations of: 'int', 'float', 'str', or 'native'") # <<<<<<<<<<<<<< @@ -31503,24 +31943,24 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje * */ /*else*/ { - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1158, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1187, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafeDefs.pxi":1159 + /* "PyCafeDefs.pxi":1188 * else: * print("Valid input parameters for data type are variations of: 'int', 'float', 'str', or 'native'") * print("Data to be presented in native data type") # <<<<<<<<<<<<<< * * return dtcheck */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1159, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L3:; - /* "PyCafeDefs.pxi":1161 + /* "PyCafeDefs.pxi":1190 * print("Data to be presented in native data type") * * return dtcheck # <<<<<<<<<<<<<< @@ -31528,13 +31968,13 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtcheck); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1161, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtcheck); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafeDefs.pxi":1120 + /* "PyCafeDefs.pxi":1149 * * ################################################################################## * cdef getMatchedDataType(dt, dtn): # <<<<<<<<<<<<<< @@ -31555,7 +31995,7 @@ static PyObject *__pyx_f_6PyCafe_getMatchedDataType(PyObject *__pyx_v_dt, PyObje return __pyx_r; } -/* "PyCafeDefs.pxi":1173 +/* "PyCafeDefs.pxi":1202 * ################################################################################# * * cdef pvdata PVDataHolderToStruct(PVDataHolder pvd, dt=None): # <<<<<<<<<<<<<< @@ -31596,19 +32036,19 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD } } - /* "PyCafeDefs.pxi":1177 + /* "PyCafeDefs.pxi":1206 * cdef CAFEDataTypeCode cdt * #global p1 * cdef pvdata p1 = pvdata() # <<<<<<<<<<<<<< * * cdef unsigned int dtn = pvd.getDataType() */ - __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvdata)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1177, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvdata)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_p1 = ((struct __pyx_obj_6PyCafe_pvdata *)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1179 + /* "PyCafeDefs.pxi":1208 * cdef pvdata p1 = pvdata() * * cdef unsigned int dtn = pvd.getDataType() # <<<<<<<<<<<<<< @@ -31617,7 +32057,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_dtn = __pyx_v_pvd.getDataType(); - /* "PyCafeDefs.pxi":1180 + /* "PyCafeDefs.pxi":1209 * * cdef unsigned int dtn = pvd.getDataType() * cdef unsigned int dtcheck = dtn # <<<<<<<<<<<<<< @@ -31626,45 +32066,45 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_dtcheck = __pyx_v_dtn; - /* "PyCafeDefs.pxi":1181 + /* "PyCafeDefs.pxi":1210 * cdef unsigned int dtn = pvd.getDataType() * cdef unsigned int dtcheck = dtn * cdef localList = [] # <<<<<<<<<<<<<< * * cdef bytes bytesVal */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1181, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_localList = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1185 + /* "PyCafeDefs.pxi":1214 * cdef bytes bytesVal * * if dt: # <<<<<<<<<<<<<< * dtcheck = getMatchedDataType(dt, dtn) * */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_dt); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 1185, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_dt); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 1214, __pyx_L1_error) if (__pyx_t_2) { - /* "PyCafeDefs.pxi":1186 + /* "PyCafeDefs.pxi":1215 * * if dt: * dtcheck = getMatchedDataType(dt, dtn) # <<<<<<<<<<<<<< * * if dtcheck == CAFE_STRING: */ - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1186, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1186, __pyx_L1_error) + __pyx_t_3 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1186, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1215, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_dtcheck = __pyx_t_4; - /* "PyCafeDefs.pxi":1185 + /* "PyCafeDefs.pxi":1214 * cdef bytes bytesVal * * if dt: # <<<<<<<<<<<<<< @@ -31673,7 +32113,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ } - /* "PyCafeDefs.pxi":1188 + /* "PyCafeDefs.pxi":1217 * dtcheck = getMatchedDataType(dt, dtn) * * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -31683,7 +32123,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafeDefs.pxi":1189 + /* "PyCafeDefs.pxi":1218 * * if dtcheck == CAFE_STRING: * for i in range(0, pvd.getNelem()): # <<<<<<<<<<<<<< @@ -31695,14 +32135,14 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1190 + /* "PyCafeDefs.pxi":1219 * if dtcheck == CAFE_STRING: * for i in range(0, pvd.getNelem()): * bytesVal = pvd.getAsString(i) # <<<<<<<<<<<<<< * encoding = False * #if not encoding: */ - __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_pvd.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1190, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_pvd.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1219, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); @@ -31710,7 +32150,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_1)); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1191 + /* "PyCafeDefs.pxi":1220 * for i in range(0, pvd.getNelem()): * bytesVal = pvd.getAsString(i) * encoding = False # <<<<<<<<<<<<<< @@ -31719,7 +32159,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_encoding = 0; - /* "PyCafeDefs.pxi":1198 + /* "PyCafeDefs.pxi":1227 * # except UnicodeDecodeError: * # pass * if not encoding: # <<<<<<<<<<<<<< @@ -31729,7 +32169,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafeDefs.pxi":1199 + /* "PyCafeDefs.pxi":1228 * # pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -31745,7 +32185,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __Pyx_XGOTREF(__pyx_t_9); /*try:*/ { - /* "PyCafeDefs.pxi":1200 + /* "PyCafeDefs.pxi":1229 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -31754,14 +32194,14 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(2, 1200, __pyx_L7_error) + __PYX_ERR(2, 1229, __pyx_L7_error) } - __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1200, __pyx_L7_error) + __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1229, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1201 + /* "PyCafeDefs.pxi":1230 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -31770,7 +32210,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_encoding = 1; - /* "PyCafeDefs.pxi":1199 + /* "PyCafeDefs.pxi":1228 * # pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -31786,7 +32226,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1203 + /* "PyCafeDefs.pxi":1232 * encoding = True * #print('utf-8 for umlauts CONFIRMED!') * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -31801,7 +32241,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD goto __pyx_L9_except_error; __pyx_L9_except_error:; - /* "PyCafeDefs.pxi":1199 + /* "PyCafeDefs.pxi":1228 * # pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -31821,7 +32261,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_L14_try_end:; } - /* "PyCafeDefs.pxi":1198 + /* "PyCafeDefs.pxi":1227 * # except UnicodeDecodeError: * # pass * if not encoding: # <<<<<<<<<<<<<< @@ -31830,7 +32270,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ } - /* "PyCafeDefs.pxi":1205 + /* "PyCafeDefs.pxi":1234 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -31840,7 +32280,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafeDefs.pxi":1206 + /* "PyCafeDefs.pxi":1235 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -31856,7 +32296,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __Pyx_XGOTREF(__pyx_t_7); /*try:*/ { - /* "PyCafeDefs.pxi":1207 + /* "PyCafeDefs.pxi":1236 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -31865,14 +32305,14 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(2, 1207, __pyx_L16_error) + __PYX_ERR(2, 1236, __pyx_L16_error) } - __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1207, __pyx_L16_error) + __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1236, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1208 + /* "PyCafeDefs.pxi":1237 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -31881,7 +32321,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_encoding = 1; - /* "PyCafeDefs.pxi":1206 + /* "PyCafeDefs.pxi":1235 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -31897,7 +32337,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1210 + /* "PyCafeDefs.pxi":1239 * encoding = True * #print('utf-16 for umlauts') * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -31912,7 +32352,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD goto __pyx_L18_except_error; __pyx_L18_except_error:; - /* "PyCafeDefs.pxi":1206 + /* "PyCafeDefs.pxi":1235 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -31932,7 +32372,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_L23_try_end:; } - /* "PyCafeDefs.pxi":1205 + /* "PyCafeDefs.pxi":1234 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -31941,7 +32381,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ } - /* "PyCafeDefs.pxi":1212 + /* "PyCafeDefs.pxi":1241 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -31951,7 +32391,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafeDefs.pxi":1213 + /* "PyCafeDefs.pxi":1242 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -31967,7 +32407,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __Pyx_XGOTREF(__pyx_t_9); /*try:*/ { - /* "PyCafeDefs.pxi":1214 + /* "PyCafeDefs.pxi":1243 * if not encoding: * try: * strVal= (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -31976,14 +32416,14 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(2, 1214, __pyx_L25_error) + __PYX_ERR(2, 1243, __pyx_L25_error) } - __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1214, __pyx_L25_error) + __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1243, __pyx_L25_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1215 + /* "PyCafeDefs.pxi":1244 * try: * strVal= (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -31992,7 +32432,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_encoding = 1; - /* "PyCafeDefs.pxi":1213 + /* "PyCafeDefs.pxi":1242 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -32008,7 +32448,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1217 + /* "PyCafeDefs.pxi":1246 * encoding = True * #print('latin1 for umlauts') * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -32023,7 +32463,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD goto __pyx_L27_except_error; __pyx_L27_except_error:; - /* "PyCafeDefs.pxi":1213 + /* "PyCafeDefs.pxi":1242 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -32043,7 +32483,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_L32_try_end:; } - /* "PyCafeDefs.pxi":1212 + /* "PyCafeDefs.pxi":1241 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -32052,7 +32492,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ } - /* "PyCafeDefs.pxi":1219 + /* "PyCafeDefs.pxi":1248 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -32062,19 +32502,19 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafeDefs.pxi":1220 + /* "PyCafeDefs.pxi":1249 * pass * if not encoding: * strVal = pvd.getAsString(i) # <<<<<<<<<<<<<< * * localList.append(strVal) */ - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvd.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1220, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvd.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1219 + /* "PyCafeDefs.pxi":1248 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -32083,18 +32523,18 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ } - /* "PyCafeDefs.pxi":1222 + /* "PyCafeDefs.pxi":1251 * strVal = pvd.getAsString(i) * * localList.append(strVal) # <<<<<<<<<<<<<< * * elif dtcheck == CAFE_SHORT: */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(2, 1222, __pyx_L1_error) } - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1222, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(2, 1251, __pyx_L1_error) } + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1251, __pyx_L1_error) } - /* "PyCafeDefs.pxi":1188 + /* "PyCafeDefs.pxi":1217 * dtcheck = getMatchedDataType(dt, dtn) * * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -32104,7 +32544,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD break; case CAFE_SHORT: - /* "PyCafeDefs.pxi":1225 + /* "PyCafeDefs.pxi":1254 * * elif dtcheck == CAFE_SHORT: * for i in range(0, pvd.getNelem()): # <<<<<<<<<<<<<< @@ -32116,20 +32556,20 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1226 + /* "PyCafeDefs.pxi":1255 * elif dtcheck == CAFE_SHORT: * for i in range(0, pvd.getNelem()): * localList.append(pvd.getAsLong(i)) # getAsShort(i) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_FLOAT: * for i in range(0, pvd.getNelem()): */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1226, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1226, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1255, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "PyCafeDefs.pxi":1224 + /* "PyCafeDefs.pxi":1253 * localList.append(strVal) * * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -32139,7 +32579,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD break; case CAFE_FLOAT: - /* "PyCafeDefs.pxi":1228 + /* "PyCafeDefs.pxi":1257 * localList.append(pvd.getAsLong(i)) # getAsShort(i) * elif dtcheck == CAFE_FLOAT: * for i in range(0, pvd.getNelem()): # <<<<<<<<<<<<<< @@ -32151,20 +32591,20 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1229 + /* "PyCafeDefs.pxi":1258 * elif dtcheck == CAFE_FLOAT: * for i in range(0, pvd.getNelem()): * localList.append(pvd.getAsDouble(i)) # getAsFloat(i) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvd.getAsDouble(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1229, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvd.getAsDouble(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1229, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1258, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "PyCafeDefs.pxi":1227 + /* "PyCafeDefs.pxi":1256 * for i in range(0, pvd.getNelem()): * localList.append(pvd.getAsLong(i)) # getAsShort(i) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -32174,7 +32614,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD break; case CAFE_ENUM: - /* "PyCafeDefs.pxi":1233 + /* "PyCafeDefs.pxi":1262 * # if enum, string taken as native * # if self._c_cafe.isEnum(handle)==1: * for i in range(0, pvd.getNelem()): # <<<<<<<<<<<<<< @@ -32186,20 +32626,20 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1234 + /* "PyCafeDefs.pxi":1263 * # if self._c_cafe.isEnum(handle)==1: * for i in range(0, pvd.getNelem()): * localList.append(pvd.getAsString(i)) # <<<<<<<<<<<<<< * # else: * # for i in range(0, pvd.getNelem()): */ - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvd.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1234, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvd.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1234, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1263, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "PyCafeDefs.pxi":1230 + /* "PyCafeDefs.pxi":1259 * for i in range(0, pvd.getNelem()): * localList.append(pvd.getAsDouble(i)) # getAsFloat(i) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -32209,7 +32649,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD break; case CAFE_CHAR: - /* "PyCafeDefs.pxi":1239 + /* "PyCafeDefs.pxi":1268 * # localList.append(pvd.getAsLong(i)) #getAsUShort(i) * elif dtcheck == CAFE_CHAR: * for i in range(0, pvd.getNelem()): # <<<<<<<<<<<<<< @@ -32221,20 +32661,20 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1241 + /* "PyCafeDefs.pxi":1270 * for i in range(0, pvd.getNelem()): * # pvd.getAsChar(i) * localList.append(pvd.getAsLong(i)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * for i in range(0, pvd.getNelem()): */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1241, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1241, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1270, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "PyCafeDefs.pxi":1238 + /* "PyCafeDefs.pxi":1267 * # for i in range(0, pvd.getNelem()): * # localList.append(pvd.getAsLong(i)) #getAsUShort(i) * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -32244,7 +32684,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD break; case CAFE_LONG: - /* "PyCafeDefs.pxi":1243 + /* "PyCafeDefs.pxi":1272 * localList.append(pvd.getAsLong(i)) * elif dtcheck == CAFE_LONG: * for i in range(0, pvd.getNelem()): # <<<<<<<<<<<<<< @@ -32256,20 +32696,20 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1244 + /* "PyCafeDefs.pxi":1273 * elif dtcheck == CAFE_LONG: * for i in range(0, pvd.getNelem()): * localList.append(pvd.getAsLong(i)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_DOUBLE: * for i in range(0, pvd.getNelem()): */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1244, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1244, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1273, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "PyCafeDefs.pxi":1242 + /* "PyCafeDefs.pxi":1271 * # pvd.getAsChar(i) * localList.append(pvd.getAsLong(i)) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -32279,7 +32719,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD break; case CAFE_DOUBLE: - /* "PyCafeDefs.pxi":1246 + /* "PyCafeDefs.pxi":1275 * localList.append(pvd.getAsLong(i)) * elif dtcheck == CAFE_DOUBLE: * for i in range(0, pvd.getNelem()): # <<<<<<<<<<<<<< @@ -32291,20 +32731,20 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1247 + /* "PyCafeDefs.pxi":1276 * elif dtcheck == CAFE_DOUBLE: * for i in range(0, pvd.getNelem()): * localList.append(pvd.getAsDouble(i)) # <<<<<<<<<<<<<< * else: * localList.append(0) */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvd.getAsDouble(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1247, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvd.getAsDouble(__pyx_v_i)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1247, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1276, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "PyCafeDefs.pxi":1245 + /* "PyCafeDefs.pxi":1274 * for i in range(0, pvd.getNelem()): * localList.append(pvd.getAsLong(i)) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -32314,25 +32754,25 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD break; default: - /* "PyCafeDefs.pxi":1249 + /* "PyCafeDefs.pxi":1278 * localList.append(pvd.getAsDouble(i)) * else: * localList.append(0) # <<<<<<<<<<<<<< * # print ("This line in PyCafe def getDataHolderToStruct should never appear!" * # print ("No Data! Error. Is channel connected?" */ - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1249, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1278, __pyx_L1_error) break; } - /* "PyCafeDefs.pxi":1253 + /* "PyCafeDefs.pxi":1282 * # print ("No Data! Error. Is channel connected?" * * p1.value = localList # <<<<<<<<<<<<<< * p1.status = pvd.getStatus() * p1.statusAsString = pvd.getStatusAsString() */ - if (!(likely(PyList_CheckExact(__pyx_v_localList))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_localList)->tp_name), 0))) __PYX_ERR(2, 1253, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_localList))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_localList)->tp_name), 0))) __PYX_ERR(2, 1282, __pyx_L1_error) __pyx_t_1 = __pyx_v_localList; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); @@ -32341,7 +32781,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_v_p1->value = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1254 + /* "PyCafeDefs.pxi":1283 * * p1.value = localList * p1.status = pvd.getStatus() # <<<<<<<<<<<<<< @@ -32350,14 +32790,14 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_p1->status = __pyx_v_pvd.getStatus(); - /* "PyCafeDefs.pxi":1255 + /* "PyCafeDefs.pxi":1284 * p1.value = localList * p1.status = pvd.getStatus() * p1.statusAsString = pvd.getStatusAsString() # <<<<<<<<<<<<<< * p1.nelem = pvd.getNelem() * p1.alarmStatus = pvd.getAlarmStatus() */ - __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_pvd.getStatusAsString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1255, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_pvd.getStatusAsString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_p1->statusAsString); @@ -32365,7 +32805,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_v_p1->statusAsString = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1256 + /* "PyCafeDefs.pxi":1285 * p1.status = pvd.getStatus() * p1.statusAsString = pvd.getStatusAsString() * p1.nelem = pvd.getNelem() # <<<<<<<<<<<<<< @@ -32374,7 +32814,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_p1->nelem = __pyx_v_pvd.getNelem(); - /* "PyCafeDefs.pxi":1257 + /* "PyCafeDefs.pxi":1286 * p1.statusAsString = pvd.getStatusAsString() * p1.nelem = pvd.getNelem() * p1.alarmStatus = pvd.getAlarmStatus() # <<<<<<<<<<<<<< @@ -32383,7 +32823,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_p1->alarmStatus = __pyx_v_pvd.getAlarmStatus(); - /* "PyCafeDefs.pxi":1258 + /* "PyCafeDefs.pxi":1287 * p1.nelem = pvd.getNelem() * p1.alarmStatus = pvd.getAlarmStatus() * p1.alarmSeverity = pvd.getAlarmSeverity() # <<<<<<<<<<<<<< @@ -32392,14 +32832,14 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_p1->alarmSeverity = __pyx_v_pvd.getAlarmSeverity(); - /* "PyCafeDefs.pxi":1260 + /* "PyCafeDefs.pxi":1289 * p1.alarmSeverity = pvd.getAlarmSeverity() * * p1.alarmStatusAsString = pvd.getAlarmStatusAsString() # <<<<<<<<<<<<<< * p1.alarmSeverityAsString = pvd.getAlarmSeverityAsString() * */ - __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_pvd.getAlarmStatusAsString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1260, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_pvd.getAlarmStatusAsString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1289, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_p1->alarmStatusAsString); @@ -32407,14 +32847,14 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_v_p1->alarmStatusAsString = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1261 + /* "PyCafeDefs.pxi":1290 * * p1.alarmStatusAsString = pvd.getAlarmStatusAsString() * p1.alarmSeverityAsString = pvd.getAlarmSeverityAsString() # <<<<<<<<<<<<<< * * p1.pulseID = pvd.getPulseID() */ - __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_pvd.getAlarmSeverityAsString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1261, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_pvd.getAlarmSeverityAsString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_p1->alarmSeverityAsString); @@ -32422,7 +32862,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_v_p1->alarmSeverityAsString = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1263 + /* "PyCafeDefs.pxi":1292 * p1.alarmSeverityAsString = pvd.getAlarmSeverityAsString() * * p1.pulseID = pvd.getPulseID() # <<<<<<<<<<<<<< @@ -32431,7 +32871,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_p1->pulseID = __pyx_v_pvd.getPulseID(); - /* "PyCafeDefs.pxi":1265 + /* "PyCafeDefs.pxi":1294 * p1.pulseID = pvd.getPulseID() * * p1.dataType = pvd.getDataType() # <<<<<<<<<<<<<< @@ -32440,14 +32880,14 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_p1->dataType = __pyx_v_pvd.getDataType(); - /* "PyCafeDefs.pxi":1266 + /* "PyCafeDefs.pxi":1295 * * p1.dataType = pvd.getDataType() * p1.dataTypeAsString = cdt.message(pvd.getDataType()) # <<<<<<<<<<<<<< * - * p1.tsDateAsString = pvd.getEpicsTimeStampAsString() + * p1.tsDateAsString = encodeString( pvd.getEpicsTimeStampAsString()) */ - __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_cdt.message(__pyx_v_pvd.getDataType())); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1266, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_cdt.message(__pyx_v_pvd.getDataType())); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_p1->dataTypeAsString); @@ -32455,89 +32895,97 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_v_p1->dataTypeAsString = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1268 + /* "PyCafeDefs.pxi":1297 * p1.dataTypeAsString = cdt.message(pvd.getDataType()) * - * p1.tsDateAsString = pvd.getEpicsTimeStampAsString() # <<<<<<<<<<<<<< - * p1.bsDateAsString = pvd.getBSTimeStampAsString() + * p1.tsDateAsString = encodeString( pvd.getEpicsTimeStampAsString()) # <<<<<<<<<<<<<< + * p1.bsDateAsString = encodeString( pvd.getBSTimeStampAsString()) * */ - __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_pvd.getEpicsTimeStampAsString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1268, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_pvd.getEpicsTimeStampAsString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_3 = __pyx_f_6PyCafe_encodeString(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(2, 1297, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_p1->tsDateAsString); __Pyx_DECREF(__pyx_v_p1->tsDateAsString); - __pyx_v_p1->tsDateAsString = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + __pyx_v_p1->tsDateAsString = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; - /* "PyCafeDefs.pxi":1269 + /* "PyCafeDefs.pxi":1298 * - * p1.tsDateAsString = pvd.getEpicsTimeStampAsString() - * p1.bsDateAsString = pvd.getBSTimeStampAsString() # <<<<<<<<<<<<<< + * p1.tsDateAsString = encodeString( pvd.getEpicsTimeStampAsString()) + * p1.bsDateAsString = encodeString( pvd.getBSTimeStampAsString()) # <<<<<<<<<<<<<< * - * pvd._etsNorm = pvd.getEpicsTimeStampAsUInt32() + * #Mr 21, 2002 11:59:11.856568682 */ - __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_pvd.getBSTimeStampAsString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1269, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_pvd.getBSTimeStampAsString()); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_f_6PyCafe_encodeString(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(2, 1298, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_p1->bsDateAsString); __Pyx_DECREF(__pyx_v_p1->bsDateAsString); __pyx_v_p1->bsDateAsString = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1271 - * p1.bsDateAsString = pvd.getBSTimeStampAsString() - * + /* "PyCafeDefs.pxi":1302 + * #Mr 21, 2002 11:59:11.856568682 + * #print( p1.tsDateAsString, "//", p1.bsDateAsString) * pvd._etsNorm = pvd.getEpicsTimeStampAsUInt32() # <<<<<<<<<<<<<< * * cpdef ll = [] */ __pyx_v_pvd._etsNorm = __pyx_v_pvd.getEpicsTimeStampAsUInt32(); - /* "PyCafeDefs.pxi":1273 + /* "PyCafeDefs.pxi":1304 * pvd._etsNorm = pvd.getEpicsTimeStampAsUInt32() * * cpdef ll = [] # <<<<<<<<<<<<<< * ll.append((pvd._etsNorm).secPastEpoch) * ll.append((pvd._etsNorm).nsec) */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1273, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ll = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1274 + /* "PyCafeDefs.pxi":1305 * * cpdef ll = [] * ll.append((pvd._etsNorm).secPastEpoch) # <<<<<<<<<<<<<< * ll.append((pvd._etsNorm).nsec) * p1.ts = ll */ - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_pvd._etsNorm.secPastEpoch); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1274, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_pvd._etsNorm.secPastEpoch); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ll, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1274, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ll, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1305, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1275 + /* "PyCafeDefs.pxi":1306 * cpdef ll = [] * ll.append((pvd._etsNorm).secPastEpoch) * ll.append((pvd._etsNorm).nsec) # <<<<<<<<<<<<<< * p1.ts = ll * */ - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_pvd._etsNorm.nsec); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1275, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_pvd._etsNorm.nsec); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ll, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1275, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ll, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1306, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1276 + /* "PyCafeDefs.pxi":1307 * ll.append((pvd._etsNorm).secPastEpoch) * ll.append((pvd._etsNorm).nsec) * p1.ts = ll # <<<<<<<<<<<<<< * * pvd._etsDate = pvd.getEpicsTimeStampAsDate() */ - if (!(likely(PyList_CheckExact(__pyx_v_ll))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_ll)->tp_name), 0))) __PYX_ERR(2, 1276, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_ll))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_ll)->tp_name), 0))) __PYX_ERR(2, 1307, __pyx_L1_error) __pyx_t_1 = __pyx_v_ll; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); @@ -32546,7 +32994,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_v_p1->ts = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1278 + /* "PyCafeDefs.pxi":1309 * p1.ts = ll * * pvd._etsDate = pvd.getEpicsTimeStampAsDate() # <<<<<<<<<<<<<< @@ -32555,110 +33003,110 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD */ __pyx_v_pvd._etsDate = __pyx_v_pvd.getEpicsTimeStampAsDate(); - /* "PyCafeDefs.pxi":1280 + /* "PyCafeDefs.pxi":1311 * pvd._etsDate = pvd.getEpicsTimeStampAsDate() * * cpdef ld = [] # <<<<<<<<<<<<<< * ld.append((pvd._etsDate).year) * ld.append((pvd._etsDate).mon) */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1280, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ld = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1281 + /* "PyCafeDefs.pxi":1312 * * cpdef ld = [] * ld.append((pvd._etsDate).year) # <<<<<<<<<<<<<< * ld.append((pvd._etsDate).mon) * ld.append((pvd._etsDate).day) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.year); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1281, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.year); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1312, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1281, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1312, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1282 + /* "PyCafeDefs.pxi":1313 * cpdef ld = [] * ld.append((pvd._etsDate).year) * ld.append((pvd._etsDate).mon) # <<<<<<<<<<<<<< * ld.append((pvd._etsDate).day) * ld.append((pvd._etsDate).hour) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.mon); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1282, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.mon); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1282, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1313, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1283 + /* "PyCafeDefs.pxi":1314 * ld.append((pvd._etsDate).year) * ld.append((pvd._etsDate).mon) * ld.append((pvd._etsDate).day) # <<<<<<<<<<<<<< * ld.append((pvd._etsDate).hour) * ld.append((pvd._etsDate).min) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.day); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1283, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.day); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1283, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1314, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1284 + /* "PyCafeDefs.pxi":1315 * ld.append((pvd._etsDate).mon) * ld.append((pvd._etsDate).day) * ld.append((pvd._etsDate).hour) # <<<<<<<<<<<<<< * ld.append((pvd._etsDate).min) * ld.append((pvd._etsDate).sec) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.hour); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1284, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.hour); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1284, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1315, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1285 + /* "PyCafeDefs.pxi":1316 * ld.append((pvd._etsDate).day) * ld.append((pvd._etsDate).hour) * ld.append((pvd._etsDate).min) # <<<<<<<<<<<<<< * ld.append((pvd._etsDate).sec) * ld.append((pvd._etsDate).nsec) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.min); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1285, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.min); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1285, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1316, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1286 + /* "PyCafeDefs.pxi":1317 * ld.append((pvd._etsDate).hour) * ld.append((pvd._etsDate).min) * ld.append((pvd._etsDate).sec) # <<<<<<<<<<<<<< * ld.append((pvd._etsDate).nsec) * p1.tsDate = ld */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.sec); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1286, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_pvd._etsDate.sec); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1286, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1317, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1287 + /* "PyCafeDefs.pxi":1318 * ld.append((pvd._etsDate).min) * ld.append((pvd._etsDate).sec) * ld.append((pvd._etsDate).nsec) # <<<<<<<<<<<<<< * p1.tsDate = ld * */ - __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_pvd._etsDate.nsec); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1287, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_pvd._etsDate.nsec); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1287, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1318, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1288 + /* "PyCafeDefs.pxi":1319 * ld.append((pvd._etsDate).sec) * ld.append((pvd._etsDate).nsec) * p1.tsDate = ld # <<<<<<<<<<<<<< * * return p1 */ - if (!(likely(PyList_CheckExact(__pyx_v_ld))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_ld)->tp_name), 0))) __PYX_ERR(2, 1288, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_ld))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_ld)->tp_name), 0))) __PYX_ERR(2, 1319, __pyx_L1_error) __pyx_t_1 = __pyx_v_ld; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); @@ -32667,7 +33115,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_v_p1->tsDate = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1290 + /* "PyCafeDefs.pxi":1321 * p1.tsDate = ld * * return p1 # <<<<<<<<<<<<<< @@ -32679,7 +33127,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD __pyx_r = __pyx_v_p1; goto __pyx_L0; - /* "PyCafeDefs.pxi":1173 + /* "PyCafeDefs.pxi":1202 * ################################################################################# * * cdef pvdata PVDataHolderToStruct(PVDataHolder pvd, dt=None): # <<<<<<<<<<<<<< @@ -32707,7 +33155,7 @@ static struct __pyx_obj_6PyCafe_pvdata *__pyx_f_6PyCafe_PVDataHolderToStruct(PVD return __pyx_r; } -/* "PyCafeDefs.pxi":1296 +/* "PyCafeDefs.pxi":1327 * ################################################################################# * * cdef pvctrl PVCtrlHolderToStruct(PVCtrlHolder pvc, dt=None): # <<<<<<<<<<<<<< @@ -32751,20 +33199,20 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC } } - /* "PyCafeDefs.pxi":1299 + /* "PyCafeDefs.pxi":1330 * * #global c1 * cdef pvctrl c1 = pvctrl() # <<<<<<<<<<<<<< * - * + * cdef unsigned int dtn = pvc.getDataType() */ - __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvctrl)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1299, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvctrl)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c1 = ((struct __pyx_obj_6PyCafe_pvctrl *)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1303 - * + /* "PyCafeDefs.pxi":1332 + * cdef pvctrl c1 = pvctrl() * * cdef unsigned int dtn = pvc.getDataType() # <<<<<<<<<<<<<< * @@ -32772,7 +33220,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ __pyx_v_dtn = __pyx_v_pvc.getDataType(); - /* "PyCafeDefs.pxi":1305 + /* "PyCafeDefs.pxi":1334 * cdef unsigned int dtn = pvc.getDataType() * * cdef unsigned int dtcheck = dtn # <<<<<<<<<<<<<< @@ -32781,45 +33229,45 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ __pyx_v_dtcheck = __pyx_v_dtn; - /* "PyCafeDefs.pxi":1308 + /* "PyCafeDefs.pxi":1337 * cdef bytes bytesVal * * cdef localList = [] # <<<<<<<<<<<<<< * * if dt: */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1308, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_localList = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1310 + /* "PyCafeDefs.pxi":1339 * cdef localList = [] * * if dt: # <<<<<<<<<<<<<< * dtcheck = getMatchedDataType(dt, dtn) * */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_dt); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 1310, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_dt); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 1339, __pyx_L1_error) if (__pyx_t_2) { - /* "PyCafeDefs.pxi":1311 + /* "PyCafeDefs.pxi":1340 * * if dt: * dtcheck = getMatchedDataType(dt, dtn) # <<<<<<<<<<<<<< * * if dtcheck == CAFE_STRING: */ - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1311, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1311, __pyx_L1_error) + __pyx_t_3 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1311, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1340, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_dtcheck = __pyx_t_4; - /* "PyCafeDefs.pxi":1310 + /* "PyCafeDefs.pxi":1339 * cdef localList = [] * * if dt: # <<<<<<<<<<<<<< @@ -32828,7 +33276,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ } - /* "PyCafeDefs.pxi":1313 + /* "PyCafeDefs.pxi":1342 * dtcheck = getMatchedDataType(dt, dtn) * * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -32838,7 +33286,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafeDefs.pxi":1314 + /* "PyCafeDefs.pxi":1343 * * if dtcheck == CAFE_STRING: * for i in range(0, pvc.getNelem()): # <<<<<<<<<<<<<< @@ -32850,14 +33298,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1315 + /* "PyCafeDefs.pxi":1344 * if dtcheck == CAFE_STRING: * for i in range(0, pvc.getNelem()): * bytesVal = pvc.getAsString(i) # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('utf-8') */ - __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_pvc.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1315, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_pvc.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); @@ -32865,7 +33313,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_1)); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1316 + /* "PyCafeDefs.pxi":1345 * for i in range(0, pvc.getNelem()): * bytesVal = pvc.getAsString(i) * try: # <<<<<<<<<<<<<< @@ -32881,7 +33329,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_XGOTREF(__pyx_t_9); /*try:*/ { - /* "PyCafeDefs.pxi":1317 + /* "PyCafeDefs.pxi":1346 * bytesVal = pvc.getAsString(i) * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -32890,14 +33338,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(2, 1317, __pyx_L6_error) + __PYX_ERR(2, 1346, __pyx_L6_error) } - __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1317, __pyx_L6_error) + __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1346, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1316 + /* "PyCafeDefs.pxi":1345 * for i in range(0, pvc.getNelem()): * bytesVal = pvc.getAsString(i) * try: # <<<<<<<<<<<<<< @@ -32913,7 +33361,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1318 + /* "PyCafeDefs.pxi":1347 * try: * strVal = (bytesVal).decode('utf-8') * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -32928,7 +33376,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC goto __pyx_L8_except_error; __pyx_L8_except_error:; - /* "PyCafeDefs.pxi":1316 + /* "PyCafeDefs.pxi":1345 * for i in range(0, pvc.getNelem()): * bytesVal = pvc.getAsString(i) * try: # <<<<<<<<<<<<<< @@ -32948,7 +33396,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_L13_try_end:; } - /* "PyCafeDefs.pxi":1320 + /* "PyCafeDefs.pxi":1349 * except UnicodeDecodeError: * pass * try: # <<<<<<<<<<<<<< @@ -32964,7 +33412,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_XGOTREF(__pyx_t_7); /*try:*/ { - /* "PyCafeDefs.pxi":1321 + /* "PyCafeDefs.pxi":1350 * pass * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -32973,14 +33421,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(2, 1321, __pyx_L14_error) + __PYX_ERR(2, 1350, __pyx_L14_error) } - __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1321, __pyx_L14_error) + __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1350, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1320 + /* "PyCafeDefs.pxi":1349 * except UnicodeDecodeError: * pass * try: # <<<<<<<<<<<<<< @@ -32996,7 +33444,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1322 + /* "PyCafeDefs.pxi":1351 * try: * strVal = (bytesVal).decode('utf-16') * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -33011,7 +33459,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC goto __pyx_L16_except_error; __pyx_L16_except_error:; - /* "PyCafeDefs.pxi":1320 + /* "PyCafeDefs.pxi":1349 * except UnicodeDecodeError: * pass * try: # <<<<<<<<<<<<<< @@ -33031,7 +33479,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_L21_try_end:; } - /* "PyCafeDefs.pxi":1324 + /* "PyCafeDefs.pxi":1353 * except UnicodeDecodeError: * pass * try: # <<<<<<<<<<<<<< @@ -33047,7 +33495,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_XGOTREF(__pyx_t_9); /*try:*/ { - /* "PyCafeDefs.pxi":1325 + /* "PyCafeDefs.pxi":1354 * pass * try: * strVal= (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -33056,14 +33504,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(2, 1325, __pyx_L22_error) + __PYX_ERR(2, 1354, __pyx_L22_error) } - __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1325, __pyx_L22_error) + __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1354, __pyx_L22_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1324 + /* "PyCafeDefs.pxi":1353 * except UnicodeDecodeError: * pass * try: # <<<<<<<<<<<<<< @@ -33079,7 +33527,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1326 + /* "PyCafeDefs.pxi":1355 * try: * strVal= (bytesVal).decode('latin-1') * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -33089,19 +33537,19 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeDecodeError); if (__pyx_t_10) { __Pyx_AddTraceback("PyCafe.PVCtrlHolderToStruct", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_3, &__pyx_t_11) < 0) __PYX_ERR(2, 1326, __pyx_L24_except_error) + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_3, &__pyx_t_11) < 0) __PYX_ERR(2, 1355, __pyx_L24_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_11); - /* "PyCafeDefs.pxi":1327 + /* "PyCafeDefs.pxi":1356 * strVal= (bytesVal).decode('latin-1') * except UnicodeDecodeError: * strVal = pvc.getAsString(i) # <<<<<<<<<<<<<< * localList.append(strVal) * elif dtcheck == CAFE_SHORT: */ - __pyx_t_12 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvc.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1327, __pyx_L24_except_error) + __pyx_t_12 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvc.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1356, __pyx_L24_except_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_12); __pyx_t_12 = 0; @@ -33113,7 +33561,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC goto __pyx_L24_except_error; __pyx_L24_except_error:; - /* "PyCafeDefs.pxi":1324 + /* "PyCafeDefs.pxi":1353 * except UnicodeDecodeError: * pass * try: # <<<<<<<<<<<<<< @@ -33133,17 +33581,17 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_L29_try_end:; } - /* "PyCafeDefs.pxi":1328 + /* "PyCafeDefs.pxi":1357 * except UnicodeDecodeError: * strVal = pvc.getAsString(i) * localList.append(strVal) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_SHORT: * for i in range(0, pvc.getNelem()): */ - __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1328, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1357, __pyx_L1_error) } - /* "PyCafeDefs.pxi":1313 + /* "PyCafeDefs.pxi":1342 * dtcheck = getMatchedDataType(dt, dtn) * * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -33153,7 +33601,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC break; case CAFE_SHORT: - /* "PyCafeDefs.pxi":1330 + /* "PyCafeDefs.pxi":1359 * localList.append(strVal) * elif dtcheck == CAFE_SHORT: * for i in range(0, pvc.getNelem()): # <<<<<<<<<<<<<< @@ -33165,20 +33613,20 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1331 + /* "PyCafeDefs.pxi":1360 * elif dtcheck == CAFE_SHORT: * for i in range(0, pvc.getNelem()): * localList.append(pvc.getAsLong(i)) # getAsShort(i) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_FLOAT: * for i in range(0, pvc.getNelem()): */ - __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_pvc.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1331, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_pvc.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1331, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1360, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } - /* "PyCafeDefs.pxi":1329 + /* "PyCafeDefs.pxi":1358 * strVal = pvc.getAsString(i) * localList.append(strVal) * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -33188,7 +33636,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC break; case CAFE_FLOAT: - /* "PyCafeDefs.pxi":1333 + /* "PyCafeDefs.pxi":1362 * localList.append(pvc.getAsLong(i)) # getAsShort(i) * elif dtcheck == CAFE_FLOAT: * for i in range(0, pvc.getNelem()): # <<<<<<<<<<<<<< @@ -33200,20 +33648,20 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1334 + /* "PyCafeDefs.pxi":1363 * elif dtcheck == CAFE_FLOAT: * for i in range(0, pvc.getNelem()): * localList.append(pvc.getAsDouble(i)) # getAsFloat(i) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native */ - __pyx_t_11 = PyFloat_FromDouble(__pyx_v_pvc.getAsDouble(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1334, __pyx_L1_error) + __pyx_t_11 = PyFloat_FromDouble(__pyx_v_pvc.getAsDouble(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1363, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1334, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1363, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } - /* "PyCafeDefs.pxi":1332 + /* "PyCafeDefs.pxi":1361 * for i in range(0, pvc.getNelem()): * localList.append(pvc.getAsLong(i)) # getAsShort(i) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -33223,7 +33671,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC break; case CAFE_ENUM: - /* "PyCafeDefs.pxi":1338 + /* "PyCafeDefs.pxi":1367 * # if enum, string taken as native * # if self._c_cafe.isEnum(handle)==1: * for i in range(0, pvc.getNelem()): # <<<<<<<<<<<<<< @@ -33235,20 +33683,20 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1339 + /* "PyCafeDefs.pxi":1368 * # if self._c_cafe.isEnum(handle)==1: * for i in range(0, pvc.getNelem()): * localList.append(pvc.getAsString(i)) # <<<<<<<<<<<<<< * # else: * # for i in range(0, pvd.getNelem()): */ - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvc.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1339, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvc.getAsString(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1339, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } - /* "PyCafeDefs.pxi":1335 + /* "PyCafeDefs.pxi":1364 * for i in range(0, pvc.getNelem()): * localList.append(pvc.getAsDouble(i)) # getAsFloat(i) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -33258,7 +33706,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC break; case CAFE_CHAR: - /* "PyCafeDefs.pxi":1344 + /* "PyCafeDefs.pxi":1373 * # localList.append(pvd.getAsLong(i)) #getAsUShort(i) * elif dtcheck == CAFE_CHAR: * for i in range(0, pvc.getNelem()): # <<<<<<<<<<<<<< @@ -33270,20 +33718,20 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1346 + /* "PyCafeDefs.pxi":1375 * for i in range(0, pvc.getNelem()): * # pvd.getAsChar(i) * localList.append(pvc.getAsLong(i)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * for i in range(0, pvc.getNelem()): */ - __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_pvc.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1346, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_pvc.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1346, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1375, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } - /* "PyCafeDefs.pxi":1343 + /* "PyCafeDefs.pxi":1372 * # for i in range(0, pvd.getNelem()): * # localList.append(pvd.getAsLong(i)) #getAsUShort(i) * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -33293,7 +33741,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC break; case CAFE_LONG: - /* "PyCafeDefs.pxi":1348 + /* "PyCafeDefs.pxi":1377 * localList.append(pvc.getAsLong(i)) * elif dtcheck == CAFE_LONG: * for i in range(0, pvc.getNelem()): # <<<<<<<<<<<<<< @@ -33305,20 +33753,20 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1349 + /* "PyCafeDefs.pxi":1378 * elif dtcheck == CAFE_LONG: * for i in range(0, pvc.getNelem()): * localList.append(pvc.getAsLong(i)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_DOUBLE: * for i in range(0, pvc.getNelem()): */ - __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_pvc.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1349, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_pvc.getAsLong(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1349, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1378, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } - /* "PyCafeDefs.pxi":1347 + /* "PyCafeDefs.pxi":1376 * # pvd.getAsChar(i) * localList.append(pvc.getAsLong(i)) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -33328,7 +33776,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC break; case CAFE_DOUBLE: - /* "PyCafeDefs.pxi":1351 + /* "PyCafeDefs.pxi":1380 * localList.append(pvc.getAsLong(i)) * elif dtcheck == CAFE_DOUBLE: * for i in range(0, pvc.getNelem()): # <<<<<<<<<<<<<< @@ -33340,20 +33788,20 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1352 + /* "PyCafeDefs.pxi":1381 * elif dtcheck == CAFE_DOUBLE: * for i in range(0, pvc.getNelem()): * localList.append(pvc.getAsDouble(i)) # <<<<<<<<<<<<<< * else: * localList.append(0) */ - __pyx_t_11 = PyFloat_FromDouble(__pyx_v_pvc.getAsDouble(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1352, __pyx_L1_error) + __pyx_t_11 = PyFloat_FromDouble(__pyx_v_pvc.getAsDouble(__pyx_v_i)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1352, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1381, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } - /* "PyCafeDefs.pxi":1350 + /* "PyCafeDefs.pxi":1379 * for i in range(0, pvc.getNelem()): * localList.append(pvc.getAsLong(i)) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -33363,25 +33811,25 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC break; default: - /* "PyCafeDefs.pxi":1354 + /* "PyCafeDefs.pxi":1383 * localList.append(pvc.getAsDouble(i)) * else: * localList.append(0) # <<<<<<<<<<<<<< * # print ("This line in PyCafe def getDataHolderToStruct should never appear!" * # print ("No Data! Error. Is channel connected?" */ - __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1354, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1383, __pyx_L1_error) break; } - /* "PyCafeDefs.pxi":1357 + /* "PyCafeDefs.pxi":1386 * # print ("This line in PyCafe def getDataHolderToStruct should never appear!" * # print ("No Data! Error. Is channel connected?" * c1.value = localList # <<<<<<<<<<<<<< * c1.status = pvc.getStatus() * c1.nelem = pvc.getNelem() */ - if (!(likely(PyList_CheckExact(__pyx_v_localList))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_localList)->tp_name), 0))) __PYX_ERR(2, 1357, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_localList))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_localList)->tp_name), 0))) __PYX_ERR(2, 1386, __pyx_L1_error) __pyx_t_11 = __pyx_v_localList; __Pyx_INCREF(__pyx_t_11); __Pyx_GIVEREF(__pyx_t_11); @@ -33390,7 +33838,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->value = ((PyObject*)__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafeDefs.pxi":1358 + /* "PyCafeDefs.pxi":1387 * # print ("No Data! Error. Is channel connected?" * c1.value = localList * c1.status = pvc.getStatus() # <<<<<<<<<<<<<< @@ -33399,7 +33847,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ __pyx_v_c1->status = __pyx_v_pvc.getStatus(); - /* "PyCafeDefs.pxi":1359 + /* "PyCafeDefs.pxi":1388 * c1.value = localList * c1.status = pvc.getStatus() * c1.nelem = pvc.getNelem() # <<<<<<<<<<<<<< @@ -33408,7 +33856,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ __pyx_v_c1->nelem = __pyx_v_pvc.getNelem(); - /* "PyCafeDefs.pxi":1360 + /* "PyCafeDefs.pxi":1389 * c1.status = pvc.getStatus() * c1.nelem = pvc.getNelem() * c1.alarmStatus = pvc.getAlarmStatus() # <<<<<<<<<<<<<< @@ -33417,7 +33865,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ __pyx_v_c1->alarmStatus = __pyx_v_pvc.getAlarmStatus(); - /* "PyCafeDefs.pxi":1361 + /* "PyCafeDefs.pxi":1390 * c1.nelem = pvc.getNelem() * c1.alarmStatus = pvc.getAlarmStatus() * c1.alarmSeverity = pvc.getAlarmSeverity() # <<<<<<<<<<<<<< @@ -33426,7 +33874,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ __pyx_v_c1->alarmSeverity = __pyx_v_pvc.getAlarmSeverity(); - /* "PyCafeDefs.pxi":1363 + /* "PyCafeDefs.pxi":1392 * c1.alarmSeverity = pvc.getAlarmSeverity() * * c1.precision = pvc.getPrecision() # <<<<<<<<<<<<<< @@ -33435,7 +33883,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ __pyx_v_c1->precision = __pyx_v_pvc.getPrecision(); - /* "PyCafeDefs.pxi":1364 + /* "PyCafeDefs.pxi":1393 * * c1.precision = pvc.getPrecision() * c1.noEnumStrings = pvc.getNoEnumStrings() # <<<<<<<<<<<<<< @@ -33444,19 +33892,19 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ __pyx_v_c1->noEnumStrings = __pyx_v_pvc.getNoEnumStrings(); - /* "PyCafeDefs.pxi":1366 + /* "PyCafeDefs.pxi":1395 * c1.noEnumStrings = pvc.getNoEnumStrings() * * enumList = [] # <<<<<<<<<<<<<< * for i in range(0, pvc.getNoEnumStrings()): * enumList.append(pvc.getEnumStrings()[i]) */ - __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1366, __pyx_L1_error) + __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_v_enumList = ((PyObject*)__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafeDefs.pxi":1367 + /* "PyCafeDefs.pxi":1396 * * enumList = [] * for i in range(0, pvc.getNoEnumStrings()): # <<<<<<<<<<<<<< @@ -33468,20 +33916,20 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_15; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafeDefs.pxi":1368 + /* "PyCafeDefs.pxi":1397 * enumList = [] * for i in range(0, pvc.getNoEnumStrings()): * enumList.append(pvc.getEnumStrings()[i]) # <<<<<<<<<<<<<< * * c1.enumStrings = enumList */ - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvc.getEnumStrings()[__pyx_v_i])); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1368, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvc.getEnumStrings()[__pyx_v_i])); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_enumList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1368, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_enumList, __pyx_t_11); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(2, 1397, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } - /* "PyCafeDefs.pxi":1370 + /* "PyCafeDefs.pxi":1399 * enumList.append(pvc.getEnumStrings()[i]) * * c1.enumStrings = enumList # <<<<<<<<<<<<<< @@ -33494,7 +33942,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_DECREF(__pyx_v_c1->enumStrings); __pyx_v_c1->enumStrings = __pyx_v_enumList; - /* "PyCafeDefs.pxi":1373 + /* "PyCafeDefs.pxi":1402 * * cdef bytes bVal * try: # <<<<<<<<<<<<<< @@ -33510,14 +33958,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_XGOTREF(__pyx_t_7); /*try:*/ { - /* "PyCafeDefs.pxi":1374 + /* "PyCafeDefs.pxi":1403 * cdef bytes bVal * try: * c1.units = pvc.getUnits() # <<<<<<<<<<<<<< * except UnicodeDecodeError: * #c1.units = str("") */ - __pyx_t_11 = __Pyx_PyUnicode_FromString(__pyx_v_pvc.getUnits()); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1374, __pyx_L46_error) + __pyx_t_11 = __Pyx_PyUnicode_FromString(__pyx_v_pvc.getUnits()); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1403, __pyx_L46_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_GIVEREF(__pyx_t_11); __Pyx_GOTREF(__pyx_v_c1->units); @@ -33525,7 +33973,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->units = ((PyObject*)__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafeDefs.pxi":1373 + /* "PyCafeDefs.pxi":1402 * * cdef bytes bVal * try: # <<<<<<<<<<<<<< @@ -33543,7 +33991,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafeDefs.pxi":1375 + /* "PyCafeDefs.pxi":1404 * try: * c1.units = pvc.getUnits() * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -33553,19 +34001,19 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeDecodeError); if (__pyx_t_10) { __Pyx_AddTraceback("PyCafe.PVCtrlHolderToStruct", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_3, &__pyx_t_1) < 0) __PYX_ERR(2, 1375, __pyx_L48_except_error) + if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_3, &__pyx_t_1) < 0) __PYX_ERR(2, 1404, __pyx_L48_except_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_1); - /* "PyCafeDefs.pxi":1378 + /* "PyCafeDefs.pxi":1407 * #c1.units = str("") * * bVal = pvc.getUnits() # <<<<<<<<<<<<<< * c1.units = (bVal).decode('latin-1') * */ - __pyx_t_12 = __Pyx_PyBytes_FromString(__pyx_v_pvc.getUnits()); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1378, __pyx_L48_except_error) + __pyx_t_12 = __Pyx_PyBytes_FromString(__pyx_v_pvc.getUnits()); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1407, __pyx_L48_except_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __pyx_t_12; __Pyx_INCREF(__pyx_t_16); @@ -33573,7 +34021,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_bVal = ((PyObject*)__pyx_t_16); __pyx_t_16 = 0; - /* "PyCafeDefs.pxi":1379 + /* "PyCafeDefs.pxi":1408 * * bVal = pvc.getUnits() * c1.units = (bVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -33582,9 +34030,9 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(2, 1379, __pyx_L48_except_error) + __PYX_ERR(2, 1408, __pyx_L48_except_error) } - __pyx_t_16 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 1379, __pyx_L48_except_error) + __pyx_t_16 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 1408, __pyx_L48_except_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_GIVEREF(__pyx_t_16); __Pyx_GOTREF(__pyx_v_c1->units); @@ -33599,7 +34047,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC goto __pyx_L48_except_error; __pyx_L48_except_error:; - /* "PyCafeDefs.pxi":1373 + /* "PyCafeDefs.pxi":1402 * * cdef bytes bVal * try: # <<<<<<<<<<<<<< @@ -33619,14 +34067,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_L51_try_end:; } - /* "PyCafeDefs.pxi":1393 + /* "PyCafeDefs.pxi":1422 * ''' * * c1.upperDisplayLimit = pvc.getUpperDispLimit_AsDouble() # <<<<<<<<<<<<<< * c1.lowerDisplayLimit = pvc.getLowerDispLimit_AsDouble() * c1.upperAlarmLimit = pvc.getUpperAlarmLimit_AsDouble() */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getUpperDispLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1393, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getUpperDispLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_c1->upperDisplayLimit); @@ -33634,14 +34082,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->upperDisplayLimit = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1394 + /* "PyCafeDefs.pxi":1423 * * c1.upperDisplayLimit = pvc.getUpperDispLimit_AsDouble() * c1.lowerDisplayLimit = pvc.getLowerDispLimit_AsDouble() # <<<<<<<<<<<<<< * c1.upperAlarmLimit = pvc.getUpperAlarmLimit_AsDouble() * c1.upperWarningLimit = pvc.getUpperWarningLimit_AsDouble() */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getLowerDispLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1394, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getLowerDispLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_c1->lowerDisplayLimit); @@ -33649,14 +34097,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->lowerDisplayLimit = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1395 + /* "PyCafeDefs.pxi":1424 * c1.upperDisplayLimit = pvc.getUpperDispLimit_AsDouble() * c1.lowerDisplayLimit = pvc.getLowerDispLimit_AsDouble() * c1.upperAlarmLimit = pvc.getUpperAlarmLimit_AsDouble() # <<<<<<<<<<<<<< * c1.upperWarningLimit = pvc.getUpperWarningLimit_AsDouble() * c1.lowerWarningLimit = pvc.getLowerWarningLimit_AsDouble() */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getUpperAlarmLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1395, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getUpperAlarmLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_c1->upperAlarmLimit); @@ -33664,14 +34112,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->upperAlarmLimit = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1396 + /* "PyCafeDefs.pxi":1425 * c1.lowerDisplayLimit = pvc.getLowerDispLimit_AsDouble() * c1.upperAlarmLimit = pvc.getUpperAlarmLimit_AsDouble() * c1.upperWarningLimit = pvc.getUpperWarningLimit_AsDouble() # <<<<<<<<<<<<<< * c1.lowerWarningLimit = pvc.getLowerWarningLimit_AsDouble() * c1.lowerAlarmLimit = pvc.getLowerAlarmLimit_AsDouble() */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getUpperWarningLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1396, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getUpperWarningLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_c1->upperWarningLimit); @@ -33679,14 +34127,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->upperWarningLimit = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1397 + /* "PyCafeDefs.pxi":1426 * c1.upperAlarmLimit = pvc.getUpperAlarmLimit_AsDouble() * c1.upperWarningLimit = pvc.getUpperWarningLimit_AsDouble() * c1.lowerWarningLimit = pvc.getLowerWarningLimit_AsDouble() # <<<<<<<<<<<<<< * c1.lowerAlarmLimit = pvc.getLowerAlarmLimit_AsDouble() * c1.upperControlLimit = pvc.getUpperCtrlLimit_AsDouble() */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getLowerWarningLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1397, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getLowerWarningLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_c1->lowerWarningLimit); @@ -33694,14 +34142,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->lowerWarningLimit = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1398 + /* "PyCafeDefs.pxi":1427 * c1.upperWarningLimit = pvc.getUpperWarningLimit_AsDouble() * c1.lowerWarningLimit = pvc.getLowerWarningLimit_AsDouble() * c1.lowerAlarmLimit = pvc.getLowerAlarmLimit_AsDouble() # <<<<<<<<<<<<<< * c1.upperControlLimit = pvc.getUpperCtrlLimit_AsDouble() * c1.lowerControlLimit = pvc.getLowerCtrlLimit_AsDouble() */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getLowerAlarmLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1398, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getLowerAlarmLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_c1->lowerAlarmLimit); @@ -33709,14 +34157,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->lowerAlarmLimit = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1399 + /* "PyCafeDefs.pxi":1428 * c1.lowerWarningLimit = pvc.getLowerWarningLimit_AsDouble() * c1.lowerAlarmLimit = pvc.getLowerAlarmLimit_AsDouble() * c1.upperControlLimit = pvc.getUpperCtrlLimit_AsDouble() # <<<<<<<<<<<<<< * c1.lowerControlLimit = pvc.getLowerCtrlLimit_AsDouble() * */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getUpperCtrlLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1399, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getUpperCtrlLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_c1->upperControlLimit); @@ -33724,14 +34172,14 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->upperControlLimit = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1400 + /* "PyCafeDefs.pxi":1429 * c1.lowerAlarmLimit = pvc.getLowerAlarmLimit_AsDouble() * c1.upperControlLimit = pvc.getUpperCtrlLimit_AsDouble() * c1.lowerControlLimit = pvc.getLowerCtrlLimit_AsDouble() # <<<<<<<<<<<<<< * * return c1 */ - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getLowerCtrlLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1400, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_pvc.getLowerCtrlLimit_AsDouble()); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_c1->lowerControlLimit); @@ -33739,7 +34187,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_v_c1->lowerControlLimit = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1402 + /* "PyCafeDefs.pxi":1431 * c1.lowerControlLimit = pvc.getLowerCtrlLimit_AsDouble() * * return c1 # <<<<<<<<<<<<<< @@ -33751,7 +34199,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC __pyx_r = __pyx_v_c1; goto __pyx_L0; - /* "PyCafeDefs.pxi":1296 + /* "PyCafeDefs.pxi":1327 * ################################################################################# * * cdef pvctrl PVCtrlHolderToStruct(PVCtrlHolder pvc, dt=None): # <<<<<<<<<<<<<< @@ -33782,7 +34230,7 @@ static struct __pyx_obj_6PyCafe_pvctrl *__pyx_f_6PyCafe_PVCtrlHolderToStruct(PVC return __pyx_r; } -/* "PyCafeDefs.pxi":1408 +/* "PyCafeDefs.pxi":1437 * ################################################################################# * * cdef channelInfo channelRegaliaToStruct(ChannelRegalia cr): # <<<<<<<<<<<<<< @@ -33798,19 +34246,19 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("channelRegaliaToStruct", 0); - /* "PyCafeDefs.pxi":1410 + /* "PyCafeDefs.pxi":1439 * cdef channelInfo channelRegaliaToStruct(ChannelRegalia cr): * * cdef channelInfo ci = channelInfo() # <<<<<<<<<<<<<< * cdef CAFEDataTypeCode cdt * */ - __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_channelInfo)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1410, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_channelInfo)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ci = ((struct __pyx_obj_6PyCafe_channelInfo *)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafeDefs.pxi":1413 + /* "PyCafeDefs.pxi":1442 * cdef CAFEDataTypeCode cdt * * ci.channelID = ( < long > cr.getChannelID()) # <<<<<<<<<<<<<< @@ -33819,7 +34267,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->channelID = ((long)__pyx_v_cr.getChannelID()); - /* "PyCafeDefs.pxi":1414 + /* "PyCafeDefs.pxi":1443 * * ci.channelID = ( < long > cr.getChannelID()) * ci.connectFlag = cr.getConnectFlag() # <<<<<<<<<<<<<< @@ -33828,7 +34276,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->connectFlag = __pyx_v_cr.getConnectFlag(); - /* "PyCafeDefs.pxi":1415 + /* "PyCafeDefs.pxi":1444 * ci.channelID = ( < long > cr.getChannelID()) * ci.connectFlag = cr.getConnectFlag() * ci.hostName = cr.getHostNameAsString() # <<<<<<<<<<<<<< @@ -33837,7 +34285,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->hostName = __pyx_v_cr.getHostNameAsString(); - /* "PyCafeDefs.pxi":1416 + /* "PyCafeDefs.pxi":1445 * ci.connectFlag = cr.getConnectFlag() * ci.hostName = cr.getHostNameAsString() * ci.dataType = cr.getDataType() # <<<<<<<<<<<<<< @@ -33846,7 +34294,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->dataType = __pyx_v_cr.getDataType(); - /* "PyCafeDefs.pxi":1417 + /* "PyCafeDefs.pxi":1446 * ci.hostName = cr.getHostNameAsString() * ci.dataType = cr.getDataType() * ci.dataTypeAsString = cdt.message(cr.getDataType()) # <<<<<<<<<<<<<< @@ -33855,7 +34303,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->dataTypeAsString = __pyx_v_cdt.message(__pyx_v_cr.getDataType()); - /* "PyCafeDefs.pxi":1418 + /* "PyCafeDefs.pxi":1447 * ci.dataType = cr.getDataType() * ci.dataTypeAsString = cdt.message(cr.getDataType()) * ci.className = cr.getClassNameAsString() # <<<<<<<<<<<<<< @@ -33864,7 +34312,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->className = __pyx_v_cr.getClassNameAsString(); - /* "PyCafeDefs.pxi":1419 + /* "PyCafeDefs.pxi":1448 * ci.dataTypeAsString = cdt.message(cr.getDataType()) * ci.className = cr.getClassNameAsString() * ci.accessRead = cr.getAccessRead() # <<<<<<<<<<<<<< @@ -33873,7 +34321,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->accessRead = __pyx_v_cr.getAccessRead(); - /* "PyCafeDefs.pxi":1420 + /* "PyCafeDefs.pxi":1449 * ci.className = cr.getClassNameAsString() * ci.accessRead = cr.getAccessRead() * ci.accessWrite = cr.getAccessWrite() # <<<<<<<<<<<<<< @@ -33882,7 +34330,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->accessWrite = __pyx_v_cr.getAccessWrite(); - /* "PyCafeDefs.pxi":1421 + /* "PyCafeDefs.pxi":1450 * ci.accessRead = cr.getAccessRead() * ci.accessWrite = cr.getAccessWrite() * ci.nelem = cr.getNelem() # <<<<<<<<<<<<<< @@ -33891,7 +34339,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->nelem = __pyx_v_cr.getNelem(); - /* "PyCafeDefs.pxi":1422 + /* "PyCafeDefs.pxi":1451 * ci.accessWrite = cr.getAccessWrite() * ci.nelem = cr.getNelem() * ci.connectionState = cr.getConnectionState() # <<<<<<<<<<<<<< @@ -33900,7 +34348,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->connectionState = __pyx_v_cr.getConnectionState(); - /* "PyCafeDefs.pxi":1423 + /* "PyCafeDefs.pxi":1452 * ci.nelem = cr.getNelem() * ci.connectionState = cr.getConnectionState() * ci.cafeConnectionState = cr.getCafeConnectionState() # <<<<<<<<<<<<<< @@ -33909,7 +34357,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->cafeConnectionState = __pyx_v_cr.getCafeConnectionState(); - /* "PyCafeDefs.pxi":1424 + /* "PyCafeDefs.pxi":1453 * ci.connectionState = cr.getConnectionState() * ci.cafeConnectionState = cr.getCafeConnectionState() * ci.connectionStateAsString = cr.getConnectionStateAsString() # <<<<<<<<<<<<<< @@ -33918,7 +34366,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->connectionStateAsString = __pyx_v_cr.getConnectionStateAsString(); - /* "PyCafeDefs.pxi":1425 + /* "PyCafeDefs.pxi":1454 * ci.cafeConnectionState = cr.getCafeConnectionState() * ci.connectionStateAsString = cr.getConnectionStateAsString() * ci.cafeConnectionStateAsString = cr.getCafeConnectionStateAsString() # <<<<<<<<<<<<<< @@ -33927,7 +34375,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr */ __pyx_v_ci->cafeConnectionStateAsString = __pyx_v_cr.getCafeConnectionStateAsString(); - /* "PyCafeDefs.pxi":1426 + /* "PyCafeDefs.pxi":1455 * ci.connectionStateAsString = cr.getConnectionStateAsString() * ci.cafeConnectionStateAsString = cr.getCafeConnectionStateAsString() * return ci # <<<<<<<<<<<<<< @@ -33938,7 +34386,7 @@ static struct __pyx_obj_6PyCafe_channelInfo *__pyx_f_6PyCafe_channelRegaliaToStr __pyx_r = __pyx_v_ci; goto __pyx_L0; - /* "PyCafeDefs.pxi":1408 + /* "PyCafeDefs.pxi":1437 * ################################################################################# * * cdef channelInfo channelRegaliaToStruct(ChannelRegalia cr): # <<<<<<<<<<<<<< @@ -34941,7 +35389,7 @@ static PyObject *__pyx_pf_6PyCafe_verify_handlepv(CYTHON_UNUSED PyObject *__pyx_ return __pyx_r; } -/* "PyCafe.pyx":176 +/* "PyCafe.pyx":175 * * ########################################################################### * def __cinit__(self): # <<<<<<<<<<<<<< @@ -34980,7 +35428,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ PyObject *__pyx_t_7 = NULL; __Pyx_RefNannySetupContext("__cinit__", 0); - /* "PyCafe.pyx":180 + /* "PyCafe.pyx":179 * * """ * cdef str _METHOD = "__cinit__" # <<<<<<<<<<<<<< @@ -34990,7 +35438,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ __Pyx_INCREF(__pyx_n_u_cinit); __pyx_v__METHOD = __pyx_n_u_cinit; - /* "PyCafe.pyx":181 + /* "PyCafe.pyx":180 * """ * cdef str _METHOD = "__cinit__" * self._c_cafe = new ccafe.CAFE() ##_c_cafe ## # <<<<<<<<<<<<<< @@ -35001,11 +35449,11 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ __pyx_t_1 = new CAFE(); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 181, __pyx_L1_error) + __PYX_ERR(3, 180, __pyx_L1_error) } __pyx_v_self->_c_cafe = __pyx_t_1; - /* "PyCafe.pyx":183 + /* "PyCafe.pyx":182 * self._c_cafe = new ccafe.CAFE() ##_c_cafe ## * * if self._c_cafe is NULL: # <<<<<<<<<<<<<< @@ -35015,20 +35463,20 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ __pyx_t_2 = ((__pyx_v_self->_c_cafe == NULL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":184 + /* "PyCafe.pyx":183 * * if self._c_cafe is NULL: * raise MemoryError("Failed to instantiate CAFE()") # <<<<<<<<<<<<<< * * self.cs = self._c_cafe.getCafeStatus() */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 184, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 184, __pyx_L1_error) + __PYX_ERR(3, 183, __pyx_L1_error) - /* "PyCafe.pyx":183 + /* "PyCafe.pyx":182 * self._c_cafe = new ccafe.CAFE() ##_c_cafe ## * * if self._c_cafe is NULL: # <<<<<<<<<<<<<< @@ -35037,7 +35485,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ */ } - /* "PyCafe.pyx":186 + /* "PyCafe.pyx":185 * raise MemoryError("Failed to instantiate CAFE()") * * self.cs = self._c_cafe.getCafeStatus() # <<<<<<<<<<<<<< @@ -35046,7 +35494,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ */ __pyx_v_self->cs = __pyx_v_self->_c_cafe->getCafeStatus(); - /* "PyCafe.pyx":188 + /* "PyCafe.pyx":187 * self.cs = self._c_cafe.getCafeStatus() * * self._exception_text = "Exception raised in PyCafe.pyx:" # <<<<<<<<<<<<<< @@ -35059,7 +35507,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ __Pyx_DECREF(__pyx_v_self->_exception_text); __pyx_v_self->_exception_text = __pyx_kp_u_Exception_raised_in_PyCafe_pyx; - /* "PyCafe.pyx":189 + /* "PyCafe.pyx":188 * * self._exception_text = "Exception raised in PyCafe.pyx:" * self._enable_exceptions = False # <<<<<<<<<<<<<< @@ -35068,7 +35516,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ */ __pyx_v_self->_enable_exceptions = 0; - /* "PyCafe.pyx":191 + /* "PyCafe.pyx":190 * self._enable_exceptions = False * * self._min_timeout = 0.001 #cannot be zero # <<<<<<<<<<<<<< @@ -35077,7 +35525,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ */ __pyx_v_self->_min_timeout = 0.001; - /* "PyCafe.pyx":193 + /* "PyCafe.pyx":192 * self._min_timeout = 0.001 #cannot be zero * * try: # <<<<<<<<<<<<<< @@ -35088,7 +35536,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ (void)__pyx_t_4; (void)__pyx_t_5; (void)__pyx_t_6; /* mark used */ /*try:*/ { - /* "PyCafe.pyx":194 + /* "PyCafe.pyx":193 * * try: * self._c_cafe.init() # <<<<<<<<<<<<<< @@ -35097,7 +35545,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ */ (void)(__pyx_v_self->_c_cafe->init()); - /* "PyCafe.pyx":193 + /* "PyCafe.pyx":192 * self._min_timeout = 0.001 #cannot be zero * * try: # <<<<<<<<<<<<<< @@ -35107,16 +35555,16 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ } } - /* "PyCafe.pyx":208 + /* "PyCafe.pyx":207 * * * print("PY_VERSION_HEX is ", hex(PY_VERSION_HEX)) # <<<<<<<<<<<<<< * * IF PY_EXT_C: */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_hex, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 208, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_hex, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 208, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_kp_u_PY_VERSION_HEX_is); __Pyx_GIVEREF(__pyx_kp_u_PY_VERSION_HEX_is); @@ -35124,23 +35572,23 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 208, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":211 + /* "PyCafe.pyx":210 * * IF PY_EXT_C: * print("USING PUBLIC PyCafe.h INTERFACE FOR CALLBACKS") # <<<<<<<<<<<<<< * ELSE: * print("USING API PyCafe_api.h INTERFACE FOR CALLBACKS") */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 211, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":176 + /* "PyCafe.pyx":175 * * ########################################################################### * def __cinit__(self): # <<<<<<<<<<<<<< @@ -35164,7 +35612,7 @@ static int __pyx_pf_6PyCafe_6CyCafe___cinit__(struct __pyx_obj_6PyCafe_CyCafe *_ return __pyx_r; } -/* "PyCafe.pyx":221 +/* "PyCafe.pyx":220 * * ########################################################################### * def __dealloc__(self): # <<<<<<<<<<<<<< @@ -35187,7 +35635,7 @@ static void __pyx_pf_6PyCafe_6CyCafe_2__dealloc__(struct __pyx_obj_6PyCafe_CyCaf __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__", 0); - /* "PyCafe.pyx":222 + /* "PyCafe.pyx":221 * ########################################################################### * def __dealloc__(self): * del self._c_cafe # <<<<<<<<<<<<<< @@ -35196,7 +35644,7 @@ static void __pyx_pf_6PyCafe_6CyCafe_2__dealloc__(struct __pyx_obj_6PyCafe_CyCaf */ delete __pyx_v_self->_c_cafe; - /* "PyCafe.pyx":221 + /* "PyCafe.pyx":220 * * ########################################################################### * def __dealloc__(self): # <<<<<<<<<<<<<< @@ -35208,7 +35656,7 @@ static void __pyx_pf_6PyCafe_6CyCafe_2__dealloc__(struct __pyx_obj_6PyCafe_CyCaf __Pyx_RefNannyFinishContext(); } -/* "PyCafe.pyx":226 +/* "PyCafe.pyx":225 * ########################################################################### * * def ca_version(self): # <<<<<<<<<<<<<< @@ -35235,7 +35683,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_4ca_version(struct __pyx_obj_6PyCafe_C PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("ca_version", 0); - /* "PyCafe.pyx":227 + /* "PyCafe.pyx":226 * * def ca_version(self): * return self._c_cafe._ca_version() # <<<<<<<<<<<<<< @@ -35243,13 +35691,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_4ca_version(struct __pyx_obj_6PyCafe_C * def epics_version_string(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->_c_cafe->_ca_version()); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 227, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->_c_cafe->_ca_version()); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":226 + /* "PyCafe.pyx":225 * ########################################################################### * * def ca_version(self): # <<<<<<<<<<<<<< @@ -35270,7 +35718,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_4ca_version(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":229 +/* "PyCafe.pyx":228 * return self._c_cafe._ca_version() * * def epics_version_string(self): # <<<<<<<<<<<<<< @@ -35297,7 +35745,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_6epics_version_string(struct __pyx_obj PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("epics_version_string", 0); - /* "PyCafe.pyx":230 + /* "PyCafe.pyx":229 * * def epics_version_string(self): * return self._c_cafe._epics_version() # <<<<<<<<<<<<<< @@ -35305,13 +35753,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_6epics_version_string(struct __pyx_obj * def CAFE_version(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->_c_cafe->_epics_version()); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 230, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->_c_cafe->_epics_version()); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":229 + /* "PyCafe.pyx":228 * return self._c_cafe._ca_version() * * def epics_version_string(self): # <<<<<<<<<<<<<< @@ -35332,7 +35780,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_6epics_version_string(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":232 +/* "PyCafe.pyx":231 * return self._c_cafe._epics_version() * * def CAFE_version(self): # <<<<<<<<<<<<<< @@ -35358,7 +35806,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_8CAFE_version(CYTHON_UNUSED struct __p __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CAFE_version", 0); - /* "PyCafe.pyx":233 + /* "PyCafe.pyx":232 * * def CAFE_version(self): * return CAFE_VERSION # <<<<<<<<<<<<<< @@ -35366,11 +35814,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_8CAFE_version(CYTHON_UNUSED struct __p * def EPICS_version(self): */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_kp_u_1_15_0_py37_gcc_7_3_0); - __pyx_r = __pyx_kp_u_1_15_0_py37_gcc_7_3_0; + __Pyx_INCREF(__pyx_kp_u_1_15_1_py37_gcc_7_3_0); + __pyx_r = __pyx_kp_u_1_15_1_py37_gcc_7_3_0; goto __pyx_L0; - /* "PyCafe.pyx":232 + /* "PyCafe.pyx":231 * return self._c_cafe._epics_version() * * def CAFE_version(self): # <<<<<<<<<<<<<< @@ -35386,7 +35834,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_8CAFE_version(CYTHON_UNUSED struct __p return __pyx_r; } -/* "PyCafe.pyx":235 +/* "PyCafe.pyx":234 * return CAFE_VERSION * * def EPICS_version(self): # <<<<<<<<<<<<<< @@ -35412,7 +35860,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_10EPICS_version(CYTHON_UNUSED struct _ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("EPICS_version", 0); - /* "PyCafe.pyx":236 + /* "PyCafe.pyx":235 * * def EPICS_version(self): * return EPICS_VERSION # <<<<<<<<<<<<<< @@ -35424,7 +35872,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_10EPICS_version(CYTHON_UNUSED struct _ __pyx_r = __pyx_kp_u_7_0_6; goto __pyx_L0; - /* "PyCafe.pyx":235 + /* "PyCafe.pyx":234 * return CAFE_VERSION * * def EPICS_version(self): # <<<<<<<<<<<<<< @@ -35440,7 +35888,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_10EPICS_version(CYTHON_UNUSED struct _ return __pyx_r; } -/* "PyCafe.pyx":239 +/* "PyCafe.pyx":238 * * @verify_handlepv * def setPyConnectCallbackFn(self, handlePV, cb: object = None): # <<<<<<<<<<<<<< @@ -35484,7 +35932,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_13setPyConnectCallbackFn(PyObject *__p } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setPyConnectCallbackFn") < 0)) __PYX_ERR(3, 239, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setPyConnectCallbackFn") < 0)) __PYX_ERR(3, 238, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -35500,7 +35948,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_13setPyConnectCallbackFn(PyObject *__p } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setPyConnectCallbackFn", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 239, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setPyConnectCallbackFn", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 238, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setPyConnectCallbackFn", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -35522,7 +35970,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_12setPyConnectCallbackFn(struct __pyx_ unsigned int __pyx_t_3; __Pyx_RefNannySetupContext("setPyConnectCallbackFn", 0); - /* "PyCafe.pyx":240 + /* "PyCafe.pyx":239 * @verify_handlepv * def setPyConnectCallbackFn(self, handlePV, cb: object = None): * if cb is None: # <<<<<<<<<<<<<< @@ -35533,7 +35981,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_12setPyConnectCallbackFn(struct __pyx_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":241 + /* "PyCafe.pyx":240 * def setPyConnectCallbackFn(self, handlePV, cb: object = None): * if cb is None: * return # <<<<<<<<<<<<<< @@ -35544,7 +35992,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_12setPyConnectCallbackFn(struct __pyx_ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":240 + /* "PyCafe.pyx":239 * @verify_handlepv * def setPyConnectCallbackFn(self, handlePV, cb: object = None): * if cb is None: # <<<<<<<<<<<<<< @@ -35553,7 +36001,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_12setPyConnectCallbackFn(struct __pyx_ */ } - /* "PyCafe.pyx":242 + /* "PyCafe.pyx":241 * if cb is None: * return * pv_name = handlePV # <<<<<<<<<<<<<< @@ -35563,17 +36011,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_12setPyConnectCallbackFn(struct __pyx_ __Pyx_INCREF(__pyx_v_handlePV); __pyx_v_pv_name = __pyx_v_handlePV; - /* "PyCafe.pyx":243 + /* "PyCafe.pyx":242 * return * pv_name = handlePV * self.hh.setPyConnectCallbackFn(handlePV, cb) # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_3 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 243, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_3 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 242, __pyx_L1_error) (void)(__pyx_v_self->hh.setPyConnectCallbackFn(__pyx_t_3, ((void *)__pyx_v_cb))); - /* "PyCafe.pyx":239 + /* "PyCafe.pyx":238 * * @verify_handlepv * def setPyConnectCallbackFn(self, handlePV, cb: object = None): # <<<<<<<<<<<<<< @@ -35594,7 +36042,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_12setPyConnectCallbackFn(struct __pyx_ return __pyx_r; } -/* "PyCafe.pyx":247 +/* "PyCafe.pyx":246 * * ############################################################################ * def init(self): # <<<<<<<<<<<<<< @@ -35626,7 +36074,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_14init(struct __pyx_obj_6PyCafe_CyCafe PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("init", 0); - /* "PyCafe.pyx":260 + /* "PyCafe.pyx":259 * * """ * cdef str _METHOD = "init" # <<<<<<<<<<<<<< @@ -35636,7 +36084,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_14init(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_n_u_init); __pyx_v__METHOD = __pyx_n_u_init; - /* "PyCafe.pyx":261 + /* "PyCafe.pyx":260 * """ * cdef str _METHOD = "init" * try: # <<<<<<<<<<<<<< @@ -35647,7 +36095,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_14init(struct __pyx_obj_6PyCafe_CyCafe (void)__pyx_t_1; (void)__pyx_t_2; (void)__pyx_t_3; /* mark used */ /*try:*/ { - /* "PyCafe.pyx":262 + /* "PyCafe.pyx":261 * cdef str _METHOD = "init" * try: * self._c_cafe.init() # <<<<<<<<<<<<<< @@ -35656,7 +36104,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_14init(struct __pyx_obj_6PyCafe_CyCafe */ (void)(__pyx_v_self->_c_cafe->init()); - /* "PyCafe.pyx":261 + /* "PyCafe.pyx":260 * """ * cdef str _METHOD = "init" * try: # <<<<<<<<<<<<<< @@ -35666,7 +36114,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_14init(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":247 + /* "PyCafe.pyx":246 * * ############################################################################ * def init(self): # <<<<<<<<<<<<<< @@ -35683,7 +36131,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_14init(struct __pyx_obj_6PyCafe_CyCafe return __pyx_r; } -/* "PyCafe.pyx":276 +/* "PyCafe.pyx":275 * * * def withExceptions(self, bint exceptions=True): # <<<<<<<<<<<<<< @@ -35720,7 +36168,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_17withExceptions(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "withExceptions") < 0)) __PYX_ERR(3, 276, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "withExceptions") < 0)) __PYX_ERR(3, 275, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -35731,14 +36179,14 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_17withExceptions(PyObject *__pyx_v_sel } } if (values[0]) { - __pyx_v_exceptions = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_exceptions == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 276, __pyx_L3_error) + __pyx_v_exceptions = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_exceptions == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 275, __pyx_L3_error) } else { __pyx_v_exceptions = ((int)1); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("withExceptions", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 276, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("withExceptions", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 275, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.withExceptions", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -35757,7 +36205,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_16withExceptions(struct __pyx_obj_6PyC PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("withExceptions", 0); - /* "PyCafe.pyx":294 + /* "PyCafe.pyx":293 * """ * * self._enable_exceptions = exceptions # <<<<<<<<<<<<<< @@ -35766,7 +36214,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_16withExceptions(struct __pyx_obj_6PyC */ __pyx_v_self->_enable_exceptions = __pyx_v_exceptions; - /* "PyCafe.pyx":295 + /* "PyCafe.pyx":294 * * self._enable_exceptions = exceptions * return self._enable_exceptions # <<<<<<<<<<<<<< @@ -35774,13 +36222,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_16withExceptions(struct __pyx_obj_6PyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_enable_exceptions); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 295, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_enable_exceptions); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":276 + /* "PyCafe.pyx":275 * * * def withExceptions(self, bint exceptions=True): # <<<<<<<<<<<<<< @@ -35801,7 +36249,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_16withExceptions(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":299 +/* "PyCafe.pyx":298 * * @property * def enableExceptions(self): # <<<<<<<<<<<<<< @@ -35828,7 +36276,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_16enableExceptions___get__(struct __py PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__get__", 0); - /* "PyCafe.pyx":315 + /* "PyCafe.pyx":314 * """ * * return self._enable_exceptions # <<<<<<<<<<<<<< @@ -35836,13 +36284,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_16enableExceptions___get__(struct __py * @enableExceptions.setter */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_enable_exceptions); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 315, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_enable_exceptions); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":299 + /* "PyCafe.pyx":298 * * @property * def enableExceptions(self): # <<<<<<<<<<<<<< @@ -35863,7 +36311,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_16enableExceptions___get__(struct __py return __pyx_r; } -/* "PyCafe.pyx":318 +/* "PyCafe.pyx":317 * * @enableExceptions.setter * def enableExceptions(self, bint enable): # <<<<<<<<<<<<<< @@ -35879,7 +36327,7 @@ static int __pyx_pw_6PyCafe_6CyCafe_16enableExceptions_3__set__(PyObject *__pyx_ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); assert(__pyx_arg_enable); { - __pyx_v_enable = __Pyx_PyObject_IsTrue(__pyx_arg_enable); if (unlikely((__pyx_v_enable == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 318, __pyx_L3_error) + __pyx_v_enable = __Pyx_PyObject_IsTrue(__pyx_arg_enable); if (unlikely((__pyx_v_enable == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 317, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -35899,7 +36347,7 @@ static int __pyx_pf_6PyCafe_6CyCafe_16enableExceptions_2__set__(struct __pyx_obj __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__", 0); - /* "PyCafe.pyx":319 + /* "PyCafe.pyx":318 * @enableExceptions.setter * def enableExceptions(self, bint enable): * self._enable_exceptions = enable # <<<<<<<<<<<<<< @@ -35908,7 +36356,7 @@ static int __pyx_pf_6PyCafe_6CyCafe_16enableExceptions_2__set__(struct __pyx_obj */ __pyx_v_self->_enable_exceptions = __pyx_v_enable; - /* "PyCafe.pyx":318 + /* "PyCafe.pyx":317 * * @enableExceptions.setter * def enableExceptions(self, bint enable): # <<<<<<<<<<<<<< @@ -35922,7 +36370,7 @@ static int __pyx_pf_6PyCafe_6CyCafe_16enableExceptions_2__set__(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":321 +/* "PyCafe.pyx":320 * self._enable_exceptions = enable * * cdef prepareCafeException( # <<<<<<<<<<<<<< @@ -35933,7 +36381,7 @@ static int __pyx_pf_6PyCafe_6CyCafe_16enableExceptions_2__set__(struct __pyx_obj static PyObject *__pyx_f_6PyCafe_6CyCafe_prepareCafeException(struct __pyx_obj_6PyCafe_CyCafe *__pyx_v_self, int __pyx_v_status, PyObject *__pyx_v__METHOD, struct __pyx_opt_args_6PyCafe_6CyCafe_prepareCafeException *__pyx_optional_args) { unsigned int __pyx_v_handle = ((unsigned int)0); - /* "PyCafe.pyx":323 + /* "PyCafe.pyx":322 * cdef prepareCafeException( * self, int status, str _METHOD, * unsigned int handle = 0, pv_name: str = None): # <<<<<<<<<<<<<< @@ -35960,7 +36408,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_prepareCafeException(struct __pyx_obj_6 } __Pyx_INCREF(__pyx_v_pv_name); - /* "PyCafe.pyx":324 + /* "PyCafe.pyx":323 * self, int status, str _METHOD, * unsigned int handle = 0, pv_name: str = None): * if handle > 0 and pv_name is None: # <<<<<<<<<<<<<< @@ -35979,19 +36427,19 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_prepareCafeException(struct __pyx_obj_6 __pyx_L4_bool_binop_done:; if (__pyx_t_1) { - /* "PyCafe.pyx":325 + /* "PyCafe.pyx":324 * unsigned int handle = 0, pv_name: str = None): * if handle > 0 and pv_name is None: * pv_name=self._c_cafe.getPVFromHandle(handle) # <<<<<<<<<<<<<< * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, */ - __pyx_t_4 = __Pyx_PyUnicode_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 325, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyUnicode_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_pv_name, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; - /* "PyCafe.pyx":324 + /* "PyCafe.pyx":323 * self, int status, str _METHOD, * unsigned int handle = 0, pv_name: str = None): * if handle > 0 and pv_name is None: # <<<<<<<<<<<<<< @@ -36000,65 +36448,65 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_prepareCafeException(struct __pyx_obj_6 */ } - /* "PyCafe.pyx":327 + /* "PyCafe.pyx":326 * pv_name=self._c_cafe.getPVFromHandle(handle) * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _error_code=status, _pv_name=pv_name, * _error_text=self.cs.code(status), _error_info=self.cs.info(status)) */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 327, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 327, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 327, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 327, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 326, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 326, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 327, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 326, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":328 + /* "PyCafe.pyx":327 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _error_code=status, _pv_name=pv_name, # <<<<<<<<<<<<<< * _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * return _cafeException */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 328, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 327, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 326, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_pv_name, __pyx_v_pv_name) < 0) __PYX_ERR(3, 327, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_pv_name, __pyx_v_pv_name) < 0) __PYX_ERR(3, 326, __pyx_L1_error) - /* "PyCafe.pyx":329 + /* "PyCafe.pyx":328 * _type='CafeError', _source=_METHOD, _handle=handle, * _error_code=status, _pv_name=pv_name, * _error_text=self.cs.code(status), _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * return _cafeException * */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 329, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 327, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 326, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 329, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 327, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 326, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":326 + /* "PyCafe.pyx":325 * if handle > 0 and pv_name is None: * pv_name=self._c_cafe.getPVFromHandle(handle) * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _error_code=status, _pv_name=pv_name, */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 326, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":330 + /* "PyCafe.pyx":329 * _error_code=status, _pv_name=pv_name, * _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * return _cafeException # <<<<<<<<<<<<<< @@ -36070,7 +36518,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_prepareCafeException(struct __pyx_obj_6 __pyx_r = ((PyObject *)__pyx_v__cafeException); goto __pyx_L0; - /* "PyCafe.pyx":321 + /* "PyCafe.pyx":320 * self._enable_exceptions = enable * * cdef prepareCafeException( # <<<<<<<<<<<<<< @@ -36094,7 +36542,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_prepareCafeException(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":334 +/* "PyCafe.pyx":333 * ############################################################################ * * def isValid(self, unsigned int handle): # <<<<<<<<<<<<<< @@ -36110,7 +36558,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_19isValid(PyObject *__pyx_v_self, PyOb __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("isValid (wrapper)", 0); assert(__pyx_arg_handle); { - __pyx_v_handle = __Pyx_PyInt_As_unsigned_int(__pyx_arg_handle); if (unlikely((__pyx_v_handle == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 334, __pyx_L3_error) + __pyx_v_handle = __Pyx_PyInt_As_unsigned_int(__pyx_arg_handle); if (unlikely((__pyx_v_handle == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 333, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -36131,7 +36579,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_18isValid(struct __pyx_obj_6PyCafe_CyC PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("isValid", 0); - /* "PyCafe.pyx":335 + /* "PyCafe.pyx":334 * * def isValid(self, unsigned int handle): * return self._c_cafe.isValid(handle) # <<<<<<<<<<<<<< @@ -36139,13 +36587,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_18isValid(struct __pyx_obj_6PyCafe_CyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->isValid(__pyx_v_handle)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 335, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->isValid(__pyx_v_handle)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":334 + /* "PyCafe.pyx":333 * ############################################################################ * * def isValid(self, unsigned int handle): # <<<<<<<<<<<<<< @@ -36166,7 +36614,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_18isValid(struct __pyx_obj_6PyCafe_CyC return __pyx_r; } -/* "PyCafe.pyx":339 +/* "PyCafe.pyx":338 * * ############################################################################ * def removeWidget(self, unsigned int handle, object widget): # <<<<<<<<<<<<<< @@ -36205,11 +36653,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_21removeWidget(PyObject *__pyx_v_self, case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_widget)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("removeWidget", 1, 2, 2, 1); __PYX_ERR(3, 339, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("removeWidget", 1, 2, 2, 1); __PYX_ERR(3, 338, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "removeWidget") < 0)) __PYX_ERR(3, 339, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "removeWidget") < 0)) __PYX_ERR(3, 338, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -36217,12 +36665,12 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_21removeWidget(PyObject *__pyx_v_self, values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } - __pyx_v_handle = __Pyx_PyInt_As_unsigned_int(values[0]); if (unlikely((__pyx_v_handle == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 339, __pyx_L3_error) + __pyx_v_handle = __Pyx_PyInt_As_unsigned_int(values[0]); if (unlikely((__pyx_v_handle == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 338, __pyx_L3_error) __pyx_v_widget = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("removeWidget", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 339, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("removeWidget", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 338, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.removeWidget", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -36241,7 +36689,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_20removeWidget(struct __pyx_obj_6PyCaf PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("removeWidget", 0); - /* "PyCafe.pyx":340 + /* "PyCafe.pyx":339 * ############################################################################ * def removeWidget(self, unsigned int handle, object widget): * return self.hh.removeWidget(handle, widget) # <<<<<<<<<<<<<< @@ -36249,13 +36697,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_20removeWidget(struct __pyx_obj_6PyCaf * def addWidget(self, unsigned int handle, object widget): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->hh.removeWidget(__pyx_v_handle, ((void *)__pyx_v_widget))); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 340, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->hh.removeWidget(__pyx_v_handle, ((void *)__pyx_v_widget))); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":339 + /* "PyCafe.pyx":338 * * ############################################################################ * def removeWidget(self, unsigned int handle, object widget): # <<<<<<<<<<<<<< @@ -36276,7 +36724,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_20removeWidget(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":342 +/* "PyCafe.pyx":341 * return self.hh.removeWidget(handle, widget) * * def addWidget(self, unsigned int handle, object widget): # <<<<<<<<<<<<<< @@ -36315,11 +36763,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_23addWidget(PyObject *__pyx_v_self, Py case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_widget)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("addWidget", 1, 2, 2, 1); __PYX_ERR(3, 342, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("addWidget", 1, 2, 2, 1); __PYX_ERR(3, 341, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "addWidget") < 0)) __PYX_ERR(3, 342, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "addWidget") < 0)) __PYX_ERR(3, 341, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -36327,12 +36775,12 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_23addWidget(PyObject *__pyx_v_self, Py values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } - __pyx_v_handle = __Pyx_PyInt_As_unsigned_int(values[0]); if (unlikely((__pyx_v_handle == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 342, __pyx_L3_error) + __pyx_v_handle = __Pyx_PyInt_As_unsigned_int(values[0]); if (unlikely((__pyx_v_handle == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 341, __pyx_L3_error) __pyx_v_widget = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("addWidget", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 342, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("addWidget", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 341, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.addWidget", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -36351,7 +36799,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_22addWidget(struct __pyx_obj_6PyCafe_C PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("addWidget", 0); - /* "PyCafe.pyx":343 + /* "PyCafe.pyx":342 * * def addWidget(self, unsigned int handle, object widget): * return self.hh.addWidget(handle, widget) # <<<<<<<<<<<<<< @@ -36359,13 +36807,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_22addWidget(struct __pyx_obj_6PyCafe_C * def getWidgets(self, unsigned int handle): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->hh.addWidget(__pyx_v_handle, ((void *)__pyx_v_widget))); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 343, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->hh.addWidget(__pyx_v_handle, ((void *)__pyx_v_widget))); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":342 + /* "PyCafe.pyx":341 * return self.hh.removeWidget(handle, widget) * * def addWidget(self, unsigned int handle, object widget): # <<<<<<<<<<<<<< @@ -36386,7 +36834,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_22addWidget(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":345 +/* "PyCafe.pyx":344 * return self.hh.addWidget(handle, widget) * * def getWidgets(self, unsigned int handle): # <<<<<<<<<<<<<< @@ -36402,7 +36850,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_25getWidgets(PyObject *__pyx_v_self, P __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getWidgets (wrapper)", 0); assert(__pyx_arg_handle); { - __pyx_v_handle = __Pyx_PyInt_As_unsigned_int(__pyx_arg_handle); if (unlikely((__pyx_v_handle == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 345, __pyx_L3_error) + __pyx_v_handle = __Pyx_PyInt_As_unsigned_int(__pyx_arg_handle); if (unlikely((__pyx_v_handle == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 344, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -36432,7 +36880,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_24getWidgets(struct __pyx_obj_6PyCafe_ int __pyx_t_6; __Pyx_RefNannySetupContext("getWidgets", 0); - /* "PyCafe.pyx":347 + /* "PyCafe.pyx":346 * def getWidgets(self, unsigned int handle): * cdef vector[void *] widgetV * widgetV.reserve(2) # <<<<<<<<<<<<<< @@ -36441,19 +36889,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_24getWidgets(struct __pyx_obj_6PyCafe_ */ __pyx_v_widgetV.reserve(2); - /* "PyCafe.pyx":348 + /* "PyCafe.pyx":347 * cdef vector[void *] widgetV * widgetV.reserve(2) * widgetList = [] # <<<<<<<<<<<<<< * status = self.hh.getWidgets(handle, widgetV) * for i in range(0, widgetV.size()): */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 348, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_widgetList = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":349 + /* "PyCafe.pyx":348 * widgetV.reserve(2) * widgetList = [] * status = self.hh.getWidgets(handle, widgetV) # <<<<<<<<<<<<<< @@ -36462,7 +36910,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_24getWidgets(struct __pyx_obj_6PyCafe_ */ __pyx_v_status = __pyx_v_self->hh.getWidgets(__pyx_v_handle, __pyx_v_widgetV); - /* "PyCafe.pyx":350 + /* "PyCafe.pyx":349 * widgetList = [] * status = self.hh.getWidgets(handle, widgetV) * for i in range(0, widgetV.size()): # <<<<<<<<<<<<<< @@ -36474,7 +36922,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_24getWidgets(struct __pyx_obj_6PyCafe_ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "PyCafe.pyx":351 + /* "PyCafe.pyx":350 * status = self.hh.getWidgets(handle, widgetV) * for i in range(0, widgetV.size()): * widgetList.append( < object > widgetV[i]) # <<<<<<<<<<<<<< @@ -36482,10 +36930,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_24getWidgets(struct __pyx_obj_6PyCafe_ * ############################################################################ */ __pyx_t_5 = (__pyx_v_widgetV[__pyx_v_i]); - __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_widgetList, ((PyObject *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(3, 351, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_widgetList, ((PyObject *)__pyx_t_5)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(3, 350, __pyx_L1_error) } - /* "PyCafe.pyx":352 + /* "PyCafe.pyx":351 * for i in range(0, widgetV.size()): * widgetList.append( < object > widgetV[i]) * return widgetList # <<<<<<<<<<<<<< @@ -36497,7 +36945,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_24getWidgets(struct __pyx_obj_6PyCafe_ __pyx_r = __pyx_v_widgetList; goto __pyx_L0; - /* "PyCafe.pyx":345 + /* "PyCafe.pyx":344 * return self.hh.addWidget(handle, widget) * * def getWidgets(self, unsigned int handle): # <<<<<<<<<<<<<< @@ -36519,7 +36967,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_24getWidgets(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":361 +/* "PyCafe.pyx":360 * * * def open(self, pv, cb: object = None): # <<<<<<<<<<<<<< @@ -36564,7 +37012,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_27open(PyObject *__pyx_v_self, PyObjec } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "open") < 0)) __PYX_ERR(3, 361, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "open") < 0)) __PYX_ERR(3, 360, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -36580,7 +37028,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_27open(PyObject *__pyx_v_self, PyObjec } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("open", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 361, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("open", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 360, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.open", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -36636,7 +37084,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe char const *__pyx_t_28; __Pyx_RefNannySetupContext("open", 0); - /* "PyCafe.pyx":402 + /* "PyCafe.pyx":401 * * """ * cdef str _METHOD = "open" # <<<<<<<<<<<<<< @@ -36646,7 +37094,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_n_u_open); __pyx_v__METHOD = __pyx_n_u_open; - /* "PyCafe.pyx":407 + /* "PyCafe.pyx":406 * cdef bytes py_string * * if isinstance(pv, (list)): # <<<<<<<<<<<<<< @@ -36657,51 +37105,51 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":408 + /* "PyCafe.pyx":407 * * if isinstance(pv, (list)): * for i in range(0, len(pv)): # <<<<<<<<<<<<<< * if isinstance(pv[i], str): * pvV.push_back(pv[i]) */ - __pyx_t_3 = PyObject_Length(__pyx_v_pv); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 408, __pyx_L1_error) + __pyx_t_3 = PyObject_Length(__pyx_v_pv); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 407, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":409 + /* "PyCafe.pyx":408 * if isinstance(pv, (list)): * for i in range(0, len(pv)): * if isinstance(pv[i], str): # <<<<<<<<<<<<<< * pvV.push_back(pv[i]) * elif isinstance(pv[i], bytes): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_pv, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 409, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_pv, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyUnicode_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":410 + /* "PyCafe.pyx":409 * for i in range(0, len(pv)): * if isinstance(pv[i], str): * pvV.push_back(pv[i]) # <<<<<<<<<<<<<< * elif isinstance(pv[i], bytes): * pvV.push_back(pv[i].decode('utf_8') ) */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_pv, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 410, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_pv, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __pyx_convert_string_from_py_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 410, __pyx_L1_error) + __pyx_t_7 = __pyx_convert_string_from_py_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 409, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_pvV.push_back(__pyx_t_7); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 410, __pyx_L1_error) + __PYX_ERR(3, 409, __pyx_L1_error) } - /* "PyCafe.pyx":409 + /* "PyCafe.pyx":408 * if isinstance(pv, (list)): * for i in range(0, len(pv)): * if isinstance(pv[i], str): # <<<<<<<<<<<<<< @@ -36711,30 +37159,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L6; } - /* "PyCafe.pyx":411 + /* "PyCafe.pyx":410 * if isinstance(pv[i], str): * pvV.push_back(pv[i]) * elif isinstance(pv[i], bytes): # <<<<<<<<<<<<<< * pvV.push_back(pv[i].decode('utf_8') ) * else: */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_pv, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 411, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_pv, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyBytes_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":412 + /* "PyCafe.pyx":411 * pvV.push_back(pv[i]) * elif isinstance(pv[i], bytes): * pvV.push_back(pv[i].decode('utf_8') ) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_pv, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 412, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_pv, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_decode); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 412, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_decode); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; @@ -36747,21 +37195,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_9, function); } } - __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_8, __pyx_n_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_n_u_utf_8); + __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_8, __pyx_n_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_n_u_utf_8_2); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 412, __pyx_L1_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_7 = __pyx_convert_string_from_py_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 412, __pyx_L1_error) + __pyx_t_7 = __pyx_convert_string_from_py_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 411, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_pvV.push_back(__pyx_t_7); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 412, __pyx_L1_error) + __PYX_ERR(3, 411, __pyx_L1_error) } - /* "PyCafe.pyx":411 + /* "PyCafe.pyx":410 * if isinstance(pv[i], str): * pvV.push_back(pv[i]) * elif isinstance(pv[i], bytes): # <<<<<<<<<<<<<< @@ -36771,7 +37219,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L6; } - /* "PyCafe.pyx":414 + /* "PyCafe.pyx":413 * pvV.push_back(pv[i].decode('utf_8') ) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -36779,10 +37227,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe * ("The pv name entered within list should be " */ /*else*/ { - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 414, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - /* "PyCafe.pyx":415 + /* "PyCafe.pyx":414 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -36804,7 +37252,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_The_pv_name_entered_within_list}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 414, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 413, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else @@ -36812,13 +37260,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_The_pv_name_entered_within_list}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 414, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 413, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { - __pyx_t_11 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 414, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -36832,30 +37280,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_kp_u_The_pv_name_entered_within_list); __Pyx_GIVEREF(__pyx_kp_u_The_pv_name_entered_within_list); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_kp_u_The_pv_name_entered_within_list); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 414, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":414 + /* "PyCafe.pyx":413 * pvV.push_back(pv[i].decode('utf_8') ) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("The pv name entered within list should be " */ - __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 414, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_9, 0, 0, 0); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __PYX_ERR(3, 414, __pyx_L1_error) + __PYX_ERR(3, 413, __pyx_L1_error) } __pyx_L6:; } - /* "PyCafe.pyx":418 + /* "PyCafe.pyx":417 * ("The pv name entered within list should be " * "of type or "))) * try: # <<<<<<<<<<<<<< @@ -36871,7 +37319,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":419 + /* "PyCafe.pyx":418 * "of type or "))) * try: * if cb is not None: # <<<<<<<<<<<<<< @@ -36882,7 +37330,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":421 + /* "PyCafe.pyx":420 * if cb is not None: * * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(True) # <<<<<<<<<<<<<< @@ -36891,7 +37339,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->channelCreatePolicy.setPyCallbackFlag(1); - /* "PyCafe.pyx":422 + /* "PyCafe.pyx":421 * * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(True) * self._c_cafe.channelCreatePolicy.setPyConnectHandler(cb) # <<<<<<<<<<<<<< @@ -36900,7 +37348,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->channelCreatePolicy.setPyConnectHandler(((void *)__pyx_v_cb)); - /* "PyCafe.pyx":419 + /* "PyCafe.pyx":418 * "of type or "))) * try: * if cb is not None: # <<<<<<<<<<<<<< @@ -36909,7 +37357,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":425 + /* "PyCafe.pyx":424 * * IF PY_EXT_C: * with nogil: # <<<<<<<<<<<<<< @@ -36924,7 +37372,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":426 + /* "PyCafe.pyx":425 * IF PY_EXT_C: * with nogil: * status = self._c_cafe.openV(pvV, handleV) # <<<<<<<<<<<<<< @@ -36941,12 +37389,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif - __PYX_ERR(3, 426, __pyx_L15_error) + __PYX_ERR(3, 425, __pyx_L15_error) } __pyx_v_status = __pyx_t_10; } - /* "PyCafe.pyx":425 + /* "PyCafe.pyx":424 * * IF PY_EXT_C: * with nogil: # <<<<<<<<<<<<<< @@ -36972,16 +37420,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":431 + /* "PyCafe.pyx":430 * #with nogil: * status = self._c_cafe.openV(pvV, handleV) * if not self.initCallbackComplete(handleV): # <<<<<<<<<<<<<< * time.sleep(0.2) * else: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_initCallbackComplete); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 431, __pyx_L7_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_initCallbackComplete); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 430, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_handleV); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 431, __pyx_L7_error) + __pyx_t_11 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_handleV); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 430, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -36996,24 +37444,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_11) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_11); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 431, __pyx_L7_error) + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 430, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 431, __pyx_L7_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 430, __pyx_L7_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_2 = ((!__pyx_t_1) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":432 + /* "PyCafe.pyx":431 * status = self._c_cafe.openV(pvV, handleV) * if not self.initCallbackComplete(handleV): * time.sleep(0.2) # <<<<<<<<<<<<<< * else: * time.sleep(0.02) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 432, __pyx_L7_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 431, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_sleep); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 432, __pyx_L7_error) + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_sleep); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 431, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -37028,12 +37476,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe } __pyx_t_9 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_6, __pyx_float_0_2) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_float_0_2); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 432, __pyx_L7_error) + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 431, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":431 + /* "PyCafe.pyx":430 * #with nogil: * status = self._c_cafe.openV(pvV, handleV) * if not self.initCallbackComplete(handleV): # <<<<<<<<<<<<<< @@ -37043,7 +37491,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L17; } - /* "PyCafe.pyx":434 + /* "PyCafe.pyx":433 * time.sleep(0.2) * else: * time.sleep(0.02) # <<<<<<<<<<<<<< @@ -37051,9 +37499,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe * # Reset */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_time); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 434, __pyx_L7_error) + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_time); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 433, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sleep); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 434, __pyx_L7_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sleep); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 433, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_11 = NULL; @@ -37068,14 +37516,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe } __pyx_t_9 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_11, __pyx_float_0_02) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_float_0_02); __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 434, __pyx_L7_error) + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 433, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_L17:; - /* "PyCafe.pyx":418 + /* "PyCafe.pyx":417 * ("The pv name entered within list should be " * "of type or "))) * try: # <<<<<<<<<<<<<< @@ -37093,7 +37541,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":435 + /* "PyCafe.pyx":434 * else: * time.sleep(0.02) * except RuntimeError as e: # <<<<<<<<<<<<<< @@ -37103,7 +37551,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_RuntimeError); if (__pyx_t_10) { __Pyx_AddTraceback("PyCafe.CyCafe.open", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_6, &__pyx_t_11) < 0) __PYX_ERR(3, 435, __pyx_L9_except_error) + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_6, &__pyx_t_11) < 0) __PYX_ERR(3, 434, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_11); @@ -37111,7 +37559,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_e = __pyx_t_6; /*try:*/ { - /* "PyCafe.pyx":437 + /* "PyCafe.pyx":436 * except RuntimeError as e: * # Reset * if cb is not None: # <<<<<<<<<<<<<< @@ -37122,7 +37570,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":438 + /* "PyCafe.pyx":437 * # Reset * if cb is not None: * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) # <<<<<<<<<<<<<< @@ -37131,7 +37579,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->channelCreatePolicy.setPyCallbackFlag(0); - /* "PyCafe.pyx":437 + /* "PyCafe.pyx":436 * except RuntimeError as e: * # Reset * if cb is not None: # <<<<<<<<<<<<<< @@ -37140,50 +37588,50 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":440 + /* "PyCafe.pyx":439 * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) * * if isinstance(e.args, (tuple)): # <<<<<<<<<<<<<< * # equivalent to e.what() * if 'CAFEException' in (e.args[0]): */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 440, __pyx_L23_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 439, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = PyTuple_Check(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":442 + /* "PyCafe.pyx":441 * if isinstance(e.args, (tuple)): * # equivalent to e.what() * if 'CAFEException' in (e.args[0]): # <<<<<<<<<<<<<< * errors = e.args[0].split(",") * if len(errors) > 5: */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 442, __pyx_L23_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 441, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 442, __pyx_L23_error) + __pyx_t_15 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 441, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_CAFEException, __pyx_t_15, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 442, __pyx_L23_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_CAFEException, __pyx_t_15, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 441, __pyx_L23_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":443 + /* "PyCafe.pyx":442 * # equivalent to e.what() * if 'CAFEException' in (e.args[0]): * errors = e.args[0].split(",") # <<<<<<<<<<<<<< * if len(errors) > 5: * _cafeException = CafeException( */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 443, __pyx_L23_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 442, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_16 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 443, __pyx_L23_error) + __pyx_t_16 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 442, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_16, __pyx_n_s_split); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 443, __pyx_L23_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_16, __pyx_n_s_split); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 442, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = NULL; @@ -37198,99 +37646,99 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe } __pyx_t_15 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_16, __pyx_kp_u__38) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_kp_u__38); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 443, __pyx_L23_error) + if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 442, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_errors = __pyx_t_15; __pyx_t_15 = 0; - /* "PyCafe.pyx":444 + /* "PyCafe.pyx":443 * if 'CAFEException' in (e.args[0]): * errors = e.args[0].split(",") * if len(errors) > 5: # <<<<<<<<<<<<<< * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, */ - __pyx_t_3 = PyObject_Length(__pyx_v_errors); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 444, __pyx_L23_error) + __pyx_t_3 = PyObject_Length(__pyx_v_errors); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 443, __pyx_L23_error) __pyx_t_1 = ((__pyx_t_3 > 5) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":446 + /* "PyCafe.pyx":445 * if len(errors) > 5: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _pv_name=errors[1], _handle=int(errors[2]), * _error_code=int(errors[3]), */ - __pyx_t_15 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 446, __pyx_L23_error) + __pyx_t_15 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 445, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_15); - if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 446, __pyx_L23_error) - if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 446, __pyx_L23_error) + if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 445, __pyx_L23_error) + if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 445, __pyx_L23_error) - /* "PyCafe.pyx":447 + /* "PyCafe.pyx":446 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, * _pv_name=errors[1], _handle=int(errors[2]), # <<<<<<<<<<<<<< * _error_code=int(errors[3]), * _error_text=errors[4], _error_info=errors[5]) */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_errors, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 447, __pyx_L23_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_errors, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 446, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_pv_name, __pyx_t_8) < 0) __PYX_ERR(3, 446, __pyx_L23_error) + if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_pv_name, __pyx_t_8) < 0) __PYX_ERR(3, 445, __pyx_L23_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_errors, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 447, __pyx_L23_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_errors, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 446, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_16 = __Pyx_PyNumber_Int(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 447, __pyx_L23_error) + __pyx_t_16 = __Pyx_PyNumber_Int(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 446, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_handle, __pyx_t_16) < 0) __PYX_ERR(3, 446, __pyx_L23_error) + if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_handle, __pyx_t_16) < 0) __PYX_ERR(3, 445, __pyx_L23_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - /* "PyCafe.pyx":448 + /* "PyCafe.pyx":447 * _type='CafeError', _source=_METHOD, * _pv_name=errors[1], _handle=int(errors[2]), * _error_code=int(errors[3]), # <<<<<<<<<<<<<< * _error_text=errors[4], _error_info=errors[5]) * raise _cafeException */ - __pyx_t_16 = __Pyx_GetItemInt(__pyx_v_errors, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 448, __pyx_L23_error) + __pyx_t_16 = __Pyx_GetItemInt(__pyx_v_errors, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 447, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_8 = __Pyx_PyNumber_Int(__pyx_t_16); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 448, __pyx_L23_error) + __pyx_t_8 = __Pyx_PyNumber_Int(__pyx_t_16); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 447, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_error_code, __pyx_t_8) < 0) __PYX_ERR(3, 446, __pyx_L23_error) + if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_error_code, __pyx_t_8) < 0) __PYX_ERR(3, 445, __pyx_L23_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":449 + /* "PyCafe.pyx":448 * _pv_name=errors[1], _handle=int(errors[2]), * _error_code=int(errors[3]), * _error_text=errors[4], _error_info=errors[5]) # <<<<<<<<<<<<<< * raise _cafeException * raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e)) */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_errors, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 449, __pyx_L23_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_errors, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 448, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_error_text, __pyx_t_8) < 0) __PYX_ERR(3, 446, __pyx_L23_error) + if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_error_text, __pyx_t_8) < 0) __PYX_ERR(3, 445, __pyx_L23_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_errors, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 449, __pyx_L23_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_errors, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 448, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_error_info, __pyx_t_8) < 0) __PYX_ERR(3, 446, __pyx_L23_error) + if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_error_info, __pyx_t_8) < 0) __PYX_ERR(3, 445, __pyx_L23_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":445 + /* "PyCafe.pyx":444 * errors = e.args[0].split(",") * if len(errors) > 5: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _pv_name=errors[1], _handle=int(errors[2]), */ - __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_15); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 445, __pyx_L23_error) + __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_15); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 444, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":450 + /* "PyCafe.pyx":449 * _error_code=int(errors[3]), * _error_text=errors[4], _error_info=errors[5]) * raise _cafeException # <<<<<<<<<<<<<< @@ -37298,9 +37746,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 450, __pyx_L23_error) + __PYX_ERR(3, 449, __pyx_L23_error) - /* "PyCafe.pyx":444 + /* "PyCafe.pyx":443 * if 'CAFEException' in (e.args[0]): * errors = e.args[0].split(",") * if len(errors) > 5: # <<<<<<<<<<<<<< @@ -37309,7 +37757,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":442 + /* "PyCafe.pyx":441 * if isinstance(e.args, (tuple)): * # equivalent to e.what() * if 'CAFEException' in (e.args[0]): # <<<<<<<<<<<<<< @@ -37318,7 +37766,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":440 + /* "PyCafe.pyx":439 * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) * * if isinstance(e.args, (tuple)): # <<<<<<<<<<<<<< @@ -37327,14 +37775,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":451 + /* "PyCafe.pyx":450 * _error_text=errors[4], _error_info=errors[5]) * raise _cafeException * raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e)) # <<<<<<<<<<<<<< * * if cb is not None: */ - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 451, __pyx_L23_error) + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 450, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = NULL; __pyx_t_10 = 0; @@ -37351,7 +37799,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_15)) { PyObject *__pyx_temp[4] = {__pyx_t_16, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_v_e}; - __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 451, __pyx_L23_error) + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 450, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_GOTREF(__pyx_t_8); } else @@ -37359,13 +37807,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_15)) { PyObject *__pyx_temp[4] = {__pyx_t_16, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_v_e}; - __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 451, __pyx_L23_error) + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 450, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_GOTREF(__pyx_t_8); } else #endif { - __pyx_t_17 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 451, __pyx_L23_error) + __pyx_t_17 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 450, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_17); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_16); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_16); __pyx_t_16 = NULL; @@ -37379,20 +37827,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_v_e); __Pyx_GIVEREF(__pyx_v_e); PyTuple_SET_ITEM(__pyx_t_17, 2+__pyx_t_10, __pyx_v_e); - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_17, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 451, __pyx_L23_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_17, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 450, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __pyx_t_15 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_8); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 451, __pyx_L23_error) + __pyx_t_15 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_8); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 450, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_15, 0, 0, 0); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __PYX_ERR(3, 451, __pyx_L23_error) + __PYX_ERR(3, 450, __pyx_L23_error) } - /* "PyCafe.pyx":435 + /* "PyCafe.pyx":434 * else: * time.sleep(0.02) * except RuntimeError as e: # <<<<<<<<<<<<<< @@ -37451,7 +37899,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L9_except_error; __pyx_L9_except_error:; - /* "PyCafe.pyx":418 + /* "PyCafe.pyx":417 * ("The pv name entered within list should be " * "of type or "))) * try: # <<<<<<<<<<<<<< @@ -37471,7 +37919,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_L12_try_end:; } - /* "PyCafe.pyx":453 + /* "PyCafe.pyx":452 * raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e)) * * if cb is not None: # <<<<<<<<<<<<<< @@ -37482,7 +37930,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":455 + /* "PyCafe.pyx":454 * if cb is not None: * # Reset * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) # <<<<<<<<<<<<<< @@ -37491,7 +37939,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->channelCreatePolicy.setPyCallbackFlag(0); - /* "PyCafe.pyx":453 + /* "PyCafe.pyx":452 * raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e)) * * if cb is not None: # <<<<<<<<<<<<<< @@ -37500,7 +37948,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":456 + /* "PyCafe.pyx":455 * # Reset * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) * return handleV # <<<<<<<<<<<<<< @@ -37508,13 +37956,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe * elif not isinstance(pv, (bytes, str)): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_11 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_handleV); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 456, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_handleV); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_r = __pyx_t_11; __pyx_t_11 = 0; goto __pyx_L0; - /* "PyCafe.pyx":407 + /* "PyCafe.pyx":406 * cdef bytes py_string * * if isinstance(pv, (list)): # <<<<<<<<<<<<<< @@ -37524,7 +37972,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L3; } - /* "PyCafe.pyx":458 + /* "PyCafe.pyx":457 * return handleV * * elif not isinstance(pv, (bytes, str)): # <<<<<<<<<<<<<< @@ -37545,17 +37993,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":459 + /* "PyCafe.pyx":458 * * elif not isinstance(pv, (bytes, str)): * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "Input argument, pv, should be of type ")) */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 459, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":460 + /* "PyCafe.pyx":459 * elif not isinstance(pv, (bytes, str)): * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -37577,7 +38025,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Input_argument_pv_should_be_of_t}; - __pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 459, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 458, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_11); } else @@ -37585,13 +38033,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Input_argument_pv_should_be_of_t}; - __pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 459, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 458, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_11); } else #endif { - __pyx_t_15 = PyTuple_New(3+__pyx_t_18); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 459, __pyx_L1_error) + __pyx_t_15 = PyTuple_New(3+__pyx_t_18); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_9); __pyx_t_9 = NULL; @@ -37605,27 +38053,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_kp_u_Input_argument_pv_should_be_of_t); __Pyx_GIVEREF(__pyx_kp_u_Input_argument_pv_should_be_of_t); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_18, __pyx_kp_u_Input_argument_pv_should_be_of_t); - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 459, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":459 + /* "PyCafe.pyx":458 * * elif not isinstance(pv, (bytes, str)): * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "Input argument, pv, should be of type ")) */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 459, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 459, __pyx_L1_error) + __PYX_ERR(3, 458, __pyx_L1_error) - /* "PyCafe.pyx":458 + /* "PyCafe.pyx":457 * return handleV * * elif not isinstance(pv, (bytes, str)): # <<<<<<<<<<<<<< @@ -37635,7 +38083,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L3:; - /* "PyCafe.pyx":463 + /* "PyCafe.pyx":462 * "Input argument, pv, should be of type ")) * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -37644,17 +38092,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_handle = 0; - /* "PyCafe.pyx":466 + /* "PyCafe.pyx":465 * cdef vector[string] vecS * * cdef char * pvStr = pv # <<<<<<<<<<<<<< * * if cb is not None: */ - __pyx_t_27 = __Pyx_PyObject_AsWritableString(__pyx_v_pv); if (unlikely((!__pyx_t_27) && PyErr_Occurred())) __PYX_ERR(3, 466, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyObject_AsWritableString(__pyx_v_pv); if (unlikely((!__pyx_t_27) && PyErr_Occurred())) __PYX_ERR(3, 465, __pyx_L1_error) __pyx_v_pvStr = __pyx_t_27; - /* "PyCafe.pyx":468 + /* "PyCafe.pyx":467 * cdef char * pvStr = pv * * if cb is not None: # <<<<<<<<<<<<<< @@ -37665,7 +38113,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":470 + /* "PyCafe.pyx":469 * if cb is not None: * * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(True) # <<<<<<<<<<<<<< @@ -37674,7 +38122,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->channelCreatePolicy.setPyCallbackFlag(1); - /* "PyCafe.pyx":471 + /* "PyCafe.pyx":470 * * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(True) * self._c_cafe.channelCreatePolicy.setPyConnectHandler(cb) # <<<<<<<<<<<<<< @@ -37683,7 +38131,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->channelCreatePolicy.setPyConnectHandler(((void *)__pyx_v_cb)); - /* "PyCafe.pyx":468 + /* "PyCafe.pyx":467 * cdef char * pvStr = pv * * if cb is not None: # <<<<<<<<<<<<<< @@ -37692,7 +38140,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":472 + /* "PyCafe.pyx":471 * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(True) * self._c_cafe.channelCreatePolicy.setPyConnectHandler(cb) * try: # <<<<<<<<<<<<<< @@ -37708,7 +38156,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "PyCafe.pyx":475 + /* "PyCafe.pyx":474 * IF PY_EXT_C: * #print("OPEN WITH NO GIL==>", pvStr) * with nogil: # <<<<<<<<<<<<<< @@ -37723,7 +38171,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":476 + /* "PyCafe.pyx":475 * #print("OPEN WITH NO GIL==>", pvStr) * with nogil: * self._c_cafe.open(pvStr, handle) # <<<<<<<<<<<<<< @@ -37740,11 +38188,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif - __PYX_ERR(3, 476, __pyx_L44_error) + __PYX_ERR(3, 475, __pyx_L44_error) } } - /* "PyCafe.pyx":475 + /* "PyCafe.pyx":474 * IF PY_EXT_C: * #print("OPEN WITH NO GIL==>", pvStr) * with nogil: # <<<<<<<<<<<<<< @@ -37770,7 +38218,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":472 + /* "PyCafe.pyx":471 * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(True) * self._c_cafe.channelCreatePolicy.setPyConnectHandler(cb) * try: # <<<<<<<<<<<<<< @@ -37791,7 +38239,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":482 + /* "PyCafe.pyx":481 * #with nogil: * self._c_cafe.open(pvStr, handle) * except RuntimeError as e: # <<<<<<<<<<<<<< @@ -37801,7 +38249,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_18 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_RuntimeError); if (__pyx_t_18) { __Pyx_AddTraceback("PyCafe.CyCafe.open", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_11, &__pyx_t_15) < 0) __PYX_ERR(3, 482, __pyx_L39_except_error) + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_11, &__pyx_t_15) < 0) __PYX_ERR(3, 481, __pyx_L39_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_11); __Pyx_GOTREF(__pyx_t_15); @@ -37809,7 +38257,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_e = __pyx_t_11; /*try:*/ { - /* "PyCafe.pyx":484 + /* "PyCafe.pyx":483 * except RuntimeError as e: * # Reset * if cb is not None: # <<<<<<<<<<<<<< @@ -37820,7 +38268,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":485 + /* "PyCafe.pyx":484 * # Reset * if cb is not None: * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) # <<<<<<<<<<<<<< @@ -37829,7 +38277,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->channelCreatePolicy.setPyCallbackFlag(0); - /* "PyCafe.pyx":484 + /* "PyCafe.pyx":483 * except RuntimeError as e: * # Reset * if cb is not None: # <<<<<<<<<<<<<< @@ -37838,50 +38286,50 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":486 + /* "PyCafe.pyx":485 * if cb is not None: * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) * if isinstance(e.args, (tuple)): # <<<<<<<<<<<<<< * if 'CAFEException' in (e.args[0]): * errors = e.args[0].split(",") # from e.what() */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 486, __pyx_L51_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 485, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = PyTuple_Check(__pyx_t_9); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":487 + /* "PyCafe.pyx":486 * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) * if isinstance(e.args, (tuple)): * if 'CAFEException' in (e.args[0]): # <<<<<<<<<<<<<< * errors = e.args[0].split(",") # from e.what() * if len(errors) > 5: */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 487, __pyx_L51_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 486, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 487, __pyx_L51_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 486, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_CAFEException, __pyx_t_8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 487, __pyx_L51_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_CAFEException, __pyx_t_8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 486, __pyx_L51_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":488 + /* "PyCafe.pyx":487 * if isinstance(e.args, (tuple)): * if 'CAFEException' in (e.args[0]): * errors = e.args[0].split(",") # from e.what() # <<<<<<<<<<<<<< * if len(errors) > 5: * _cafeException = CafeException( */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 488, __pyx_L51_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_args); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 487, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_17 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 488, __pyx_L51_error) + __pyx_t_17 = __Pyx_GetItemInt(__pyx_t_9, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 487, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_17); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_split); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 488, __pyx_L51_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_split); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 487, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; __pyx_t_17 = NULL; @@ -37896,99 +38344,99 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe } __pyx_t_8 = (__pyx_t_17) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_17, __pyx_kp_u__38) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_kp_u__38); __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 488, __pyx_L51_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 487, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_errors = __pyx_t_8; __pyx_t_8 = 0; - /* "PyCafe.pyx":489 + /* "PyCafe.pyx":488 * if 'CAFEException' in (e.args[0]): * errors = e.args[0].split(",") # from e.what() * if len(errors) > 5: # <<<<<<<<<<<<<< * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, */ - __pyx_t_3 = PyObject_Length(__pyx_v_errors); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 489, __pyx_L51_error) + __pyx_t_3 = PyObject_Length(__pyx_v_errors); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 488, __pyx_L51_error) __pyx_t_1 = ((__pyx_t_3 > 5) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":491 + /* "PyCafe.pyx":490 * if len(errors) > 5: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _pv_name=errors[1], * _handle=int(errors[2]), _error_code=int(errors[3]), */ - __pyx_t_8 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 491, __pyx_L51_error) + __pyx_t_8 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 490, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 491, __pyx_L51_error) - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 491, __pyx_L51_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 490, __pyx_L51_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 490, __pyx_L51_error) - /* "PyCafe.pyx":492 + /* "PyCafe.pyx":491 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, * _pv_name=errors[1], # <<<<<<<<<<<<<< * _handle=int(errors[2]), _error_code=int(errors[3]), * _error_text=errors[4], _error_info=errors[5]) */ - __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_errors, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 492, __pyx_L51_error) + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_errors, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 491, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_pv_name, __pyx_t_9) < 0) __PYX_ERR(3, 491, __pyx_L51_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_pv_name, __pyx_t_9) < 0) __PYX_ERR(3, 490, __pyx_L51_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":493 + /* "PyCafe.pyx":492 * _type='CafeError', _source=_METHOD, * _pv_name=errors[1], * _handle=int(errors[2]), _error_code=int(errors[3]), # <<<<<<<<<<<<<< * _error_text=errors[4], _error_info=errors[5]) * raise _cafeException */ - __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_errors, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 493, __pyx_L51_error) + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_errors, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 492, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_17 = __Pyx_PyNumber_Int(__pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 493, __pyx_L51_error) + __pyx_t_17 = __Pyx_PyNumber_Int(__pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 492, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_17); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_handle, __pyx_t_17) < 0) __PYX_ERR(3, 491, __pyx_L51_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_handle, __pyx_t_17) < 0) __PYX_ERR(3, 490, __pyx_L51_error) __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __pyx_t_17 = __Pyx_GetItemInt(__pyx_v_errors, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 493, __pyx_L51_error) + __pyx_t_17 = __Pyx_GetItemInt(__pyx_v_errors, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 492, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_17); - __pyx_t_9 = __Pyx_PyNumber_Int(__pyx_t_17); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 493, __pyx_L51_error) + __pyx_t_9 = __Pyx_PyNumber_Int(__pyx_t_17); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 492, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_error_code, __pyx_t_9) < 0) __PYX_ERR(3, 491, __pyx_L51_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_error_code, __pyx_t_9) < 0) __PYX_ERR(3, 490, __pyx_L51_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":494 + /* "PyCafe.pyx":493 * _pv_name=errors[1], * _handle=int(errors[2]), _error_code=int(errors[3]), * _error_text=errors[4], _error_info=errors[5]) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_errors, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 494, __pyx_L51_error) + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_errors, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 493, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_error_text, __pyx_t_9) < 0) __PYX_ERR(3, 491, __pyx_L51_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_error_text, __pyx_t_9) < 0) __PYX_ERR(3, 490, __pyx_L51_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_errors, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 494, __pyx_L51_error) + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_errors, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 493, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_error_info, __pyx_t_9) < 0) __PYX_ERR(3, 491, __pyx_L51_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_error_info, __pyx_t_9) < 0) __PYX_ERR(3, 490, __pyx_L51_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":490 + /* "PyCafe.pyx":489 * errors = e.args[0].split(",") # from e.what() * if len(errors) > 5: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _pv_name=errors[1], */ - __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 490, __pyx_L51_error) + __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 489, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":495 + /* "PyCafe.pyx":494 * _handle=int(errors[2]), _error_code=int(errors[3]), * _error_text=errors[4], _error_info=errors[5]) * raise _cafeException # <<<<<<<<<<<<<< @@ -37996,9 +38444,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe * raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e)) */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 495, __pyx_L51_error) + __PYX_ERR(3, 494, __pyx_L51_error) - /* "PyCafe.pyx":489 + /* "PyCafe.pyx":488 * if 'CAFEException' in (e.args[0]): * errors = e.args[0].split(",") # from e.what() * if len(errors) > 5: # <<<<<<<<<<<<<< @@ -38007,7 +38455,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":487 + /* "PyCafe.pyx":486 * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) * if isinstance(e.args, (tuple)): * if 'CAFEException' in (e.args[0]): # <<<<<<<<<<<<<< @@ -38016,7 +38464,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":486 + /* "PyCafe.pyx":485 * if cb is not None: * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) * if isinstance(e.args, (tuple)): # <<<<<<<<<<<<<< @@ -38025,14 +38473,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":497 + /* "PyCafe.pyx":496 * raise _cafeException * * raise Exception("{} {} \n{}".format(self._exception_text, _METHOD, e)) # <<<<<<<<<<<<<< * * # Reset */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 497, __pyx_L51_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 496, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_17 = NULL; __pyx_t_18 = 0; @@ -38049,7 +38497,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[4] = {__pyx_t_17, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_v_e}; - __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 497, __pyx_L51_error) + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 496, __pyx_L51_error) __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_GOTREF(__pyx_t_9); } else @@ -38057,13 +38505,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[4] = {__pyx_t_17, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_v_e}; - __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 497, __pyx_L51_error) + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_18, 3+__pyx_t_18); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 496, __pyx_L51_error) __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_GOTREF(__pyx_t_9); } else #endif { - __pyx_t_16 = PyTuple_New(3+__pyx_t_18); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 497, __pyx_L51_error) + __pyx_t_16 = PyTuple_New(3+__pyx_t_18); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 496, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_16); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_17); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_17); __pyx_t_17 = NULL; @@ -38077,20 +38525,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_v_e); __Pyx_GIVEREF(__pyx_v_e); PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_18, __pyx_v_e); - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_16, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 497, __pyx_L51_error) + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_16, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 496, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 497, __pyx_L51_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 496, __pyx_L51_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(3, 497, __pyx_L51_error) + __PYX_ERR(3, 496, __pyx_L51_error) } - /* "PyCafe.pyx":482 + /* "PyCafe.pyx":481 * #with nogil: * self._c_cafe.open(pvStr, handle) * except RuntimeError as e: # <<<<<<<<<<<<<< @@ -38149,7 +38597,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L39_except_error; __pyx_L39_except_error:; - /* "PyCafe.pyx":472 + /* "PyCafe.pyx":471 * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(True) * self._c_cafe.channelCreatePolicy.setPyConnectHandler(cb) * try: # <<<<<<<<<<<<<< @@ -38169,7 +38617,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_L42_try_end:; } - /* "PyCafe.pyx":500 + /* "PyCafe.pyx":499 * * # Reset * if cb is not None: # <<<<<<<<<<<<<< @@ -38180,7 +38628,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":501 + /* "PyCafe.pyx":500 * # Reset * if cb is not None: * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) # <<<<<<<<<<<<<< @@ -38189,7 +38637,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->channelCreatePolicy.setPyCallbackFlag(0); - /* "PyCafe.pyx":500 + /* "PyCafe.pyx":499 * * # Reset * if cb is not None: # <<<<<<<<<<<<<< @@ -38198,7 +38646,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":503 + /* "PyCafe.pyx":502 * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) * # A notch to allow for possible race condition * if not self._c_cafe.isChannelConnected(handle): # <<<<<<<<<<<<<< @@ -38208,16 +38656,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((!(__pyx_v_self->_c_cafe->isChannelConnected(__pyx_v_handle) != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":504 + /* "PyCafe.pyx":503 * # A notch to allow for possible race condition * if not self._c_cafe.isChannelConnected(handle): * time.sleep(0.1) # <<<<<<<<<<<<<< * else: * time.sleep(0.01) # Let pycallbacks complete */ - __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_time); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 504, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_time); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sleep); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 504, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sleep); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_11 = NULL; @@ -38232,12 +38680,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe } __pyx_t_15 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_11, __pyx_float_0_1) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_float_0_1); __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 504, __pyx_L1_error) + if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - /* "PyCafe.pyx":503 + /* "PyCafe.pyx":502 * self._c_cafe.channelCreatePolicy.setPyCallbackFlag(False) * # A notch to allow for possible race condition * if not self._c_cafe.isChannelConnected(handle): # <<<<<<<<<<<<<< @@ -38247,7 +38695,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L62; } - /* "PyCafe.pyx":506 + /* "PyCafe.pyx":505 * time.sleep(0.1) * else: * time.sleep(0.01) # Let pycallbacks complete # <<<<<<<<<<<<<< @@ -38255,9 +38703,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe * */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 506, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_sleep); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 506, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_sleep); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -38272,14 +38720,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe } __pyx_t_15 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_6, __pyx_float_0_01) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_float_0_01); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 506, __pyx_L1_error) + if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } __pyx_L62:; - /* "PyCafe.pyx":507 + /* "PyCafe.pyx":506 * else: * time.sleep(0.01) # Let pycallbacks complete * return handle # <<<<<<<<<<<<<< @@ -38287,13 +38735,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_15 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 507, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_r = __pyx_t_15; __pyx_t_15 = 0; goto __pyx_L0; - /* "PyCafe.pyx":361 + /* "PyCafe.pyx":360 * * * def open(self, pv, cb: object = None): # <<<<<<<<<<<<<< @@ -38324,7 +38772,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_26open(struct __pyx_obj_6PyCafe_CyCafe return __pyx_r; } -/* "PyCafe.pyx":510 +/* "PyCafe.pyx":509 * * ############################################################################ * def openNoWait(self): # <<<<<<<<<<<<<< @@ -38350,7 +38798,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_28openNoWait(struct __pyx_obj_6PyCafe_ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("openNoWait", 0); - /* "PyCafe.pyx":514 + /* "PyCafe.pyx":513 * # channelOpenPolicy.setWhenToFlushSendBuffer( * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: # <<<<<<<<<<<<<< @@ -38365,7 +38813,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_28openNoWait(struct __pyx_obj_6PyCafe_ #endif /*try:*/ { - /* "PyCafe.pyx":515 + /* "PyCafe.pyx":514 * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: * self._c_cafe.openNoWait() # <<<<<<<<<<<<<< @@ -38375,7 +38823,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_28openNoWait(struct __pyx_obj_6PyCafe_ __pyx_v_self->_c_cafe->openNoWait(); } - /* "PyCafe.pyx":514 + /* "PyCafe.pyx":513 * # channelOpenPolicy.setWhenToFlushSendBuffer( * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: # <<<<<<<<<<<<<< @@ -38394,7 +38842,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_28openNoWait(struct __pyx_obj_6PyCafe_ } } - /* "PyCafe.pyx":516 + /* "PyCafe.pyx":515 * with nogil: * self._c_cafe.openNoWait() * return # <<<<<<<<<<<<<< @@ -38405,7 +38853,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_28openNoWait(struct __pyx_obj_6PyCafe_ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":510 + /* "PyCafe.pyx":509 * * ############################################################################ * def openNoWait(self): # <<<<<<<<<<<<<< @@ -38421,7 +38869,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_28openNoWait(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":518 +/* "PyCafe.pyx":517 * return * * def openPrepare(self): # <<<<<<<<<<<<<< @@ -38447,7 +38895,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_30openPrepare(struct __pyx_obj_6PyCafe __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("openPrepare", 0); - /* "PyCafe.pyx":522 + /* "PyCafe.pyx":521 * # self._c_cafe.channelOpenPolicy.setWhenToFlushSendBuffer( * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: # <<<<<<<<<<<<<< @@ -38462,7 +38910,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_30openPrepare(struct __pyx_obj_6PyCafe #endif /*try:*/ { - /* "PyCafe.pyx":523 + /* "PyCafe.pyx":522 * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: * self._c_cafe.openPrepare() # <<<<<<<<<<<<<< @@ -38472,7 +38920,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_30openPrepare(struct __pyx_obj_6PyCafe __pyx_v_self->_c_cafe->openPrepare(); } - /* "PyCafe.pyx":522 + /* "PyCafe.pyx":521 * # self._c_cafe.channelOpenPolicy.setWhenToFlushSendBuffer( * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: # <<<<<<<<<<<<<< @@ -38491,7 +38939,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_30openPrepare(struct __pyx_obj_6PyCafe } } - /* "PyCafe.pyx":518 + /* "PyCafe.pyx":517 * return * * def openPrepare(self): # <<<<<<<<<<<<<< @@ -38506,7 +38954,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_30openPrepare(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":525 +/* "PyCafe.pyx":524 * self._c_cafe.openPrepare() * * def openGroupPrepare(self): # <<<<<<<<<<<<<< @@ -38532,7 +38980,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_32openGroupPrepare(struct __pyx_obj_6P __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("openGroupPrepare", 0); - /* "PyCafe.pyx":530 + /* "PyCafe.pyx":529 * # self._c_cafe.channelOpenGroupPolicy.setWhenToFlushSendBuffer( * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: # <<<<<<<<<<<<<< @@ -38547,7 +38995,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_32openGroupPrepare(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":531 + /* "PyCafe.pyx":530 * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: * self._c_cafe.openGroupPrepare() # <<<<<<<<<<<<<< @@ -38557,7 +39005,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_32openGroupPrepare(struct __pyx_obj_6P __pyx_v_self->_c_cafe->openGroupPrepare(); } - /* "PyCafe.pyx":530 + /* "PyCafe.pyx":529 * # self._c_cafe.channelOpenGroupPolicy.setWhenToFlushSendBuffer( * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: # <<<<<<<<<<<<<< @@ -38576,7 +39024,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_32openGroupPrepare(struct __pyx_obj_6P } } - /* "PyCafe.pyx":525 + /* "PyCafe.pyx":524 * self._c_cafe.openPrepare() * * def openGroupPrepare(self): # <<<<<<<<<<<<<< @@ -38591,7 +39039,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_32openGroupPrepare(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":533 +/* "PyCafe.pyx":532 * self._c_cafe.openGroupPrepare() * * def setOpenDefaultPendTime(self, double timeout): # <<<<<<<<<<<<<< @@ -38607,7 +39055,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_35setOpenDefaultPendTime(PyObject *__p __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setOpenDefaultPendTime (wrapper)", 0); assert(__pyx_arg_timeout); { - __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 533, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 532, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -38628,7 +39076,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_34setOpenDefaultPendTime(struct __pyx_ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("setOpenDefaultPendTime", 0); - /* "PyCafe.pyx":534 + /* "PyCafe.pyx":533 * * def setOpenDefaultPendTime(self, double timeout): * return self._c_cafe.channelOpenPolicy.setDefaultTimeout(timeout) # <<<<<<<<<<<<<< @@ -38636,13 +39084,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_34setOpenDefaultPendTime(struct __pyx_ * def getOpenDefaultPendTime(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->_c_cafe->channelOpenPolicy.setDefaultTimeout(__pyx_v_timeout)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 534, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->_c_cafe->channelOpenPolicy.setDefaultTimeout(__pyx_v_timeout)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 533, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":533 + /* "PyCafe.pyx":532 * self._c_cafe.openGroupPrepare() * * def setOpenDefaultPendTime(self, double timeout): # <<<<<<<<<<<<<< @@ -38663,7 +39111,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_34setOpenDefaultPendTime(struct __pyx_ return __pyx_r; } -/* "PyCafe.pyx":536 +/* "PyCafe.pyx":535 * return self._c_cafe.channelOpenPolicy.setDefaultTimeout(timeout) * * def getOpenDefaultPendTime(self): # <<<<<<<<<<<<<< @@ -38690,7 +39138,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_36getOpenDefaultPendTime(struct __pyx_ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("getOpenDefaultPendTime", 0); - /* "PyCafe.pyx":537 + /* "PyCafe.pyx":536 * * def getOpenDefaultPendTime(self): * return self._c_cafe.channelOpenPolicy.getDefaultTimeout() # <<<<<<<<<<<<<< @@ -38698,13 +39146,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_36getOpenDefaultPendTime(struct __pyx_ * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->_c_cafe->channelOpenPolicy.getDefaultTimeout()); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 537, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->_c_cafe->channelOpenPolicy.getDefaultTimeout()); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":536 + /* "PyCafe.pyx":535 * return self._c_cafe.channelOpenPolicy.setDefaultTimeout(timeout) * * def getOpenDefaultPendTime(self): # <<<<<<<<<<<<<< @@ -38725,7 +39173,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_36getOpenDefaultPendTime(struct __pyx_ return __pyx_r; } -/* "PyCafe.pyx":541 +/* "PyCafe.pyx":540 * * ############################################################################ * def openNow(self): # <<<<<<<<<<<<<< @@ -38751,7 +39199,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_38openNow(struct __pyx_obj_6PyCafe_CyC __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("openNow", 0); - /* "PyCafe.pyx":545 + /* "PyCafe.pyx":544 * # self._c_cafe.channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW) * # self._c_cafe.channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT) * with nogil: # <<<<<<<<<<<<<< @@ -38766,7 +39214,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_38openNow(struct __pyx_obj_6PyCafe_CyC #endif /*try:*/ { - /* "PyCafe.pyx":546 + /* "PyCafe.pyx":545 * # self._c_cafe.channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT) * with nogil: * self._c_cafe.openNow() # <<<<<<<<<<<<<< @@ -38776,7 +39224,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_38openNow(struct __pyx_obj_6PyCafe_CyC __pyx_v_self->_c_cafe->openNow(); } - /* "PyCafe.pyx":545 + /* "PyCafe.pyx":544 * # self._c_cafe.channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW) * # self._c_cafe.channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT) * with nogil: # <<<<<<<<<<<<<< @@ -38795,7 +39243,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_38openNow(struct __pyx_obj_6PyCafe_CyC } } - /* "PyCafe.pyx":541 + /* "PyCafe.pyx":540 * * ############################################################################ * def openNow(self): # <<<<<<<<<<<<<< @@ -38810,7 +39258,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_38openNow(struct __pyx_obj_6PyCafe_CyC return __pyx_r; } -/* "PyCafe.pyx":550 +/* "PyCafe.pyx":549 * ############################################################################# * * def openNowAndWait(self, double timeout=0, handlesPV=None): # <<<<<<<<<<<<<< @@ -38856,7 +39304,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_41openNowAndWait(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "openNowAndWait") < 0)) __PYX_ERR(3, 550, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "openNowAndWait") < 0)) __PYX_ERR(3, 549, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -38869,7 +39317,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_41openNowAndWait(PyObject *__pyx_v_sel } } if (values[0]) { - __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 550, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 549, __pyx_L3_error) } else { __pyx_v_timeout = ((double)0.0); } @@ -38877,7 +39325,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_41openNowAndWait(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("openNowAndWait", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 550, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("openNowAndWait", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 549, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.openNowAndWait", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -38912,7 +39360,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC int __pyx_t_12; __Pyx_RefNannySetupContext("openNowAndWait", 0); - /* "PyCafe.pyx":551 + /* "PyCafe.pyx":550 * * def openNowAndWait(self, double timeout=0, handlesPV=None): * cdef str _METHOD = "openNowAndWait" # <<<<<<<<<<<<<< @@ -38922,7 +39370,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_openNowAndWait); __pyx_v__METHOD = __pyx_n_u_openNowAndWait; - /* "PyCafe.pyx":553 + /* "PyCafe.pyx":552 * cdef str _METHOD = "openNowAndWait" * * if timeout <=0 : # <<<<<<<<<<<<<< @@ -38932,7 +39380,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_t_1 = ((__pyx_v_timeout <= 0.0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":554 + /* "PyCafe.pyx":553 * * if timeout <=0 : * timeout = self._c_cafe.channelOpenPolicy.getTimeout() # <<<<<<<<<<<<<< @@ -38941,7 +39389,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC */ __pyx_v_timeout = __pyx_v_self->_c_cafe->channelOpenPolicy.getTimeout(); - /* "PyCafe.pyx":553 + /* "PyCafe.pyx":552 * cdef str _METHOD = "openNowAndWait" * * if timeout <=0 : # <<<<<<<<<<<<<< @@ -38950,7 +39398,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":565 + /* "PyCafe.pyx":564 * cdef vector[unsigned int] hList * cdef vector[string] pvV * cdef npoll = 0 # <<<<<<<<<<<<<< @@ -38960,7 +39408,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_int_0); __pyx_v_npoll = __pyx_int_0; - /* "PyCafe.pyx":567 + /* "PyCafe.pyx":566 * cdef npoll = 0 * * if handlesPV is not None: # <<<<<<<<<<<<<< @@ -38971,7 +39419,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":568 + /* "PyCafe.pyx":567 * * if handlesPV is not None: * if isinstance(handlesPV, (list)): # <<<<<<<<<<<<<< @@ -38982,26 +39430,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":569 + /* "PyCafe.pyx":568 * if handlesPV is not None: * if isinstance(handlesPV, (list)): * for i in range(0, len(handlesPV)): # <<<<<<<<<<<<<< * if isinstance(handlesPV[i], (int, long)): * hList.push_back(handlesPV[i]) */ - __pyx_t_3 = PyObject_Length(__pyx_v_handlesPV); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 569, __pyx_L1_error) + __pyx_t_3 = PyObject_Length(__pyx_v_handlesPV); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 568, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":570 + /* "PyCafe.pyx":569 * if isinstance(handlesPV, (list)): * for i in range(0, len(handlesPV)): * if isinstance(handlesPV[i], (int, long)): # <<<<<<<<<<<<<< * hList.push_back(handlesPV[i]) * elif isinstance(handlesPV[i], (str)): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlesPV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 570, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlesPV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyInt_Check(__pyx_t_6); __pyx_t_7 = (__pyx_t_2 != 0); @@ -39018,25 +39466,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":571 + /* "PyCafe.pyx":570 * for i in range(0, len(handlesPV)): * if isinstance(handlesPV[i], (int, long)): * hList.push_back(handlesPV[i]) # <<<<<<<<<<<<<< * elif isinstance(handlesPV[i], (str)): * hList.push_back(self.getHandleFromPVName(handlesPV[i])) */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlesPV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 571, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlesPV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 570, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 571, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 570, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 571, __pyx_L1_error) + __PYX_ERR(3, 570, __pyx_L1_error) } - /* "PyCafe.pyx":570 + /* "PyCafe.pyx":569 * if isinstance(handlesPV, (list)): * for i in range(0, len(handlesPV)): * if isinstance(handlesPV[i], (int, long)): # <<<<<<<<<<<<<< @@ -39046,30 +39494,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC goto __pyx_L8; } - /* "PyCafe.pyx":572 + /* "PyCafe.pyx":571 * if isinstance(handlesPV[i], (int, long)): * hList.push_back(handlesPV[i]) * elif isinstance(handlesPV[i], (str)): # <<<<<<<<<<<<<< * hList.push_back(self.getHandleFromPVName(handlesPV[i])) * else: */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlesPV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 572, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlesPV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyUnicode_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":573 + /* "PyCafe.pyx":572 * hList.push_back(handlesPV[i]) * elif isinstance(handlesPV[i], (str)): * hList.push_back(self.getHandleFromPVName(handlesPV[i])) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandleFromPVName); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 573, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandleFromPVName); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_handlesPV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 573, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_handlesPV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { @@ -39084,19 +39532,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_t_6 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_11, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 573, __pyx_L1_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 573, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 572, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 573, __pyx_L1_error) + __PYX_ERR(3, 572, __pyx_L1_error) } - /* "PyCafe.pyx":572 + /* "PyCafe.pyx":571 * if isinstance(handlesPV[i], (int, long)): * hList.push_back(handlesPV[i]) * elif isinstance(handlesPV[i], (str)): # <<<<<<<<<<<<<< @@ -39106,7 +39554,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC goto __pyx_L8; } - /* "PyCafe.pyx":575 + /* "PyCafe.pyx":574 * hList.push_back(self.getHandleFromPVName(handlesPV[i])) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -39114,10 +39562,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC * ("List input arguments, should be < type 'int' >" + */ /*else*/ { - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 575, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - /* "PyCafe.pyx":576 + /* "PyCafe.pyx":575 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -39139,7 +39587,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_t}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 575, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 574, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_6); } else @@ -39147,13 +39595,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_t}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 575, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 574, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { - __pyx_t_11 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 575, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_10) { __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL; @@ -39167,30 +39615,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_List_input_arguments_should_be_t); __Pyx_GIVEREF(__pyx_kp_u_List_input_arguments_should_be_t); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_12, __pyx_kp_u_List_input_arguments_should_be_t); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 575, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":575 + /* "PyCafe.pyx":574 * hList.push_back(self.getHandleFromPVName(handlesPV[i])) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("List input arguments, should be < type 'int' >" + */ - __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 575, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_9, 0, 0, 0); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __PYX_ERR(3, 575, __pyx_L1_error) + __PYX_ERR(3, 574, __pyx_L1_error) } __pyx_L8:; } - /* "PyCafe.pyx":568 + /* "PyCafe.pyx":567 * * if handlesPV is not None: * if isinstance(handlesPV, (list)): # <<<<<<<<<<<<<< @@ -39200,7 +39648,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC goto __pyx_L5; } - /* "PyCafe.pyx":579 + /* "PyCafe.pyx":578 * ("List input arguments, should be < type 'int' >" + * "if handle, else < type 'str' > if pv name"))) * elif isinstance(handlesPV, (int, long)): # <<<<<<<<<<<<<< @@ -39221,22 +39669,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":580 + /* "PyCafe.pyx":579 * "if handle, else < type 'str' > if pv name"))) * elif isinstance(handlesPV, (int, long)): * hList.push_back(handlesPV) # <<<<<<<<<<<<<< * elif isinstance(handlesPV, (str)): * hList.push_back(self.getHandleFromPVName(handlesPV)) */ - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlesPV); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 580, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlesPV); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 579, __pyx_L1_error) try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 580, __pyx_L1_error) + __PYX_ERR(3, 579, __pyx_L1_error) } - /* "PyCafe.pyx":579 + /* "PyCafe.pyx":578 * ("List input arguments, should be < type 'int' >" + * "if handle, else < type 'str' > if pv name"))) * elif isinstance(handlesPV, (int, long)): # <<<<<<<<<<<<<< @@ -39246,7 +39694,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC goto __pyx_L5; } - /* "PyCafe.pyx":581 + /* "PyCafe.pyx":580 * elif isinstance(handlesPV, (int, long)): * hList.push_back(handlesPV) * elif isinstance(handlesPV, (str)): # <<<<<<<<<<<<<< @@ -39257,14 +39705,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":582 + /* "PyCafe.pyx":581 * hList.push_back(handlesPV) * elif isinstance(handlesPV, (str)): * hList.push_back(self.getHandleFromPVName(handlesPV)) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandleFromPVName); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 582, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandleFromPVName); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_11 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -39278,19 +39726,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC } __pyx_t_9 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_11, __pyx_v_handlesPV) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_handlesPV); __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 582, __pyx_L1_error) + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 582, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 581, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 582, __pyx_L1_error) + __PYX_ERR(3, 581, __pyx_L1_error) } - /* "PyCafe.pyx":581 + /* "PyCafe.pyx":580 * elif isinstance(handlesPV, (int, long)): * hList.push_back(handlesPV) * elif isinstance(handlesPV, (str)): # <<<<<<<<<<<<<< @@ -39300,7 +39748,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC goto __pyx_L5; } - /* "PyCafe.pyx":584 + /* "PyCafe.pyx":583 * hList.push_back(self.getHandleFromPVName(handlesPV)) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -39308,10 +39756,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC * "Input argument, should be of type if handle, \ */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 584, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":585 + /* "PyCafe.pyx":584 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -39333,7 +39781,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Input_argument_should_be_of_type}; - __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 584, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 583, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_9); } else @@ -39341,13 +39789,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Input_argument_should_be_of_type}; - __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 584, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 583, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_9); } else #endif { - __pyx_t_10 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 584, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_11) { __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11); __pyx_t_11 = NULL; @@ -39361,29 +39809,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_Input_argument_should_be_of_type); __Pyx_GIVEREF(__pyx_kp_u_Input_argument_should_be_of_type); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_12, __pyx_kp_u_Input_argument_should_be_of_type); - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 584, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":584 + /* "PyCafe.pyx":583 * hList.push_back(self.getHandleFromPVName(handlesPV)) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "Input argument, should be of type if handle, \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 584, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 584, __pyx_L1_error) + __PYX_ERR(3, 583, __pyx_L1_error) } __pyx_L5:; - /* "PyCafe.pyx":588 + /* "PyCafe.pyx":587 * "Input argument, should be of type if handle, \ * else if pv name")) * with nogil: # <<<<<<<<<<<<<< @@ -39398,7 +39846,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":589 + /* "PyCafe.pyx":588 * else if pv name")) * with nogil: * self._c_cafe.openNowAndWaitHandleV(hList, timeout) # <<<<<<<<<<<<<< @@ -39408,7 +39856,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_v_self->_c_cafe->openNowAndWaitHandleV(__pyx_v_hList, __pyx_v_timeout); } - /* "PyCafe.pyx":588 + /* "PyCafe.pyx":587 * "Input argument, should be of type if handle, \ * else if pv name")) * with nogil: # <<<<<<<<<<<<<< @@ -39427,7 +39875,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":591 + /* "PyCafe.pyx":590 * self._c_cafe.openNowAndWaitHandleV(hList, timeout) * # Did all callbacks complete? wait 50ms * for i in range(0, 100): # <<<<<<<<<<<<<< @@ -39437,7 +39885,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC for (__pyx_t_3 = 0; __pyx_t_3 < 0x64; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "PyCafe.pyx":592 + /* "PyCafe.pyx":591 * # Did all callbacks complete? wait 50ms * for i in range(0, 100): * if not self._c_cafe.initCallbackCompleteV(hList): # <<<<<<<<<<<<<< @@ -39447,16 +39895,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_self->_c_cafe->initCallbackCompleteV(__pyx_v_hList) != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":593 + /* "PyCafe.pyx":592 * for i in range(0, 100): * if not self._c_cafe.initCallbackCompleteV(hList): * time.sleep(0.001) # <<<<<<<<<<<<<< * npoll = npoll+1 * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_time); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 593, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_time); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_sleep); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 593, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_sleep); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; @@ -39471,24 +39919,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC } __pyx_t_6 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_9, __pyx_float_0_001) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_float_0_001); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 593, __pyx_L1_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":594 + /* "PyCafe.pyx":593 * if not self._c_cafe.initCallbackCompleteV(hList): * time.sleep(0.001) * npoll = npoll+1 # <<<<<<<<<<<<<< * else: * break */ - __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_v_npoll, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 594, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_v_npoll, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_npoll, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":592 + /* "PyCafe.pyx":591 * # Did all callbacks complete? wait 50ms * for i in range(0, 100): * if not self._c_cafe.initCallbackCompleteV(hList): # <<<<<<<<<<<<<< @@ -39498,7 +39946,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC goto __pyx_L18; } - /* "PyCafe.pyx":596 + /* "PyCafe.pyx":595 * npoll = npoll+1 * else: * break # <<<<<<<<<<<<<< @@ -39512,7 +39960,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC } __pyx_L17_break:; - /* "PyCafe.pyx":567 + /* "PyCafe.pyx":566 * cdef npoll = 0 * * if handlesPV is not None: # <<<<<<<<<<<<<< @@ -39522,7 +39970,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC goto __pyx_L4; } - /* "PyCafe.pyx":601 + /* "PyCafe.pyx":600 * * else: * with nogil: # <<<<<<<<<<<<<< @@ -39538,7 +39986,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":602 + /* "PyCafe.pyx":601 * else: * with nogil: * self._c_cafe.openNowAndWait(timeout) # <<<<<<<<<<<<<< @@ -39548,7 +39996,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_v_self->_c_cafe->openNowAndWait(__pyx_v_timeout); } - /* "PyCafe.pyx":601 + /* "PyCafe.pyx":600 * * else: * with nogil: # <<<<<<<<<<<<<< @@ -39567,7 +40015,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":605 + /* "PyCafe.pyx":604 * ###handleList, pvList = self.getHandles() * * self.hh.getHandles(hList, pvV) # <<<<<<<<<<<<<< @@ -39576,7 +40024,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC */ (void)(__pyx_v_self->hh.getHandles(__pyx_v_hList, __pyx_v_pvV)); - /* "PyCafe.pyx":607 + /* "PyCafe.pyx":606 * self.hh.getHandles(hList, pvV) * # Did all callbacks complete? wait 10ms * for i in range(0, 100): # <<<<<<<<<<<<<< @@ -39586,7 +40034,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC for (__pyx_t_3 = 0; __pyx_t_3 < 0x64; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "PyCafe.pyx":608 + /* "PyCafe.pyx":607 * # Did all callbacks complete? wait 10ms * for i in range(0, 100): * if not self._c_cafe.initCallbackCompleteV(hList): # <<<<<<<<<<<<<< @@ -39596,16 +40044,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_self->_c_cafe->initCallbackCompleteV(__pyx_v_hList) != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":609 + /* "PyCafe.pyx":608 * for i in range(0, 100): * if not self._c_cafe.initCallbackCompleteV(hList): * time.sleep(0.001) # <<<<<<<<<<<<<< * npoll = npoll+1 * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_time); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 609, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_time); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_sleep); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 609, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_sleep); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = NULL; @@ -39620,24 +40068,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC } __pyx_t_6 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_10, __pyx_float_0_001) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_float_0_001); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 609, __pyx_L1_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":610 + /* "PyCafe.pyx":609 * if not self._c_cafe.initCallbackCompleteV(hList): * time.sleep(0.001) * npoll = npoll+1 # <<<<<<<<<<<<<< * else: * break */ - __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_v_npoll, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 610, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_v_npoll, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_npoll, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":608 + /* "PyCafe.pyx":607 * # Did all callbacks complete? wait 10ms * for i in range(0, 100): * if not self._c_cafe.initCallbackCompleteV(hList): # <<<<<<<<<<<<<< @@ -39647,7 +40095,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC goto __pyx_L24; } - /* "PyCafe.pyx":612 + /* "PyCafe.pyx":611 * npoll = npoll+1 * else: * break # <<<<<<<<<<<<<< @@ -39663,7 +40111,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC } __pyx_L4:; - /* "PyCafe.pyx":550 + /* "PyCafe.pyx":549 * ############################################################################# * * def openNowAndWait(self, double timeout=0, handlesPV=None): # <<<<<<<<<<<<<< @@ -39689,7 +40137,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_40openNowAndWait(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":620 +/* "PyCafe.pyx":619 * ############################################################################ * * def openGroupNowAndWait(self, double timeout=0): # <<<<<<<<<<<<<< @@ -39725,7 +40173,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_43openGroupNowAndWait(PyObject *__pyx_ } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "openGroupNowAndWait") < 0)) __PYX_ERR(3, 620, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "openGroupNowAndWait") < 0)) __PYX_ERR(3, 619, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -39736,14 +40184,14 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_43openGroupNowAndWait(PyObject *__pyx_ } } if (values[0]) { - __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 620, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 619, __pyx_L3_error) } else { __pyx_v_timeout = ((double)0.0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("openGroupNowAndWait", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 620, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("openGroupNowAndWait", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 619, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.openGroupNowAndWait", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -39762,7 +40210,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_42openGroupNowAndWait(struct __pyx_obj int __pyx_t_1; __Pyx_RefNannySetupContext("openGroupNowAndWait", 0); - /* "PyCafe.pyx":621 + /* "PyCafe.pyx":620 * * def openGroupNowAndWait(self, double timeout=0): * if timeout <= 0: # <<<<<<<<<<<<<< @@ -39772,7 +40220,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_42openGroupNowAndWait(struct __pyx_obj __pyx_t_1 = ((__pyx_v_timeout <= 0.0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":622 + /* "PyCafe.pyx":621 * def openGroupNowAndWait(self, double timeout=0): * if timeout <= 0: * self._c_cafe.channelOpenGroupPolicy.getTimeout() # <<<<<<<<<<<<<< @@ -39781,7 +40229,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_42openGroupNowAndWait(struct __pyx_obj */ (void)(__pyx_v_self->_c_cafe->channelOpenGroupPolicy.getTimeout()); - /* "PyCafe.pyx":621 + /* "PyCafe.pyx":620 * * def openGroupNowAndWait(self, double timeout=0): * if timeout <= 0: # <<<<<<<<<<<<<< @@ -39790,7 +40238,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_42openGroupNowAndWait(struct __pyx_obj */ } - /* "PyCafe.pyx":631 + /* "PyCafe.pyx":630 * # WITH_PEND_EVENT) * # self._c_cafe.channelOpenGroupPolicy.setTimeoutToDefault() * with nogil: # <<<<<<<<<<<<<< @@ -39805,7 +40253,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_42openGroupNowAndWait(struct __pyx_obj #endif /*try:*/ { - /* "PyCafe.pyx":632 + /* "PyCafe.pyx":631 * # self._c_cafe.channelOpenGroupPolicy.setTimeoutToDefault() * with nogil: * self._c_cafe.openGroupNowAndWait(timeout) # <<<<<<<<<<<<<< @@ -39815,7 +40263,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_42openGroupNowAndWait(struct __pyx_obj __pyx_v_self->_c_cafe->openGroupNowAndWait(__pyx_v_timeout); } - /* "PyCafe.pyx":631 + /* "PyCafe.pyx":630 * # WITH_PEND_EVENT) * # self._c_cafe.channelOpenGroupPolicy.setTimeoutToDefault() * with nogil: # <<<<<<<<<<<<<< @@ -39834,7 +40282,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_42openGroupNowAndWait(struct __pyx_obj } } - /* "PyCafe.pyx":633 + /* "PyCafe.pyx":632 * with nogil: * self._c_cafe.openGroupNowAndWait(timeout) * return # <<<<<<<<<<<<<< @@ -39845,7 +40293,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_42openGroupNowAndWait(struct __pyx_obj __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":620 + /* "PyCafe.pyx":619 * ############################################################################ * * def openGroupNowAndWait(self, double timeout=0): # <<<<<<<<<<<<<< @@ -39861,7 +40309,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_42openGroupNowAndWait(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":639 +/* "PyCafe.pyx":638 * ############################################################################ * * def openGroupNowAndWaitForInputGroups(self, double timeout, groupHandles): # <<<<<<<<<<<<<< @@ -39900,11 +40348,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_45openGroupNowAndWaitForInputGroups(Py case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_groupHandles)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("openGroupNowAndWaitForInputGroups", 1, 2, 2, 1); __PYX_ERR(3, 639, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("openGroupNowAndWaitForInputGroups", 1, 2, 2, 1); __PYX_ERR(3, 638, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "openGroupNowAndWaitForInputGroups") < 0)) __PYX_ERR(3, 639, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "openGroupNowAndWaitForInputGroups") < 0)) __PYX_ERR(3, 638, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -39912,12 +40360,12 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_45openGroupNowAndWaitForInputGroups(Py values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } - __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 639, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 638, __pyx_L3_error) __pyx_v_groupHandles = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("openGroupNowAndWaitForInputGroups", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 639, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("openGroupNowAndWaitForInputGroups", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 638, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.openGroupNowAndWaitForInputGroups", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -39951,7 +40399,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st PyObject *__pyx_t_13 = NULL; __Pyx_RefNannySetupContext("openGroupNowAndWaitForInputGroups", 0); - /* "PyCafe.pyx":640 + /* "PyCafe.pyx":639 * * def openGroupNowAndWaitForInputGroups(self, double timeout, groupHandles): * cdef str _METHOD = "openGroupNowAndWaitForInputGroups" # <<<<<<<<<<<<<< @@ -39961,7 +40409,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __Pyx_INCREF(__pyx_n_u_openGroupNowAndWaitForInputGroup); __pyx_v__METHOD = __pyx_n_u_openGroupNowAndWaitForInputGroup; - /* "PyCafe.pyx":644 + /* "PyCafe.pyx":643 * cdef vector[unsigned int] hList * * if isinstance(groupHandles, (list)): # <<<<<<<<<<<<<< @@ -39972,26 +40420,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":645 + /* "PyCafe.pyx":644 * * if isinstance(groupHandles, (list)): * for i in range(0, len(groupHandles)): # <<<<<<<<<<<<<< * if isinstance(groupHandles[i], (int, long)): * hList.push_back(groupHandles[i]) */ - __pyx_t_3 = PyObject_Length(__pyx_v_groupHandles); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 645, __pyx_L1_error) + __pyx_t_3 = PyObject_Length(__pyx_v_groupHandles); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 644, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":646 + /* "PyCafe.pyx":645 * if isinstance(groupHandles, (list)): * for i in range(0, len(groupHandles)): * if isinstance(groupHandles[i], (int, long)): # <<<<<<<<<<<<<< * hList.push_back(groupHandles[i]) * elif isinstance(groupHandles[i], (str)): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_groupHandles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 646, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_groupHandles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 645, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyInt_Check(__pyx_t_6); __pyx_t_7 = (__pyx_t_1 != 0); @@ -40008,25 +40456,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":647 + /* "PyCafe.pyx":646 * for i in range(0, len(groupHandles)): * if isinstance(groupHandles[i], (int, long)): * hList.push_back(groupHandles[i]) # <<<<<<<<<<<<<< * elif isinstance(groupHandles[i], (str)): * hList.push_back( */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_groupHandles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 647, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_groupHandles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 647, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 646, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 647, __pyx_L1_error) + __PYX_ERR(3, 646, __pyx_L1_error) } - /* "PyCafe.pyx":646 + /* "PyCafe.pyx":645 * if isinstance(groupHandles, (list)): * for i in range(0, len(groupHandles)): * if isinstance(groupHandles[i], (int, long)): # <<<<<<<<<<<<<< @@ -40036,32 +40484,32 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st goto __pyx_L6; } - /* "PyCafe.pyx":648 + /* "PyCafe.pyx":647 * if isinstance(groupHandles[i], (int, long)): * hList.push_back(groupHandles[i]) * elif isinstance(groupHandles[i], (str)): # <<<<<<<<<<<<<< * hList.push_back( * self.hh.getGroupHandleFromGroupName(groupHandles[i])) */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_groupHandles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 648, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_groupHandles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyUnicode_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":650 + /* "PyCafe.pyx":649 * elif isinstance(groupHandles[i], (str)): * hList.push_back( * self.hh.getGroupHandleFromGroupName(groupHandles[i])) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_groupHandles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 650, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_groupHandles, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 649, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 = __Pyx_PyObject_AsString(__pyx_t_6); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(3, 650, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_AsString(__pyx_t_6); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(3, 649, __pyx_L1_error) - /* "PyCafe.pyx":649 + /* "PyCafe.pyx":648 * hList.push_back(groupHandles[i]) * elif isinstance(groupHandles[i], (str)): * hList.push_back( # <<<<<<<<<<<<<< @@ -40072,11 +40520,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __pyx_v_hList.push_back(__pyx_v_self->hh.getGroupHandleFromGroupName(__pyx_t_9)); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 649, __pyx_L1_error) + __PYX_ERR(3, 648, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":648 + /* "PyCafe.pyx":647 * if isinstance(groupHandles[i], (int, long)): * hList.push_back(groupHandles[i]) * elif isinstance(groupHandles[i], (str)): # <<<<<<<<<<<<<< @@ -40086,7 +40534,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st goto __pyx_L6; } - /* "PyCafe.pyx":652 + /* "PyCafe.pyx":651 * self.hh.getGroupHandleFromGroupName(groupHandles[i])) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -40094,10 +40542,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st * "List input arguments, should be of type \ */ /*else*/ { - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 652, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - /* "PyCafe.pyx":653 + /* "PyCafe.pyx":652 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -40119,7 +40567,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_10)) { PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_o}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 652, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 651, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_6); } else @@ -40127,13 +40575,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_o}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 652, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 651, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { - __pyx_t_13 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 652, __pyx_L1_error) + __pyx_t_13 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_11) { __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL; @@ -40147,30 +40595,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __Pyx_INCREF(__pyx_kp_u_List_input_arguments_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_List_input_arguments_should_be_o); PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_kp_u_List_input_arguments_should_be_o); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 652, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":652 + /* "PyCafe.pyx":651 * self.hh.getGroupHandleFromGroupName(groupHandles[i])) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "List input arguments, should be of type \ */ - __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 652, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __PYX_ERR(3, 652, __pyx_L1_error) + __PYX_ERR(3, 651, __pyx_L1_error) } __pyx_L6:; } - /* "PyCafe.pyx":644 + /* "PyCafe.pyx":643 * cdef vector[unsigned int] hList * * if isinstance(groupHandles, (list)): # <<<<<<<<<<<<<< @@ -40180,7 +40628,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st goto __pyx_L3; } - /* "PyCafe.pyx":656 + /* "PyCafe.pyx":655 * "List input arguments, should be of type \ * if group handle, else if group name")) * elif isinstance(groupHandles, (int, long)): # <<<<<<<<<<<<<< @@ -40201,22 +40649,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":657 + /* "PyCafe.pyx":656 * if group handle, else if group name")) * elif isinstance(groupHandles, (int, long)): * hList.push_back(groupHandles) # <<<<<<<<<<<<<< * elif isinstance(groupHandles, (str)): * hList.push_back(self.hh.getGroupHandleFromGroupName(groupHandles)) */ - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_groupHandles); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 657, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_groupHandles); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 656, __pyx_L1_error) try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 657, __pyx_L1_error) + __PYX_ERR(3, 656, __pyx_L1_error) } - /* "PyCafe.pyx":656 + /* "PyCafe.pyx":655 * "List input arguments, should be of type \ * if group handle, else if group name")) * elif isinstance(groupHandles, (int, long)): # <<<<<<<<<<<<<< @@ -40226,7 +40674,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st goto __pyx_L3; } - /* "PyCafe.pyx":658 + /* "PyCafe.pyx":657 * elif isinstance(groupHandles, (int, long)): * hList.push_back(groupHandles) * elif isinstance(groupHandles, (str)): # <<<<<<<<<<<<<< @@ -40237,22 +40685,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":659 + /* "PyCafe.pyx":658 * hList.push_back(groupHandles) * elif isinstance(groupHandles, (str)): * hList.push_back(self.hh.getGroupHandleFromGroupName(groupHandles)) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - __pyx_t_9 = __Pyx_PyObject_AsString(__pyx_v_groupHandles); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(3, 659, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_AsString(__pyx_v_groupHandles); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(3, 658, __pyx_L1_error) try { __pyx_v_hList.push_back(__pyx_v_self->hh.getGroupHandleFromGroupName(__pyx_t_9)); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 659, __pyx_L1_error) + __PYX_ERR(3, 658, __pyx_L1_error) } - /* "PyCafe.pyx":658 + /* "PyCafe.pyx":657 * elif isinstance(groupHandles, (int, long)): * hList.push_back(groupHandles) * elif isinstance(groupHandles, (str)): # <<<<<<<<<<<<<< @@ -40262,7 +40710,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st goto __pyx_L3; } - /* "PyCafe.pyx":661 + /* "PyCafe.pyx":660 * hList.push_back(self.hh.getGroupHandleFromGroupName(groupHandles)) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -40270,10 +40718,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st * ("Second input argument (if not a list), should be of " */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 661, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":662 + /* "PyCafe.pyx":661 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -40295,7 +40743,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_13, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Second_input_argument_if_not_a_l}; - __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 661, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 660, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_GOTREF(__pyx_t_10); } else @@ -40303,13 +40751,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_13, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Second_input_argument_if_not_a_l}; - __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 661, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 660, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_GOTREF(__pyx_t_10); } else #endif { - __pyx_t_11 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 661, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_13) { __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_13); __pyx_t_13 = NULL; @@ -40323,29 +40771,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __Pyx_INCREF(__pyx_kp_u_Second_input_argument_if_not_a_l); __Pyx_GIVEREF(__pyx_kp_u_Second_input_argument_if_not_a_l); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_12, __pyx_kp_u_Second_input_argument_if_not_a_l); - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 661, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":661 + /* "PyCafe.pyx":660 * hList.push_back(self.hh.getGroupHandleFromGroupName(groupHandles)) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("Second input argument (if not a list), should be of " */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 661, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 661, __pyx_L1_error) + __PYX_ERR(3, 660, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":668 + /* "PyCafe.pyx":667 * * # list to vector * with nogil: # <<<<<<<<<<<<<< @@ -40360,7 +40808,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st #endif /*try:*/ { - /* "PyCafe.pyx":669 + /* "PyCafe.pyx":668 * # list to vector * with nogil: * self._c_cafe.groupOpenNowAndWait(timeout, hList) # <<<<<<<<<<<<<< @@ -40370,7 +40818,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __pyx_v_self->_c_cafe->groupOpenNowAndWait(__pyx_v_timeout, __pyx_v_hList); } - /* "PyCafe.pyx":668 + /* "PyCafe.pyx":667 * * # list to vector * with nogil: # <<<<<<<<<<<<<< @@ -40389,7 +40837,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st } } - /* "PyCafe.pyx":670 + /* "PyCafe.pyx":669 * with nogil: * self._c_cafe.groupOpenNowAndWait(timeout, hList) * return # <<<<<<<<<<<<<< @@ -40400,7 +40848,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":639 + /* "PyCafe.pyx":638 * ############################################################################ * * def openGroupNowAndWaitForInputGroups(self, double timeout, groupHandles): # <<<<<<<<<<<<<< @@ -40425,7 +40873,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_44openGroupNowAndWaitForInputGroups(st return __pyx_r; } -/* "PyCafe.pyx":674 +/* "PyCafe.pyx":673 * ############################################################################ * * def openMonitorPrepare(self): # <<<<<<<<<<<<<< @@ -40451,7 +40899,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_46openMonitorPrepare(struct __pyx_obj_ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("openMonitorPrepare", 0); - /* "PyCafe.pyx":678 + /* "PyCafe.pyx":677 * # self._c_cafe.channelMonitorPolicy.setWhenToFlushSendBuffer( * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: # <<<<<<<<<<<<<< @@ -40466,7 +40914,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_46openMonitorPrepare(struct __pyx_obj_ #endif /*try:*/ { - /* "PyCafe.pyx":679 + /* "PyCafe.pyx":678 * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: * self._c_cafe.openMonitorPrepare() # <<<<<<<<<<<<<< @@ -40476,7 +40924,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_46openMonitorPrepare(struct __pyx_obj_ __pyx_v_self->_c_cafe->openMonitorPrepare(); } - /* "PyCafe.pyx":678 + /* "PyCafe.pyx":677 * # self._c_cafe.channelMonitorPolicy.setWhenToFlushSendBuffer( * # FLUSH_DESIGNATED_TO_CLIENT) * with nogil: # <<<<<<<<<<<<<< @@ -40495,7 +40943,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_46openMonitorPrepare(struct __pyx_obj_ } } - /* "PyCafe.pyx":680 + /* "PyCafe.pyx":679 * with nogil: * self._c_cafe.openMonitorPrepare() * return # <<<<<<<<<<<<<< @@ -40506,7 +40954,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_46openMonitorPrepare(struct __pyx_obj_ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":674 + /* "PyCafe.pyx":673 * ############################################################################ * * def openMonitorPrepare(self): # <<<<<<<<<<<<<< @@ -40522,7 +40970,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_46openMonitorPrepare(struct __pyx_obj_ return __pyx_r; } -/* "PyCafe.pyx":684 +/* "PyCafe.pyx":683 * ############################################################################## * * def openMonitorNow(self): # <<<<<<<<<<<<<< @@ -40551,7 +40999,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_48openMonitorNow(struct __pyx_obj_6PyC PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("openMonitorNow", 0); - /* "PyCafe.pyx":690 + /* "PyCafe.pyx":689 * # self._c_cafe.channelMonitorPolicy.setFlushSendBufferKind( * # WITH_FLUSH_IO) * with nogil: # <<<<<<<<<<<<<< @@ -40566,7 +41014,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_48openMonitorNow(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":691 + /* "PyCafe.pyx":690 * # WITH_FLUSH_IO) * with nogil: * self._c_cafe.openMonitorNow() # <<<<<<<<<<<<<< @@ -40576,7 +41024,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_48openMonitorNow(struct __pyx_obj_6PyC __pyx_v_self->_c_cafe->openMonitorNow(); } - /* "PyCafe.pyx":690 + /* "PyCafe.pyx":689 * # self._c_cafe.channelMonitorPolicy.setFlushSendBufferKind( * # WITH_FLUSH_IO) * with nogil: # <<<<<<<<<<<<<< @@ -40595,16 +41043,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_48openMonitorNow(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":692 + /* "PyCafe.pyx":691 * with nogil: * self._c_cafe.openMonitorNow() * time.sleep(0.01) # <<<<<<<<<<<<<< * return * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 692, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_sleep); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 692, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_sleep); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -40619,12 +41067,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_48openMonitorNow(struct __pyx_obj_6PyC } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_float_0_01) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_float_0_01); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 692, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":693 + /* "PyCafe.pyx":692 * self._c_cafe.openMonitorNow() * time.sleep(0.01) * return # <<<<<<<<<<<<<< @@ -40635,7 +41083,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_48openMonitorNow(struct __pyx_obj_6PyC __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":684 + /* "PyCafe.pyx":683 * ############################################################################## * * def openMonitorNow(self): # <<<<<<<<<<<<<< @@ -40658,7 +41106,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_48openMonitorNow(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":699 +/* "PyCafe.pyx":698 * ############################################################################ * * cdef getMonitorWhenToFlushSendBuffer(self): # <<<<<<<<<<<<<< @@ -40672,7 +41120,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_getMonitorWhenToFlushSendBuffer(struct PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("getMonitorWhenToFlushSendBuffer", 0); - /* "PyCafe.pyx":700 + /* "PyCafe.pyx":699 * * cdef getMonitorWhenToFlushSendBuffer(self): * return self._c_cafe.channelMonitorPolicy.getWhenToFlushSendBuffer() # <<<<<<<<<<<<<< @@ -40680,13 +41128,13 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_getMonitorWhenToFlushSendBuffer(struct * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_ChannelWhenToFlushSendBufferPolicyKind(__pyx_v_self->_c_cafe->channelMonitorPolicy.getWhenToFlushSendBuffer()); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 700, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_ChannelWhenToFlushSendBufferPolicyKind(__pyx_v_self->_c_cafe->channelMonitorPolicy.getWhenToFlushSendBuffer()); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":699 + /* "PyCafe.pyx":698 * ############################################################################ * * cdef getMonitorWhenToFlushSendBuffer(self): # <<<<<<<<<<<<<< @@ -40707,7 +41155,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_getMonitorWhenToFlushSendBuffer(struct return __pyx_r; } -/* "PyCafe.pyx":705 +/* "PyCafe.pyx":704 * * ############################################################################ * def openMonitorNowAndWait(self, double timeout): # <<<<<<<<<<<<<< @@ -40723,7 +41171,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_51openMonitorNowAndWait(PyObject *__py __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("openMonitorNowAndWait (wrapper)", 0); assert(__pyx_arg_timeout); { - __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 705, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 704, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -40754,7 +41202,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o PyObject *__pyx_t_10 = NULL; __Pyx_RefNannySetupContext("openMonitorNowAndWait", 0); - /* "PyCafe.pyx":706 + /* "PyCafe.pyx":705 * ############################################################################ * def openMonitorNowAndWait(self, double timeout): * cdef _METHOD = "openMonitorNowAndWait(timeout)" # <<<<<<<<<<<<<< @@ -40764,7 +41212,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o __Pyx_INCREF(__pyx_kp_u_openMonitorNowAndWait_timeout); __pyx_v__METHOD = __pyx_kp_u_openMonitorNowAndWait_timeout; - /* "PyCafe.pyx":714 + /* "PyCafe.pyx":713 * # self._c_cafe.channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO) * * with nogil: # <<<<<<<<<<<<<< @@ -40779,7 +41227,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o #endif /*try:*/ { - /* "PyCafe.pyx":715 + /* "PyCafe.pyx":714 * * with nogil: * self._c_cafe.openMonitorNowAndWait(max(timeout, self._min_timeout)) # <<<<<<<<<<<<<< @@ -40796,7 +41244,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o __pyx_v_self->_c_cafe->openMonitorNowAndWait(__pyx_t_3); } - /* "PyCafe.pyx":714 + /* "PyCafe.pyx":713 * # self._c_cafe.channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO) * * with nogil: # <<<<<<<<<<<<<< @@ -40815,7 +41263,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o } } - /* "PyCafe.pyx":717 + /* "PyCafe.pyx":716 * self._c_cafe.openMonitorNowAndWait(max(timeout, self._min_timeout)) * * if timeout <= 0: # <<<<<<<<<<<<<< @@ -40825,24 +41273,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o __pyx_t_4 = ((__pyx_v_timeout <= 0.0) != 0); if (__pyx_t_4) { - /* "PyCafe.pyx":719 + /* "PyCafe.pyx":718 * if timeout <= 0: * raise UserWarning \ * ("{} {} \n{} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("input argument, timeout, must be a positive number!\n" */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__40, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 719, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__40, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":722 + /* "PyCafe.pyx":721 * self._exception_text, _METHOD, * ("input argument, timeout, must be a positive number!\n" * "timeout reset to:"), self._min_timeout)) # <<<<<<<<<<<<<< * * */ - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_self->_min_timeout); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 722, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_self->_min_timeout); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; @@ -40859,7 +41307,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_input_argument_timeout_must_be_a, __pyx_t_7}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 719, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 718, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -40868,14 +41316,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_input_argument_timeout_must_be_a, __pyx_t_7}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 719, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 718, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { - __pyx_t_10 = PyTuple_New(4+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 719, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(4+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -40892,27 +41340,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 3+__pyx_t_9, __pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 719, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":719 + /* "PyCafe.pyx":718 * if timeout <= 0: * raise UserWarning \ * ("{} {} \n{} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("input argument, timeout, must be a positive number!\n" */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_UserWarning, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 719, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_UserWarning, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 718, __pyx_L1_error) + __PYX_ERR(3, 717, __pyx_L1_error) - /* "PyCafe.pyx":717 + /* "PyCafe.pyx":716 * self._c_cafe.openMonitorNowAndWait(max(timeout, self._min_timeout)) * * if timeout <= 0: # <<<<<<<<<<<<<< @@ -40921,7 +41369,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o */ } - /* "PyCafe.pyx":705 + /* "PyCafe.pyx":704 * * ############################################################################ * def openMonitorNowAndWait(self, double timeout): # <<<<<<<<<<<<<< @@ -40947,7 +41395,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_50openMonitorNowAndWait(struct __pyx_o return __pyx_r; } -/* "PyCafe.pyx":727 +/* "PyCafe.pyx":726 * ############################################################################ * * def ca_pend_event(self, double timeout): # <<<<<<<<<<<<<< @@ -40963,7 +41411,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_53ca_pend_event(PyObject *__pyx_v_self __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ca_pend_event (wrapper)", 0); assert(__pyx_arg_timeout); { - __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 727, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 726, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -40992,7 +41440,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa PyObject *__pyx_t_7 = NULL; __Pyx_RefNannySetupContext("ca_pend_event", 0); - /* "PyCafe.pyx":728 + /* "PyCafe.pyx":727 * * def ca_pend_event(self, double timeout): * cdef _METHOD = "ca_pend_event(timeout)" # <<<<<<<<<<<<<< @@ -41002,7 +41450,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_kp_u_ca_pend_event_timeout); __pyx_v__METHOD = __pyx_kp_u_ca_pend_event_timeout; - /* "PyCafe.pyx":730 + /* "PyCafe.pyx":729 * cdef _METHOD = "ca_pend_event(timeout)" * * cdef double _timeout = timeout # <<<<<<<<<<<<<< @@ -41011,7 +41459,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa */ __pyx_v__timeout = __pyx_v_timeout; - /* "PyCafe.pyx":731 + /* "PyCafe.pyx":730 * * cdef double _timeout = timeout * if timeout <= 0: # <<<<<<<<<<<<<< @@ -41021,7 +41469,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa __pyx_t_1 = ((__pyx_v_timeout <= 0.0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":732 + /* "PyCafe.pyx":731 * cdef double _timeout = timeout * if timeout <= 0: * _timeout = DEFAULT_TIMEOUT_PEND_EVENT # <<<<<<<<<<<<<< @@ -41030,7 +41478,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa */ __pyx_v__timeout = DEFAULT_TIMEOUT_PEND_EVENT; - /* "PyCafe.pyx":731 + /* "PyCafe.pyx":730 * * cdef double _timeout = timeout * if timeout <= 0: # <<<<<<<<<<<<<< @@ -41039,7 +41487,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":734 + /* "PyCafe.pyx":733 * _timeout = DEFAULT_TIMEOUT_PEND_EVENT * * self._c_cafe._ca_pend_event(_timeout) # <<<<<<<<<<<<<< @@ -41048,7 +41496,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa */ (void)(__pyx_v_self->_c_cafe->_ca_pend_event(__pyx_v__timeout)); - /* "PyCafe.pyx":736 + /* "PyCafe.pyx":735 * self._c_cafe._ca_pend_event(_timeout) * * if timeout < 0: # <<<<<<<<<<<<<< @@ -41058,24 +41506,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa __pyx_t_1 = ((__pyx_v_timeout < 0.0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":738 + /* "PyCafe.pyx":737 * if timeout < 0: * raise UserWarning \ * ("{} {} \n{} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("input argument, timeout, must be a positive number!\n" */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__40, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 738, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__40, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "PyCafe.pyx":741 + /* "PyCafe.pyx":740 * self._exception_text, _METHOD, * ("input argument, timeout, must be a positive number!\n" * "timeout reset to CAFE default:"), _timeout)) # <<<<<<<<<<<<<< * * def ca_pend_io(self, double timeout): */ - __pyx_t_4 = PyFloat_FromDouble(__pyx_v__timeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 741, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble(__pyx_v__timeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; @@ -41092,7 +41540,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_5, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_input_argument_timeout_must_be_a_2, __pyx_t_4}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 738, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 737, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -41101,14 +41549,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_5, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_input_argument_timeout_must_be_a_2, __pyx_t_4}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 738, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 737, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { - __pyx_t_7 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 738, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -41125,27 +41573,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 3+__pyx_t_6, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 738, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":738 + /* "PyCafe.pyx":737 * if timeout < 0: * raise UserWarning \ * ("{} {} \n{} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("input argument, timeout, must be a positive number!\n" */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_UserWarning, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 738, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_UserWarning, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 737, __pyx_L1_error) + __PYX_ERR(3, 736, __pyx_L1_error) - /* "PyCafe.pyx":736 + /* "PyCafe.pyx":735 * self._c_cafe._ca_pend_event(_timeout) * * if timeout < 0: # <<<<<<<<<<<<<< @@ -41154,7 +41602,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":727 + /* "PyCafe.pyx":726 * ############################################################################ * * def ca_pend_event(self, double timeout): # <<<<<<<<<<<<<< @@ -41180,7 +41628,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_52ca_pend_event(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":743 +/* "PyCafe.pyx":742 * "timeout reset to CAFE default:"), _timeout)) * * def ca_pend_io(self, double timeout): # <<<<<<<<<<<<<< @@ -41196,7 +41644,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_55ca_pend_io(PyObject *__pyx_v_self, P __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ca_pend_io (wrapper)", 0); assert(__pyx_arg_timeout); { - __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 743, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 742, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -41225,7 +41673,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ PyObject *__pyx_t_7 = NULL; __Pyx_RefNannySetupContext("ca_pend_io", 0); - /* "PyCafe.pyx":744 + /* "PyCafe.pyx":743 * * def ca_pend_io(self, double timeout): * cdef _METHOD = "ca_pend_io(timeout)" # <<<<<<<<<<<<<< @@ -41235,7 +41683,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ __Pyx_INCREF(__pyx_kp_u_ca_pend_io_timeout); __pyx_v__METHOD = __pyx_kp_u_ca_pend_io_timeout; - /* "PyCafe.pyx":746 + /* "PyCafe.pyx":745 * cdef _METHOD = "ca_pend_io(timeout)" * * cdef double _timeout = timeout # <<<<<<<<<<<<<< @@ -41244,7 +41692,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ */ __pyx_v__timeout = __pyx_v_timeout; - /* "PyCafe.pyx":747 + /* "PyCafe.pyx":746 * * cdef double _timeout = timeout * if timeout <= 0: # <<<<<<<<<<<<<< @@ -41254,7 +41702,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ __pyx_t_1 = ((__pyx_v_timeout <= 0.0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":748 + /* "PyCafe.pyx":747 * cdef double _timeout = timeout * if timeout <= 0: * _timeout = DEFAULT_TIMEOUT_PEND_IO # <<<<<<<<<<<<<< @@ -41263,7 +41711,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ */ __pyx_v__timeout = DEFAULT_TIMEOUT_PEND_IO; - /* "PyCafe.pyx":747 + /* "PyCafe.pyx":746 * * cdef double _timeout = timeout * if timeout <= 0: # <<<<<<<<<<<<<< @@ -41272,7 +41720,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":750 + /* "PyCafe.pyx":749 * _timeout = DEFAULT_TIMEOUT_PEND_IO * * self._c_cafe._ca_pend_io(timeout) # <<<<<<<<<<<<<< @@ -41281,7 +41729,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ */ (void)(__pyx_v_self->_c_cafe->_ca_pend_io(__pyx_v_timeout)); - /* "PyCafe.pyx":752 + /* "PyCafe.pyx":751 * self._c_cafe._ca_pend_io(timeout) * * if timeout < 0: # <<<<<<<<<<<<<< @@ -41291,24 +41739,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ __pyx_t_1 = ((__pyx_v_timeout < 0.0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":754 + /* "PyCafe.pyx":753 * if timeout < 0: * raise UserWarning \ * ("{} {} \n{} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("input argument, timeout, must be a positive number!\n" */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__40, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 754, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__40, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "PyCafe.pyx":757 + /* "PyCafe.pyx":756 * self._exception_text, _METHOD, * ("input argument, timeout, must be a positive number!\n" * "timeout reset to CAFE default:"), _timeout)) # <<<<<<<<<<<<<< * * def ca_poll(self): */ - __pyx_t_4 = PyFloat_FromDouble(__pyx_v__timeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 757, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble(__pyx_v__timeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; @@ -41325,7 +41773,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_5, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_input_argument_timeout_must_be_a_2, __pyx_t_4}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 754, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 753, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -41334,14 +41782,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_5, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_input_argument_timeout_must_be_a_2, __pyx_t_4}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 754, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 753, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { - __pyx_t_7 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 754, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -41358,27 +41806,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 3+__pyx_t_6, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 754, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":754 + /* "PyCafe.pyx":753 * if timeout < 0: * raise UserWarning \ * ("{} {} \n{} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("input argument, timeout, must be a positive number!\n" */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_UserWarning, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 754, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_UserWarning, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 753, __pyx_L1_error) + __PYX_ERR(3, 752, __pyx_L1_error) - /* "PyCafe.pyx":752 + /* "PyCafe.pyx":751 * self._c_cafe._ca_pend_io(timeout) * * if timeout < 0: # <<<<<<<<<<<<<< @@ -41387,7 +41835,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":743 + /* "PyCafe.pyx":742 * "timeout reset to CAFE default:"), _timeout)) * * def ca_pend_io(self, double timeout): # <<<<<<<<<<<<<< @@ -41413,7 +41861,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_54ca_pend_io(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":759 +/* "PyCafe.pyx":758 * "timeout reset to CAFE default:"), _timeout)) * * def ca_poll(self): # <<<<<<<<<<<<<< @@ -41439,7 +41887,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_56ca_poll(struct __pyx_obj_6PyCafe_CyC __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ca_poll", 0); - /* "PyCafe.pyx":760 + /* "PyCafe.pyx":759 * * def ca_poll(self): * with nogil: # <<<<<<<<<<<<<< @@ -41454,7 +41902,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_56ca_poll(struct __pyx_obj_6PyCafe_CyC #endif /*try:*/ { - /* "PyCafe.pyx":761 + /* "PyCafe.pyx":760 * def ca_poll(self): * with nogil: * self._c_cafe._ca_poll() # <<<<<<<<<<<<<< @@ -41464,7 +41912,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_56ca_poll(struct __pyx_obj_6PyCafe_CyC (void)(__pyx_v_self->_c_cafe->_ca_poll()); } - /* "PyCafe.pyx":760 + /* "PyCafe.pyx":759 * * def ca_poll(self): * with nogil: # <<<<<<<<<<<<<< @@ -41483,7 +41931,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_56ca_poll(struct __pyx_obj_6PyCafe_CyC } } - /* "PyCafe.pyx":759 + /* "PyCafe.pyx":758 * "timeout reset to CAFE default:"), _timeout)) * * def ca_poll(self): # <<<<<<<<<<<<<< @@ -41498,7 +41946,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_56ca_poll(struct __pyx_obj_6PyCafe_CyC return __pyx_r; } -/* "PyCafe.pyx":764 +/* "PyCafe.pyx":763 * * * def ca_flush_io(self): # <<<<<<<<<<<<<< @@ -41524,7 +41972,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_58ca_flush_io(struct __pyx_obj_6PyCafe __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ca_flush_io", 0); - /* "PyCafe.pyx":765 + /* "PyCafe.pyx":764 * * def ca_flush_io(self): * with nogil: # <<<<<<<<<<<<<< @@ -41539,7 +41987,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_58ca_flush_io(struct __pyx_obj_6PyCafe #endif /*try:*/ { - /* "PyCafe.pyx":766 + /* "PyCafe.pyx":765 * def ca_flush_io(self): * with nogil: * self._c_cafe._ca_flush_io() # <<<<<<<<<<<<<< @@ -41549,7 +41997,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_58ca_flush_io(struct __pyx_obj_6PyCafe (void)(__pyx_v_self->_c_cafe->_ca_flush_io()); } - /* "PyCafe.pyx":765 + /* "PyCafe.pyx":764 * * def ca_flush_io(self): * with nogil: # <<<<<<<<<<<<<< @@ -41568,7 +42016,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_58ca_flush_io(struct __pyx_obj_6PyCafe } } - /* "PyCafe.pyx":764 + /* "PyCafe.pyx":763 * * * def ca_flush_io(self): # <<<<<<<<<<<<<< @@ -41583,7 +42031,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_58ca_flush_io(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":770 +/* "PyCafe.pyx":769 * * ############################################################################ * def setChannelRequestPolicyGet( # <<<<<<<<<<<<<< @@ -41606,7 +42054,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_61setChannelRequestPolicyGet(PyObject static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_handlePV,&__pyx_n_s_when,&__pyx_n_s_wait,&__pyx_n_s_method,&__pyx_n_s_cb,0}; PyObject* values[5] = {0,0,0,0,0}; - /* "PyCafe.pyx":773 + /* "PyCafe.pyx":772 * self, handlePV, ChannelWhenToFlushSendBufferPolicyKind when, * ChannelWaitForResponsePolicyKind wait, * ChannelRequestPolicyKind method, cb: object = None): # <<<<<<<<<<<<<< @@ -41640,19 +42088,19 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_61setChannelRequestPolicyGet(PyObject case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_when)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setChannelRequestPolicyGet", 0, 4, 5, 1); __PYX_ERR(3, 770, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setChannelRequestPolicyGet", 0, 4, 5, 1); __PYX_ERR(3, 769, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wait)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setChannelRequestPolicyGet", 0, 4, 5, 2); __PYX_ERR(3, 770, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setChannelRequestPolicyGet", 0, 4, 5, 2); __PYX_ERR(3, 769, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setChannelRequestPolicyGet", 0, 4, 5, 3); __PYX_ERR(3, 770, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setChannelRequestPolicyGet", 0, 4, 5, 3); __PYX_ERR(3, 769, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: @@ -41662,7 +42110,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_61setChannelRequestPolicyGet(PyObject } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setChannelRequestPolicyGet") < 0)) __PYX_ERR(3, 770, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setChannelRequestPolicyGet") < 0)) __PYX_ERR(3, 769, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -41677,14 +42125,14 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_61setChannelRequestPolicyGet(PyObject } } __pyx_v_handlePV = values[0]; - __pyx_v_when = ((ChannelWhenToFlushSendBufferPolicyKind)__Pyx_PyInt_As_ChannelWhenToFlushSendBufferPolicyKind(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 771, __pyx_L3_error) - __pyx_v_wait = ((ChannelWaitForResponsePolicyKind)__Pyx_PyInt_As_ChannelWaitForResponsePolicyKind(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 772, __pyx_L3_error) - __pyx_v_method = ((ChannelRequestPolicyKind)__Pyx_PyInt_As_ChannelRequestPolicyKind(values[3])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 773, __pyx_L3_error) + __pyx_v_when = ((ChannelWhenToFlushSendBufferPolicyKind)__Pyx_PyInt_As_ChannelWhenToFlushSendBufferPolicyKind(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 770, __pyx_L3_error) + __pyx_v_wait = ((ChannelWaitForResponsePolicyKind)__Pyx_PyInt_As_ChannelWaitForResponsePolicyKind(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 771, __pyx_L3_error) + __pyx_v_method = ((ChannelRequestPolicyKind)__Pyx_PyInt_As_ChannelRequestPolicyKind(values[3])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 772, __pyx_L3_error) __pyx_v_cb = values[4]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setChannelRequestPolicyGet", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 770, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setChannelRequestPolicyGet", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 769, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setChannelRequestPolicyGet", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -41692,7 +42140,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_61setChannelRequestPolicyGet(PyObject __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_when, __pyx_v_wait, __pyx_v_method, __pyx_v_cb); - /* "PyCafe.pyx":770 + /* "PyCafe.pyx":769 * * ############################################################################ * def setChannelRequestPolicyGet( # <<<<<<<<<<<<<< @@ -41722,7 +42170,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ unsigned int __pyx_t_9; __Pyx_RefNannySetupContext("setChannelRequestPolicyGet", 0); - /* "PyCafe.pyx":775 + /* "PyCafe.pyx":774 * ChannelRequestPolicyKind method, cb: object = None): * * cdef str _METHOD = "setChannelRequestPolicyGet" # <<<<<<<<<<<<<< @@ -41732,7 +42180,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ __Pyx_INCREF(__pyx_n_u_setChannelRequestPolicyGet); __pyx_v__METHOD = __pyx_n_u_setChannelRequestPolicyGet; - /* "PyCafe.pyx":777 + /* "PyCafe.pyx":776 * cdef str _METHOD = "setChannelRequestPolicyGet" * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -41753,7 +42201,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":778 + /* "PyCafe.pyx":777 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< @@ -41763,7 +42211,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ __Pyx_INCREF(__pyx_v_handlePV); __pyx_v_handle = __pyx_v_handlePV; - /* "PyCafe.pyx":777 + /* "PyCafe.pyx":776 * cdef str _METHOD = "setChannelRequestPolicyGet" * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -41773,7 +42221,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ goto __pyx_L3; } - /* "PyCafe.pyx":779 + /* "PyCafe.pyx":778 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -41784,20 +42232,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":780 + /* "PyCafe.pyx":779 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 780, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 780, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 779, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_handle = __pyx_t_4; __pyx_t_4 = 0; - /* "PyCafe.pyx":779 + /* "PyCafe.pyx":778 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -41807,7 +42255,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ goto __pyx_L3; } - /* "PyCafe.pyx":782 + /* "PyCafe.pyx":781 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -41815,10 +42263,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ * ("First Input argument should be of type " */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 782, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - /* "PyCafe.pyx":783 + /* "PyCafe.pyx":782 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -41840,7 +42288,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 782, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 781, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_4); } else @@ -41848,13 +42296,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 782, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 781, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { - __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 782, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; @@ -41868,39 +42316,39 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ __Pyx_INCREF(__pyx_kp_u_First_Input_argument_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_First_Input_argument_should_be_o); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_kp_u_First_Input_argument_should_be_o); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 782, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":782 + /* "PyCafe.pyx":781 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First Input argument should be of type " */ - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 782, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 782, __pyx_L1_error) + __PYX_ERR(3, 781, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":789 + /* "PyCafe.pyx":788 * * cdef ChannelRequestPolicy crp * self.ph.getChannelRequestPolicyGet(handlePV, crp) # <<<<<<<<<<<<<< * if when: * crp.setWhenToFlushSendBuffer(when) */ - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 789, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 788, __pyx_L1_error) (void)(__pyx_v_self->ph.getChannelRequestPolicyGet(__pyx_t_9, __pyx_v_crp)); - /* "PyCafe.pyx":790 + /* "PyCafe.pyx":789 * cdef ChannelRequestPolicy crp * self.ph.getChannelRequestPolicyGet(handlePV, crp) * if when: # <<<<<<<<<<<<<< @@ -41909,7 +42357,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ if (__pyx_v_when) { - /* "PyCafe.pyx":791 + /* "PyCafe.pyx":790 * self.ph.getChannelRequestPolicyGet(handlePV, crp) * if when: * crp.setWhenToFlushSendBuffer(when) # <<<<<<<<<<<<<< @@ -41918,7 +42366,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ __pyx_v_crp.setWhenToFlushSendBuffer(__pyx_v_when); - /* "PyCafe.pyx":790 + /* "PyCafe.pyx":789 * cdef ChannelRequestPolicy crp * self.ph.getChannelRequestPolicyGet(handlePV, crp) * if when: # <<<<<<<<<<<<<< @@ -41927,7 +42375,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ } - /* "PyCafe.pyx":792 + /* "PyCafe.pyx":791 * if when: * crp.setWhenToFlushSendBuffer(when) * if wait: # <<<<<<<<<<<<<< @@ -41936,7 +42384,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ if (__pyx_v_wait) { - /* "PyCafe.pyx":793 + /* "PyCafe.pyx":792 * crp.setWhenToFlushSendBuffer(when) * if wait: * crp.setWaitKind(wait) # <<<<<<<<<<<<<< @@ -41945,7 +42393,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ __pyx_v_crp.setWaitKind(__pyx_v_wait); - /* "PyCafe.pyx":792 + /* "PyCafe.pyx":791 * if when: * crp.setWhenToFlushSendBuffer(when) * if wait: # <<<<<<<<<<<<<< @@ -41954,7 +42402,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ } - /* "PyCafe.pyx":794 + /* "PyCafe.pyx":793 * if wait: * crp.setWaitKind(wait) * if method: # <<<<<<<<<<<<<< @@ -41963,7 +42411,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ if (__pyx_v_method) { - /* "PyCafe.pyx":795 + /* "PyCafe.pyx":794 * crp.setWaitKind(wait) * if method: * crp.setMethodKind(method) # <<<<<<<<<<<<<< @@ -41972,7 +42420,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ __pyx_v_crp.setMethodKind(__pyx_v_method); - /* "PyCafe.pyx":794 + /* "PyCafe.pyx":793 * if wait: * crp.setWaitKind(wait) * if method: # <<<<<<<<<<<<<< @@ -41981,7 +42429,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ } - /* "PyCafe.pyx":796 + /* "PyCafe.pyx":795 * if method: * crp.setMethodKind(method) * if cb is not None: # <<<<<<<<<<<<<< @@ -41992,7 +42440,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":797 + /* "PyCafe.pyx":796 * crp.setMethodKind(method) * if cb is not None: * crp.setPyHandlerGet( cb) # forces when=WITH_CALLBACK_USER_SUPPLIED # <<<<<<<<<<<<<< @@ -42001,7 +42449,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ __pyx_v_crp.setPyHandlerGet(((void *)__pyx_v_cb)); - /* "PyCafe.pyx":796 + /* "PyCafe.pyx":795 * if method: * crp.setMethodKind(method) * if cb is not None: # <<<<<<<<<<<<<< @@ -42010,17 +42458,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ */ } - /* "PyCafe.pyx":799 + /* "PyCafe.pyx":798 * crp.setPyHandlerGet( cb) # forces when=WITH_CALLBACK_USER_SUPPLIED * * self.ph.setChannelRequestPolicyGet(handlePV, crp) # <<<<<<<<<<<<<< * return * ################################################################################ */ - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 799, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 798, __pyx_L1_error) (void)(__pyx_v_self->ph.setChannelRequestPolicyGet(__pyx_t_9, __pyx_v_crp)); - /* "PyCafe.pyx":800 + /* "PyCafe.pyx":799 * * self.ph.setChannelRequestPolicyGet(handlePV, crp) * return # <<<<<<<<<<<<<< @@ -42031,7 +42479,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":770 + /* "PyCafe.pyx":769 * * ############################################################################ * def setChannelRequestPolicyGet( # <<<<<<<<<<<<<< @@ -42057,7 +42505,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_60setChannelRequestPolicyGet(struct __ return __pyx_r; } -/* "PyCafe.pyx":806 +/* "PyCafe.pyx":805 * * * def initCallbackComplete(self, handlePV): # <<<<<<<<<<<<<< @@ -42099,7 +42547,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob int __pyx_t_12; __Pyx_RefNannySetupContext("initCallbackComplete", 0); - /* "PyCafe.pyx":807 + /* "PyCafe.pyx":806 * * def initCallbackComplete(self, handlePV): * cdef str _METHOD = "initCallbackComplete" # <<<<<<<<<<<<<< @@ -42109,7 +42557,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob __Pyx_INCREF(__pyx_n_u_initCallbackComplete); __pyx_v__METHOD = __pyx_n_u_initCallbackComplete; - /* "PyCafe.pyx":810 + /* "PyCafe.pyx":809 * cdef vector[unsigned int] hList * * if isinstance(handlePV, (list)): # <<<<<<<<<<<<<< @@ -42120,26 +42568,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":811 + /* "PyCafe.pyx":810 * * if isinstance(handlePV, (list)): * for i in range(0, len(handlePV)): # <<<<<<<<<<<<<< * if isinstance(handlePV[i], (int, long)): * hList.push_back(handlePV[i]) */ - __pyx_t_3 = PyObject_Length(__pyx_v_handlePV); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 811, __pyx_L1_error) + __pyx_t_3 = PyObject_Length(__pyx_v_handlePV); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 810, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":812 + /* "PyCafe.pyx":811 * if isinstance(handlePV, (list)): * for i in range(0, len(handlePV)): * if isinstance(handlePV[i], (int, long)): # <<<<<<<<<<<<<< * hList.push_back(handlePV[i]) * elif isinstance(handlePV[i], (str)): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 812, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 811, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyInt_Check(__pyx_t_6); __pyx_t_7 = (__pyx_t_1 != 0); @@ -42156,25 +42604,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":813 + /* "PyCafe.pyx":812 * for i in range(0, len(handlePV)): * if isinstance(handlePV[i], (int, long)): * hList.push_back(handlePV[i]) # <<<<<<<<<<<<<< * elif isinstance(handlePV[i], (str)): * hList.push_back(self.getHandleFromPV(handlePV[i])) */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 813, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 813, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 812, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 813, __pyx_L1_error) + __PYX_ERR(3, 812, __pyx_L1_error) } - /* "PyCafe.pyx":812 + /* "PyCafe.pyx":811 * if isinstance(handlePV, (list)): * for i in range(0, len(handlePV)): * if isinstance(handlePV[i], (int, long)): # <<<<<<<<<<<<<< @@ -42184,30 +42632,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob goto __pyx_L6; } - /* "PyCafe.pyx":814 + /* "PyCafe.pyx":813 * if isinstance(handlePV[i], (int, long)): * hList.push_back(handlePV[i]) * elif isinstance(handlePV[i], (str)): # <<<<<<<<<<<<<< * hList.push_back(self.getHandleFromPV(handlePV[i])) * else: */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 814, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyUnicode_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":815 + /* "PyCafe.pyx":814 * hList.push_back(handlePV[i]) * elif isinstance(handlePV[i], (str)): * hList.push_back(self.getHandleFromPV(handlePV[i])) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} \n{}".format( */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandleFromPV); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 815, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandleFromPV); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 815, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { @@ -42222,19 +42670,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob __pyx_t_6 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_11, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 815, __pyx_L1_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 815, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 814, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 815, __pyx_L1_error) + __PYX_ERR(3, 814, __pyx_L1_error) } - /* "PyCafe.pyx":814 + /* "PyCafe.pyx":813 * if isinstance(handlePV[i], (int, long)): * hList.push_back(handlePV[i]) * elif isinstance(handlePV[i], (str)): # <<<<<<<<<<<<<< @@ -42244,7 +42692,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob goto __pyx_L6; } - /* "PyCafe.pyx":817 + /* "PyCafe.pyx":816 * hList.push_back(self.getHandleFromPV(handlePV[i])) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -42252,10 +42700,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob * ("List input arguments, should be of type if handle" + */ /*else*/ { - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 817, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - /* "PyCafe.pyx":818 + /* "PyCafe.pyx":817 * else: * raise Exception("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -42277,7 +42725,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_o_2}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 817, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 816, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_6); } else @@ -42285,13 +42733,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_o_2}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 817, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 816, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { - __pyx_t_11 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 817, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_10) { __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL; @@ -42305,30 +42753,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob __Pyx_INCREF(__pyx_kp_u_List_input_arguments_should_be_o_2); __Pyx_GIVEREF(__pyx_kp_u_List_input_arguments_should_be_o_2); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_12, __pyx_kp_u_List_input_arguments_should_be_o_2); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 817, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":817 + /* "PyCafe.pyx":816 * hList.push_back(self.getHandleFromPV(handlePV[i])) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("List input arguments, should be of type if handle" + */ - __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 817, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_9, 0, 0, 0); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __PYX_ERR(3, 817, __pyx_L1_error) + __PYX_ERR(3, 816, __pyx_L1_error) } __pyx_L6:; } - /* "PyCafe.pyx":821 + /* "PyCafe.pyx":820 * ("List input arguments, should be of type if handle" + * "else if pvname"))) * return self._c_cafe.initCallbackCompleteV(hList) # <<<<<<<<<<<<<< @@ -42336,13 +42784,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob * elif isinstance(handlePV, (int, long)): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->initCallbackCompleteV(__pyx_v_hList)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 821, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->initCallbackCompleteV(__pyx_v_hList)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_r = __pyx_t_9; __pyx_t_9 = 0; goto __pyx_L0; - /* "PyCafe.pyx":810 + /* "PyCafe.pyx":809 * cdef vector[unsigned int] hList * * if isinstance(handlePV, (list)): # <<<<<<<<<<<<<< @@ -42352,7 +42800,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob goto __pyx_L3; } - /* "PyCafe.pyx":823 + /* "PyCafe.pyx":822 * return self._c_cafe.initCallbackCompleteV(hList) * * elif isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -42373,7 +42821,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":824 + /* "PyCafe.pyx":823 * * elif isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< @@ -42383,7 +42831,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob __Pyx_INCREF(__pyx_v_handlePV); __pyx_v_handle = __pyx_v_handlePV; - /* "PyCafe.pyx":823 + /* "PyCafe.pyx":822 * return self._c_cafe.initCallbackCompleteV(hList) * * elif isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -42393,7 +42841,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob goto __pyx_L3; } - /* "PyCafe.pyx":825 + /* "PyCafe.pyx":824 * elif isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -42404,20 +42852,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":826 + /* "PyCafe.pyx":825 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 826, __pyx_L1_error) - __pyx_t_9 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 826, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 825, __pyx_L1_error) + __pyx_t_9 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_v_handle = __pyx_t_9; __pyx_t_9 = 0; - /* "PyCafe.pyx":825 + /* "PyCafe.pyx":824 * elif isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -42427,7 +42875,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob goto __pyx_L3; } - /* "PyCafe.pyx":828 + /* "PyCafe.pyx":827 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -42435,10 +42883,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob * ("Input argument should be of type if handle," + */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 828, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 827, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":829 + /* "PyCafe.pyx":828 * else: * raise Exception("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -42460,7 +42908,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Input_argument_should_be_of_type_2}; - __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 828, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 827, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_9); } else @@ -42468,13 +42916,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Input_argument_should_be_of_type_2}; - __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 828, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 827, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_9); } else #endif { - __pyx_t_10 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 828, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 827, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_11) { __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11); __pyx_t_11 = NULL; @@ -42488,29 +42936,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob __Pyx_INCREF(__pyx_kp_u_Input_argument_should_be_of_type_2); __Pyx_GIVEREF(__pyx_kp_u_Input_argument_should_be_of_type_2); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_12, __pyx_kp_u_Input_argument_should_be_of_type_2); - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 828, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 827, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":828 + /* "PyCafe.pyx":827 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("Input argument should be of type if handle," + */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 828, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 827, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 828, __pyx_L1_error) + __PYX_ERR(3, 827, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":834 + /* "PyCafe.pyx":833 * * #print("cb complete", self._c_cafe.initCallbackCompleteHandle(handle)) * return self._c_cafe.initCallbackCompleteHandle(handle) # <<<<<<<<<<<<<< @@ -42518,14 +42966,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handle); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 834, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->initCallbackCompleteHandle(__pyx_t_8)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 834, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handle); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 833, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->initCallbackCompleteHandle(__pyx_t_8)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 833, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":806 + /* "PyCafe.pyx":805 * * * def initCallbackComplete(self, handlePV): # <<<<<<<<<<<<<< @@ -42551,7 +42999,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_62initCallbackComplete(struct __pyx_ob return __pyx_r; } -/* "PyCafe.pyx":838 +/* "PyCafe.pyx":837 * * ############################################################################ * def setCallbackGet(self, handlePV, object cb = None): # <<<<<<<<<<<<<< @@ -42595,7 +43043,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_65setCallbackGet(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCallbackGet") < 0)) __PYX_ERR(3, 838, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCallbackGet") < 0)) __PYX_ERR(3, 837, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -42611,7 +43059,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_65setCallbackGet(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setCallbackGet", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 838, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setCallbackGet", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 837, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setCallbackGet", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -42641,7 +43089,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("setCallbackGet", 0); - /* "PyCafe.pyx":840 + /* "PyCafe.pyx":839 * def setCallbackGet(self, handlePV, object cb = None): * * cdef str _METHOD = "setCallbackGet" # <<<<<<<<<<<<<< @@ -42651,17 +43099,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_setCallbackGet); __pyx_v__METHOD = __pyx_n_u_setCallbackGet; - /* "PyCafe.pyx":843 + /* "PyCafe.pyx":842 * * cdef ChannelRequestPolicy crp * self.ph.getChannelRequestPolicyGet(handlePV, crp) # <<<<<<<<<<<<<< * * if isinstance(handlePV, (int, long)): */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 843, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 842, __pyx_L1_error) (void)(__pyx_v_self->ph.getChannelRequestPolicyGet(__pyx_t_1, __pyx_v_crp)); - /* "PyCafe.pyx":845 + /* "PyCafe.pyx":844 * self.ph.getChannelRequestPolicyGet(handlePV, crp) * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -42682,7 +43130,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":846 + /* "PyCafe.pyx":845 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< @@ -42692,7 +43140,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_v_handlePV); __pyx_v_handle = __pyx_v_handlePV; - /* "PyCafe.pyx":845 + /* "PyCafe.pyx":844 * self.ph.getChannelRequestPolicyGet(handlePV, crp) * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -42702,7 +43150,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":847 + /* "PyCafe.pyx":846 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -42713,20 +43161,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":848 + /* "PyCafe.pyx":847 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 848, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 848, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 847, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 847, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_handle = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":847 + /* "PyCafe.pyx":846 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -42736,7 +43184,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":850 + /* "PyCafe.pyx":849 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -42744,10 +43192,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC * "First input argument should be of type if handle, \ */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 850, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":851 + /* "PyCafe.pyx":850 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -42769,7 +43217,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_2}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 850, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 849, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -42777,13 +43225,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_2}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 850, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 849, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 850, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -42797,29 +43245,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_2); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_2); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_2); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 850, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":850 + /* "PyCafe.pyx":849 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument should be of type if handle, \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 850, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 850, __pyx_L1_error) + __PYX_ERR(3, 849, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":855 + /* "PyCafe.pyx":854 * else if PV")) * * if cb is not None: # <<<<<<<<<<<<<< @@ -42830,7 +43278,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":856 + /* "PyCafe.pyx":855 * * if cb is not None: * crp.setPyHandlerGet(cb) # forces when=WITH_CALLBACK_USER_SUPPLIED # <<<<<<<<<<<<<< @@ -42839,7 +43287,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC */ __pyx_v_crp.setPyHandlerGet(((void *)__pyx_v_cb)); - /* "PyCafe.pyx":855 + /* "PyCafe.pyx":854 * else if PV")) * * if cb is not None: # <<<<<<<<<<<<<< @@ -42849,7 +43297,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC goto __pyx_L6; } - /* "PyCafe.pyx":858 + /* "PyCafe.pyx":857 * crp.setPyHandlerGet(cb) # forces when=WITH_CALLBACK_USER_SUPPLIED * else: * crp.setMethodKind(WITH_CALLBACK_DEFAULT) # <<<<<<<<<<<<<< @@ -42861,17 +43309,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC } __pyx_L6:; - /* "PyCafe.pyx":860 + /* "PyCafe.pyx":859 * crp.setMethodKind(WITH_CALLBACK_DEFAULT) * * self.ph.setChannelRequestPolicyGet(handlePV, crp) # <<<<<<<<<<<<<< * return * ############################################################################ */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 860, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 859, __pyx_L1_error) (void)(__pyx_v_self->ph.setChannelRequestPolicyGet(__pyx_t_1, __pyx_v_crp)); - /* "PyCafe.pyx":861 + /* "PyCafe.pyx":860 * * self.ph.setChannelRequestPolicyGet(handlePV, crp) * return # <<<<<<<<<<<<<< @@ -42882,7 +43330,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":838 + /* "PyCafe.pyx":837 * * ############################################################################ * def setCallbackGet(self, handlePV, object cb = None): # <<<<<<<<<<<<<< @@ -42908,7 +43356,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_64setCallbackGet(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":865 +/* "PyCafe.pyx":864 * * ############################################################################ * def setCallbackPut(self, handlePV, object cb=None): # <<<<<<<<<<<<<< @@ -42952,7 +43400,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_67setCallbackPut(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCallbackPut") < 0)) __PYX_ERR(3, 865, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCallbackPut") < 0)) __PYX_ERR(3, 864, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -42968,7 +43416,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_67setCallbackPut(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setCallbackPut", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 865, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setCallbackPut", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 864, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setCallbackPut", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -42998,7 +43446,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("setCallbackPut", 0); - /* "PyCafe.pyx":867 + /* "PyCafe.pyx":866 * def setCallbackPut(self, handlePV, object cb=None): * * cdef str _METHOD = "setCallbackPut" # <<<<<<<<<<<<<< @@ -43008,17 +43456,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_setCallbackPut); __pyx_v__METHOD = __pyx_n_u_setCallbackPut; - /* "PyCafe.pyx":870 + /* "PyCafe.pyx":869 * * cdef ChannelRequestPolicy crp * self.ph.getChannelRequestPolicyPut(handlePV, crp) # <<<<<<<<<<<<<< * * if isinstance(handlePV, (int, long)): */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 870, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 869, __pyx_L1_error) (void)(__pyx_v_self->ph.getChannelRequestPolicyPut(__pyx_t_1, __pyx_v_crp)); - /* "PyCafe.pyx":872 + /* "PyCafe.pyx":871 * self.ph.getChannelRequestPolicyPut(handlePV, crp) * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -43039,7 +43487,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":873 + /* "PyCafe.pyx":872 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< @@ -43049,7 +43497,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_v_handlePV); __pyx_v_handle = __pyx_v_handlePV; - /* "PyCafe.pyx":872 + /* "PyCafe.pyx":871 * self.ph.getChannelRequestPolicyPut(handlePV, crp) * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -43059,7 +43507,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":874 + /* "PyCafe.pyx":873 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -43070,20 +43518,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":875 + /* "PyCafe.pyx":874 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 875, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 875, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 874, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 874, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_handle = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":874 + /* "PyCafe.pyx":873 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -43093,7 +43541,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":877 + /* "PyCafe.pyx":876 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -43101,10 +43549,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC * "First input argument, should be of type if handle, \ */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 877, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":878 + /* "PyCafe.pyx":877 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -43126,7 +43574,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 877, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 876, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -43134,13 +43582,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 877, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 876, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 877, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -43154,29 +43602,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_3); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_3); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_3); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 877, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":877 + /* "PyCafe.pyx":876 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be of type if handle, \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 877, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 877, __pyx_L1_error) + __PYX_ERR(3, 876, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":882 + /* "PyCafe.pyx":881 * else if PV")) * * if cb is not None: # <<<<<<<<<<<<<< @@ -43187,7 +43635,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":883 + /* "PyCafe.pyx":882 * * if cb is not None: * crp.setPyHandlerPut(cb) # forces when=WITH_CALLBACK_USER_SUPPLIED # <<<<<<<<<<<<<< @@ -43196,7 +43644,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC */ __pyx_v_crp.setPyHandlerPut(((void *)__pyx_v_cb)); - /* "PyCafe.pyx":882 + /* "PyCafe.pyx":881 * else if PV")) * * if cb is not None: # <<<<<<<<<<<<<< @@ -43206,7 +43654,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC goto __pyx_L6; } - /* "PyCafe.pyx":885 + /* "PyCafe.pyx":884 * crp.setPyHandlerPut(cb) # forces when=WITH_CALLBACK_USER_SUPPLIED * else: * crp.setMethodKind(WITH_CALLBACK_DEFAULT) # <<<<<<<<<<<<<< @@ -43218,17 +43666,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC } __pyx_L6:; - /* "PyCafe.pyx":887 + /* "PyCafe.pyx":886 * crp.setMethodKind(WITH_CALLBACK_DEFAULT) * * self.ph.setChannelRequestPolicyPut(handlePV, crp) # <<<<<<<<<<<<<< * return * ############################################################################ */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 887, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 886, __pyx_L1_error) (void)(__pyx_v_self->ph.setChannelRequestPolicyPut(__pyx_t_1, __pyx_v_crp)); - /* "PyCafe.pyx":888 + /* "PyCafe.pyx":887 * * self.ph.setChannelRequestPolicyPut(handlePV, crp) * return # <<<<<<<<<<<<<< @@ -43239,7 +43687,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":865 + /* "PyCafe.pyx":864 * * ############################################################################ * def setCallbackPut(self, handlePV, object cb=None): # <<<<<<<<<<<<<< @@ -43265,7 +43713,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_66setCallbackPut(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":892 +/* "PyCafe.pyx":891 * * ############################################################################ * def setTimeout(self, timeout): # <<<<<<<<<<<<<< @@ -43293,7 +43741,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_68setTimeout(struct __pyx_obj_6PyCafe_ PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("setTimeout", 0); - /* "PyCafe.pyx":893 + /* "PyCafe.pyx":892 * ############################################################################ * def setTimeout(self, timeout): * return self.ph.setTimeout(timeout) # <<<<<<<<<<<<<< @@ -43301,14 +43749,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_68setTimeout(struct __pyx_obj_6PyCafe_ * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_timeout); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 893, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setTimeout(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 893, __pyx_L1_error) + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_timeout); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 892, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setTimeout(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":892 + /* "PyCafe.pyx":891 * * ############################################################################ * def setTimeout(self, timeout): # <<<<<<<<<<<<<< @@ -43329,7 +43777,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_68setTimeout(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":897 +/* "PyCafe.pyx":896 * * ############################################################################ * def getTimeoutGet(self): # <<<<<<<<<<<<<< @@ -43360,7 +43808,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getTimeoutGet", 0); - /* "PyCafe.pyx":899 + /* "PyCafe.pyx":898 * def getTimeoutGet(self): * cdef double minValue, p, g * minValue = 0 # <<<<<<<<<<<<<< @@ -43369,7 +43817,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa */ __pyx_v_minValue = 0.0; - /* "PyCafe.pyx":900 + /* "PyCafe.pyx":899 * cdef double minValue, p, g * minValue = 0 * p = 0 # <<<<<<<<<<<<<< @@ -43378,7 +43826,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa */ __pyx_v_p = 0.0; - /* "PyCafe.pyx":901 + /* "PyCafe.pyx":900 * minValue = 0 * p = 0 * g = 0 # <<<<<<<<<<<<<< @@ -43387,7 +43835,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa */ __pyx_v_g = 0.0; - /* "PyCafe.pyx":902 + /* "PyCafe.pyx":901 * p = 0 * g = 0 * self.ph.getTimeoutMin(p, g) # <<<<<<<<<<<<<< @@ -43396,7 +43844,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa */ (void)(__pyx_v_self->ph.getTimeoutMin(__pyx_v_p, __pyx_v_g)); - /* "PyCafe.pyx":903 + /* "PyCafe.pyx":902 * g = 0 * self.ph.getTimeoutMin(p, g) * minValue = g # <<<<<<<<<<<<<< @@ -43405,7 +43853,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa */ __pyx_v_minValue = __pyx_v_g; - /* "PyCafe.pyx":904 + /* "PyCafe.pyx":903 * self.ph.getTimeoutMin(p, g) * minValue = g * self.ph.getTimeoutMax(p, g) # <<<<<<<<<<<<<< @@ -43414,7 +43862,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa */ (void)(__pyx_v_self->ph.getTimeoutMax(__pyx_v_p, __pyx_v_g)); - /* "PyCafe.pyx":905 + /* "PyCafe.pyx":904 * minValue = g * self.ph.getTimeoutMax(p, g) * if (g < minValue): # <<<<<<<<<<<<<< @@ -43424,7 +43872,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa __pyx_t_1 = ((__pyx_v_g < __pyx_v_minValue) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":906 + /* "PyCafe.pyx":905 * self.ph.getTimeoutMax(p, g) * if (g < minValue): * minValue = g # <<<<<<<<<<<<<< @@ -43433,7 +43881,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa */ __pyx_v_minValue = __pyx_v_g; - /* "PyCafe.pyx":905 + /* "PyCafe.pyx":904 * minValue = g * self.ph.getTimeoutMax(p, g) * if (g < minValue): # <<<<<<<<<<<<<< @@ -43442,7 +43890,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":907 + /* "PyCafe.pyx":906 * if (g < minValue): * minValue = g * return minValue # <<<<<<<<<<<<<< @@ -43450,13 +43898,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_minValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 907, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_minValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 906, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":897 + /* "PyCafe.pyx":896 * * ############################################################################ * def getTimeoutGet(self): # <<<<<<<<<<<<<< @@ -43477,7 +43925,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_70getTimeoutGet(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":912 +/* "PyCafe.pyx":911 * ############################################################################ * * def getTimeoutPut(self): # <<<<<<<<<<<<<< @@ -43508,7 +43956,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getTimeoutPut", 0); - /* "PyCafe.pyx":914 + /* "PyCafe.pyx":913 * def getTimeoutPut(self): * cdef double minValue, p, g * minValue = 0 # <<<<<<<<<<<<<< @@ -43517,7 +43965,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa */ __pyx_v_minValue = 0.0; - /* "PyCafe.pyx":915 + /* "PyCafe.pyx":914 * cdef double minValue, p, g * minValue = 0 * p = 0 # <<<<<<<<<<<<<< @@ -43526,7 +43974,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa */ __pyx_v_p = 0.0; - /* "PyCafe.pyx":916 + /* "PyCafe.pyx":915 * minValue = 0 * p = 0 * g = 0 # <<<<<<<<<<<<<< @@ -43535,7 +43983,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa */ __pyx_v_g = 0.0; - /* "PyCafe.pyx":917 + /* "PyCafe.pyx":916 * p = 0 * g = 0 * self.ph.getTimeoutMin(p, g) # <<<<<<<<<<<<<< @@ -43544,7 +43992,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa */ (void)(__pyx_v_self->ph.getTimeoutMin(__pyx_v_p, __pyx_v_g)); - /* "PyCafe.pyx":918 + /* "PyCafe.pyx":917 * g = 0 * self.ph.getTimeoutMin(p, g) * minValue = p # <<<<<<<<<<<<<< @@ -43553,7 +44001,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa */ __pyx_v_minValue = __pyx_v_p; - /* "PyCafe.pyx":919 + /* "PyCafe.pyx":918 * self.ph.getTimeoutMin(p, g) * minValue = p * self.ph.getTimeoutMax(p, g) # <<<<<<<<<<<<<< @@ -43562,7 +44010,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa */ (void)(__pyx_v_self->ph.getTimeoutMax(__pyx_v_p, __pyx_v_g)); - /* "PyCafe.pyx":920 + /* "PyCafe.pyx":919 * minValue = p * self.ph.getTimeoutMax(p, g) * if (p < minValue): # <<<<<<<<<<<<<< @@ -43572,7 +44020,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa __pyx_t_1 = ((__pyx_v_p < __pyx_v_minValue) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":921 + /* "PyCafe.pyx":920 * self.ph.getTimeoutMax(p, g) * if (p < minValue): * minValue = g # <<<<<<<<<<<<<< @@ -43581,7 +44029,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa */ __pyx_v_minValue = __pyx_v_g; - /* "PyCafe.pyx":920 + /* "PyCafe.pyx":919 * minValue = p * self.ph.getTimeoutMax(p, g) * if (p < minValue): # <<<<<<<<<<<<<< @@ -43590,7 +44038,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":922 + /* "PyCafe.pyx":921 * if (p < minValue): * minValue = g * return minValue # <<<<<<<<<<<<<< @@ -43598,13 +44046,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_minValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 922, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_minValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":912 + /* "PyCafe.pyx":911 * ############################################################################ * * def getTimeoutPut(self): # <<<<<<<<<<<<<< @@ -43625,7 +44073,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_72getTimeoutPut(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":927 +/* "PyCafe.pyx":926 * ############################################################################ * * def setSelfGoverningTimeout(self, bint b): # <<<<<<<<<<<<<< @@ -43641,7 +44089,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_75setSelfGoverningTimeout(PyObject *__ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setSelfGoverningTimeout (wrapper)", 0); assert(__pyx_arg_b); { - __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 927, __pyx_L3_error) + __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 926, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -43662,7 +44110,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_74setSelfGoverningTimeout(struct __pyx PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("setSelfGoverningTimeout", 0); - /* "PyCafe.pyx":928 + /* "PyCafe.pyx":927 * * def setSelfGoverningTimeout(self, bint b): * return self.ph.setSelfGoverningTimeout(b) # <<<<<<<<<<<<<< @@ -43670,13 +44118,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_74setSelfGoverningTimeout(struct __pyx * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setSelfGoverningTimeout(__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 928, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setSelfGoverningTimeout(__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 927, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":927 + /* "PyCafe.pyx":926 * ############################################################################ * * def setSelfGoverningTimeout(self, bint b): # <<<<<<<<<<<<<< @@ -43697,7 +44145,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_74setSelfGoverningTimeout(struct __pyx return __pyx_r; } -/* "PyCafe.pyx":934 +/* "PyCafe.pyx":933 * # Synchronous Groups * ############################################################################ * def setSGTimeout(self, double timeout): # <<<<<<<<<<<<<< @@ -43713,7 +44161,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_77setSGTimeout(PyObject *__pyx_v_self, __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setSGTimeout (wrapper)", 0); assert(__pyx_arg_timeout); { - __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 934, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 933, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -43734,7 +44182,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_76setSGTimeout(struct __pyx_obj_6PyCaf PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("setSGTimeout", 0); - /* "PyCafe.pyx":935 + /* "PyCafe.pyx":934 * ############################################################################ * def setSGTimeout(self, double timeout): * return self.ph.setSGTimeout(timeout) # <<<<<<<<<<<<<< @@ -43742,13 +44190,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_76setSGTimeout(struct __pyx_obj_6PyCaf * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setSGTimeout(__pyx_v_timeout)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 935, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setSGTimeout(__pyx_v_timeout)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 934, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":934 + /* "PyCafe.pyx":933 * # Synchronous Groups * ############################################################################ * def setSGTimeout(self, double timeout): # <<<<<<<<<<<<<< @@ -43769,7 +44217,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_76setSGTimeout(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":939 +/* "PyCafe.pyx":938 * * ############################################################################ * def getSGTimeoutGet(self): # <<<<<<<<<<<<<< @@ -43800,7 +44248,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getSGTimeoutGet", 0); - /* "PyCafe.pyx":941 + /* "PyCafe.pyx":940 * def getSGTimeoutGet(self): * cdef double minValue, p, g * minValue = 0 # <<<<<<<<<<<<<< @@ -43809,7 +44257,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py */ __pyx_v_minValue = 0.0; - /* "PyCafe.pyx":942 + /* "PyCafe.pyx":941 * cdef double minValue, p, g * minValue = 0 * p = 0 # <<<<<<<<<<<<<< @@ -43818,7 +44266,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py */ __pyx_v_p = 0.0; - /* "PyCafe.pyx":943 + /* "PyCafe.pyx":942 * minValue = 0 * p = 0 * g = 0 # <<<<<<<<<<<<<< @@ -43827,7 +44275,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py */ __pyx_v_g = 0.0; - /* "PyCafe.pyx":944 + /* "PyCafe.pyx":943 * p = 0 * g = 0 * self.ph.getSGTimeoutMin(p, g) # <<<<<<<<<<<<<< @@ -43836,7 +44284,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py */ (void)(__pyx_v_self->ph.getSGTimeoutMin(__pyx_v_p, __pyx_v_g)); - /* "PyCafe.pyx":945 + /* "PyCafe.pyx":944 * g = 0 * self.ph.getSGTimeoutMin(p, g) * minValue = g # <<<<<<<<<<<<<< @@ -43845,7 +44293,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py */ __pyx_v_minValue = __pyx_v_g; - /* "PyCafe.pyx":946 + /* "PyCafe.pyx":945 * self.ph.getSGTimeoutMin(p, g) * minValue = g * self.ph.getSGTimeoutMax(p, g) # <<<<<<<<<<<<<< @@ -43854,7 +44302,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py */ (void)(__pyx_v_self->ph.getSGTimeoutMax(__pyx_v_p, __pyx_v_g)); - /* "PyCafe.pyx":947 + /* "PyCafe.pyx":946 * minValue = g * self.ph.getSGTimeoutMax(p, g) * if (g < minValue): # <<<<<<<<<<<<<< @@ -43864,7 +44312,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py __pyx_t_1 = ((__pyx_v_g < __pyx_v_minValue) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":948 + /* "PyCafe.pyx":947 * self.ph.getSGTimeoutMax(p, g) * if (g < minValue): * minValue = g # <<<<<<<<<<<<<< @@ -43873,7 +44321,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py */ __pyx_v_minValue = __pyx_v_g; - /* "PyCafe.pyx":947 + /* "PyCafe.pyx":946 * minValue = g * self.ph.getSGTimeoutMax(p, g) * if (g < minValue): # <<<<<<<<<<<<<< @@ -43882,7 +44330,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":950 + /* "PyCafe.pyx":949 * minValue = g * * return minValue # <<<<<<<<<<<<<< @@ -43890,13 +44338,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_minValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 950, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_minValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":939 + /* "PyCafe.pyx":938 * * ############################################################################ * def getSGTimeoutGet(self): # <<<<<<<<<<<<<< @@ -43917,7 +44365,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_78getSGTimeoutGet(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":954 +/* "PyCafe.pyx":953 * * ############################################################################ * def getSGTimeoutPut(self): # <<<<<<<<<<<<<< @@ -43948,7 +44396,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getSGTimeoutPut", 0); - /* "PyCafe.pyx":956 + /* "PyCafe.pyx":955 * def getSGTimeoutPut(self): * cdef double minValue, p, g * minValue = 0 # <<<<<<<<<<<<<< @@ -43957,7 +44405,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py */ __pyx_v_minValue = 0.0; - /* "PyCafe.pyx":957 + /* "PyCafe.pyx":956 * cdef double minValue, p, g * minValue = 0 * p = 0 # <<<<<<<<<<<<<< @@ -43966,7 +44414,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py */ __pyx_v_p = 0.0; - /* "PyCafe.pyx":958 + /* "PyCafe.pyx":957 * minValue = 0 * p = 0 * g = 0 # <<<<<<<<<<<<<< @@ -43975,7 +44423,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py */ __pyx_v_g = 0.0; - /* "PyCafe.pyx":959 + /* "PyCafe.pyx":958 * p = 0 * g = 0 * self.ph.getSGTimeoutMin(p, g) # <<<<<<<<<<<<<< @@ -43984,7 +44432,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py */ (void)(__pyx_v_self->ph.getSGTimeoutMin(__pyx_v_p, __pyx_v_g)); - /* "PyCafe.pyx":960 + /* "PyCafe.pyx":959 * g = 0 * self.ph.getSGTimeoutMin(p, g) * minValue = p # <<<<<<<<<<<<<< @@ -43993,7 +44441,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py */ __pyx_v_minValue = __pyx_v_p; - /* "PyCafe.pyx":961 + /* "PyCafe.pyx":960 * self.ph.getSGTimeoutMin(p, g) * minValue = p * self.ph.getSGTimeoutMax(p, g) # <<<<<<<<<<<<<< @@ -44002,7 +44450,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py */ (void)(__pyx_v_self->ph.getSGTimeoutMax(__pyx_v_p, __pyx_v_g)); - /* "PyCafe.pyx":962 + /* "PyCafe.pyx":961 * minValue = p * self.ph.getSGTimeoutMax(p, g) * if (p < minValue): # <<<<<<<<<<<<<< @@ -44012,7 +44460,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py __pyx_t_1 = ((__pyx_v_p < __pyx_v_minValue) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":963 + /* "PyCafe.pyx":962 * self.ph.getSGTimeoutMax(p, g) * if (p < minValue): * minValue = p # <<<<<<<<<<<<<< @@ -44021,7 +44469,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py */ __pyx_v_minValue = __pyx_v_p; - /* "PyCafe.pyx":962 + /* "PyCafe.pyx":961 * minValue = p * self.ph.getSGTimeoutMax(p, g) * if (p < minValue): # <<<<<<<<<<<<<< @@ -44030,7 +44478,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":965 + /* "PyCafe.pyx":964 * minValue = p * * return minValue # <<<<<<<<<<<<<< @@ -44038,13 +44486,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_minValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 965, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_minValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 964, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":954 + /* "PyCafe.pyx":953 * * ############################################################################ * def getSGTimeoutPut(self): # <<<<<<<<<<<<<< @@ -44065,7 +44513,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_80getSGTimeoutPut(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":969 +/* "PyCafe.pyx":968 * * ############################################################################ * def setSGSelfGoverningTimeout(self, bint b): # <<<<<<<<<<<<<< @@ -44081,7 +44529,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_83setSGSelfGoverningTimeout(PyObject * __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setSGSelfGoverningTimeout (wrapper)", 0); assert(__pyx_arg_b); { - __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 969, __pyx_L3_error) + __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 968, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -44103,7 +44551,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_82setSGSelfGoverningTimeout(CYTHON_UNU PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("setSGSelfGoverningTimeout", 0); - /* "PyCafe.pyx":971 + /* "PyCafe.pyx":970 * def setSGSelfGoverningTimeout(self, bint b): * cdef PolicyHelper ph * return ph.setSGSelfGoverningTimeout(b) # <<<<<<<<<<<<<< @@ -44111,13 +44559,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_82setSGSelfGoverningTimeout(CYTHON_UNU * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ph.setSGSelfGoverningTimeout(__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 971, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ph.setSGSelfGoverningTimeout(__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 970, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":969 + /* "PyCafe.pyx":968 * * ############################################################################ * def setSGSelfGoverningTimeout(self, bint b): # <<<<<<<<<<<<<< @@ -44138,7 +44586,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_82setSGSelfGoverningTimeout(CYTHON_UNU return __pyx_r; } -/* "PyCafe.pyx":976 +/* "PyCafe.pyx":975 * ############################################################################ * * def getContext(self, handlePV): # <<<<<<<<<<<<<< @@ -44174,7 +44622,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ PyObject *__pyx_t_7 = NULL; __Pyx_RefNannySetupContext("getContext", 0); - /* "PyCafe.pyx":977 + /* "PyCafe.pyx":976 * * def getContext(self, handlePV): * cdef str _METHOD = "getContext" # <<<<<<<<<<<<<< @@ -44184,7 +44632,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ __Pyx_INCREF(__pyx_n_u_getContext); __pyx_v__METHOD = __pyx_n_u_getContext; - /* "PyCafe.pyx":979 + /* "PyCafe.pyx":978 * cdef str _METHOD = "getContext" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -44193,7 +44641,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ */ __pyx_v_handle = 0; - /* "PyCafe.pyx":980 + /* "PyCafe.pyx":979 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -44214,7 +44662,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":981 + /* "PyCafe.pyx":980 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * return < long > self.hh.getContextFromHandle(handlePV) # <<<<<<<<<<<<<< @@ -44222,14 +44670,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ * return < long > self.hh.getContextFromPV(handlePV) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 981, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_long(((long)__pyx_v_self->hh.getContextFromHandle(__pyx_t_4))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 981, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 980, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_long(((long)__pyx_v_self->hh.getContextFromHandle(__pyx_t_4))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 980, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":980 + /* "PyCafe.pyx":979 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -44239,7 +44687,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ goto __pyx_L3; } - /* "PyCafe.pyx":982 + /* "PyCafe.pyx":981 * if isinstance(handlePV, (int, long)): * return < long > self.hh.getContextFromHandle(handlePV) * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -44250,7 +44698,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":983 + /* "PyCafe.pyx":982 * return < long > self.hh.getContextFromHandle(handlePV) * elif isinstance(handlePV, (str)): * return < long > self.hh.getContextFromPV(handlePV) # <<<<<<<<<<<<<< @@ -44258,14 +44706,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ * _cafeException = CafeException( */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_handlePV); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(3, 983, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_long(((long)__pyx_v_self->hh.getContextFromPV(__pyx_t_6))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 983, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_handlePV); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(3, 982, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_long(((long)__pyx_v_self->hh.getContextFromPV(__pyx_t_6))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 982, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":982 + /* "PyCafe.pyx":981 * if isinstance(handlePV, (int, long)): * return < long > self.hh.getContextFromHandle(handlePV) * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -44275,7 +44723,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ goto __pyx_L3; } - /* "PyCafe.pyx":985 + /* "PyCafe.pyx":984 * return < long > self.hh.getContextFromPV(handlePV) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< @@ -44284,33 +44732,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ */ /*else*/ { - /* "PyCafe.pyx":986 + /* "PyCafe.pyx":985 * else: * _cafeException = CafeException( * _type='TypeError', _source=_METHOD, # <<<<<<<<<<<<<< * _error_info=( * "First input argument should be of type if handle, " */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 986, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_TypeError) < 0) __PYX_ERR(3, 986, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 986, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_4) < 0) __PYX_ERR(3, 986, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_TypeError) < 0) __PYX_ERR(3, 985, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 985, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_4) < 0) __PYX_ERR(3, 985, __pyx_L1_error) - /* "PyCafe.pyx":985 + /* "PyCafe.pyx":984 * return < long > self.hh.getContextFromPV(handlePV) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='TypeError', _source=_METHOD, * _error_info=( */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 985, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 984, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":990 + /* "PyCafe.pyx":989 * "First input argument should be of type if handle, " * "else if PV")) * raise _cafeException # <<<<<<<<<<<<<< @@ -44318,11 +44766,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 990, __pyx_L1_error) + __PYX_ERR(3, 989, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":976 + /* "PyCafe.pyx":975 * ############################################################################ * * def getContext(self, handlePV): # <<<<<<<<<<<<<< @@ -44346,7 +44794,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_84getContext(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":995 +/* "PyCafe.pyx":994 * ############################################################################ * * def attachContext(self, handlePV): # <<<<<<<<<<<<<< @@ -44384,7 +44832,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa PyObject *__pyx_t_10 = NULL; __Pyx_RefNannySetupContext("attachContext", 0); - /* "PyCafe.pyx":996 + /* "PyCafe.pyx":995 * * def attachContext(self, handlePV): * cdef str _METHOD = "attachContext" # <<<<<<<<<<<<<< @@ -44394,7 +44842,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_n_u_attachContext); __pyx_v__METHOD = __pyx_n_u_attachContext; - /* "PyCafe.pyx":998 + /* "PyCafe.pyx":997 * cdef str _METHOD = "attachContext" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -44403,7 +44851,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa */ __pyx_v_handle = 0; - /* "PyCafe.pyx":999 + /* "PyCafe.pyx":998 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -44424,7 +44872,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1000 + /* "PyCafe.pyx":999 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * return self._c_cafe.attachContextByHandle(handlePV) # <<<<<<<<<<<<<< @@ -44432,14 +44880,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa * return self._c_cafe.attachContextByPVName(handlePV) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1000, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->attachContextByHandle(__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1000, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 999, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->attachContextByHandle(__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 999, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":999 + /* "PyCafe.pyx":998 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -44449,7 +44897,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa goto __pyx_L3; } - /* "PyCafe.pyx":1001 + /* "PyCafe.pyx":1000 * if isinstance(handlePV, (int, long)): * return self._c_cafe.attachContextByHandle(handlePV) * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -44460,7 +44908,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1002 + /* "PyCafe.pyx":1001 * return self._c_cafe.attachContextByHandle(handlePV) * elif isinstance(handlePV, (str)): * return self._c_cafe.attachContextByPVName(handlePV) # <<<<<<<<<<<<<< @@ -44468,14 +44916,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa * raise Exception("{} {} {}".format( */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_handlePV); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(3, 1002, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->attachContextByPVName(__pyx_t_6)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1002, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_handlePV); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(3, 1001, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->attachContextByPVName(__pyx_t_6)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1001 + /* "PyCafe.pyx":1000 * if isinstance(handlePV, (int, long)): * return self._c_cafe.attachContextByHandle(handlePV) * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -44485,7 +44933,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa goto __pyx_L3; } - /* "PyCafe.pyx":1004 + /* "PyCafe.pyx":1003 * return self._c_cafe.attachContextByPVName(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -44493,10 +44941,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa * "First input argument, should be of type if handle, \ */ /*else*/ { - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1004, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "PyCafe.pyx":1005 + /* "PyCafe.pyx":1004 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -44518,7 +44966,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1004, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1003, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -44526,13 +44974,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1004, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1003, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1004, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -44546,29 +44994,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_3); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_3); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_kp_u_First_input_argument_should_be_o_3); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1004, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":1004 + /* "PyCafe.pyx":1003 * return self._c_cafe.attachContextByPVName(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be of type if handle, \ */ - __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1004, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(3, 1004, __pyx_L1_error) + __PYX_ERR(3, 1003, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":995 + /* "PyCafe.pyx":994 * ############################################################################ * * def attachContext(self, handlePV): # <<<<<<<<<<<<<< @@ -44593,7 +45041,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_86attachContext(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":1011 +/* "PyCafe.pyx":1010 * * ############################################################################ * def collectionDefine(self, const char * cName, vector[string] cMembers): # <<<<<<<<<<<<<< @@ -44632,11 +45080,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_89collectionDefine(PyObject *__pyx_v_s case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_cMembers)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("collectionDefine", 1, 2, 2, 1); __PYX_ERR(3, 1011, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("collectionDefine", 1, 2, 2, 1); __PYX_ERR(3, 1010, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "collectionDefine") < 0)) __PYX_ERR(3, 1011, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "collectionDefine") < 0)) __PYX_ERR(3, 1010, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -44644,12 +45092,12 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_89collectionDefine(PyObject *__pyx_v_s values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } - __pyx_v_cName = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_cName) && PyErr_Occurred())) __PYX_ERR(3, 1011, __pyx_L3_error) - __pyx_v_cMembers = __pyx_convert_vector_from_py_std_3a__3a_string(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1011, __pyx_L3_error) + __pyx_v_cName = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_cName) && PyErr_Occurred())) __PYX_ERR(3, 1010, __pyx_L3_error) + __pyx_v_cMembers = __pyx_convert_vector_from_py_std_3a__3a_string(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1010, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("collectionDefine", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1011, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("collectionDefine", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1010, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.collectionDefine", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -44667,7 +45115,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_88collectionDefine(struct __pyx_obj_6P __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("collectionDefine", 0); - /* "PyCafe.pyx":1012 + /* "PyCafe.pyx":1011 * ############################################################################ * def collectionDefine(self, const char * cName, vector[string] cMembers): * with nogil: # <<<<<<<<<<<<<< @@ -44682,7 +45130,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_88collectionDefine(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":1013 + /* "PyCafe.pyx":1012 * def collectionDefine(self, const char * cName, vector[string] cMembers): * with nogil: * self._c_cafe.collectionDefine(cName, cMembers) # <<<<<<<<<<<<<< @@ -44692,7 +45140,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_88collectionDefine(struct __pyx_obj_6P (void)(__pyx_v_self->_c_cafe->collectionDefine(__pyx_v_cName, __pyx_v_cMembers)); } - /* "PyCafe.pyx":1012 + /* "PyCafe.pyx":1011 * ############################################################################ * def collectionDefine(self, const char * cName, vector[string] cMembers): * with nogil: # <<<<<<<<<<<<<< @@ -44711,7 +45159,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_88collectionDefine(struct __pyx_obj_6P } } - /* "PyCafe.pyx":1011 + /* "PyCafe.pyx":1010 * * ############################################################################ * def collectionDefine(self, const char * cName, vector[string] cMembers): # <<<<<<<<<<<<<< @@ -44726,7 +45174,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_88collectionDefine(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":1016 +/* "PyCafe.pyx":1015 * * ############################################################################ * def defineCollection(self, const char * cName, vector[string] cMembers): # <<<<<<<<<<<<<< @@ -44765,11 +45213,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_91defineCollection(PyObject *__pyx_v_s case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_cMembers)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("defineCollection", 1, 2, 2, 1); __PYX_ERR(3, 1016, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("defineCollection", 1, 2, 2, 1); __PYX_ERR(3, 1015, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "defineCollection") < 0)) __PYX_ERR(3, 1016, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "defineCollection") < 0)) __PYX_ERR(3, 1015, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -44777,12 +45225,12 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_91defineCollection(PyObject *__pyx_v_s values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } - __pyx_v_cName = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_cName) && PyErr_Occurred())) __PYX_ERR(3, 1016, __pyx_L3_error) - __pyx_v_cMembers = __pyx_convert_vector_from_py_std_3a__3a_string(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1016, __pyx_L3_error) + __pyx_v_cName = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_cName) && PyErr_Occurred())) __PYX_ERR(3, 1015, __pyx_L3_error) + __pyx_v_cMembers = __pyx_convert_vector_from_py_std_3a__3a_string(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1015, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("defineCollection", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1016, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("defineCollection", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1015, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.defineCollection", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -44800,7 +45248,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_90defineCollection(struct __pyx_obj_6P __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("defineCollection", 0); - /* "PyCafe.pyx":1017 + /* "PyCafe.pyx":1016 * ############################################################################ * def defineCollection(self, const char * cName, vector[string] cMembers): * with nogil: # <<<<<<<<<<<<<< @@ -44815,7 +45263,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_90defineCollection(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":1018 + /* "PyCafe.pyx":1017 * def defineCollection(self, const char * cName, vector[string] cMembers): * with nogil: * self._c_cafe.collectionDefine(cName, cMembers) # <<<<<<<<<<<<<< @@ -44825,7 +45273,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_90defineCollection(struct __pyx_obj_6P (void)(__pyx_v_self->_c_cafe->collectionDefine(__pyx_v_cName, __pyx_v_cMembers)); } - /* "PyCafe.pyx":1017 + /* "PyCafe.pyx":1016 * ############################################################################ * def defineCollection(self, const char * cName, vector[string] cMembers): * with nogil: # <<<<<<<<<<<<<< @@ -44844,7 +45292,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_90defineCollection(struct __pyx_obj_6P } } - /* "PyCafe.pyx":1016 + /* "PyCafe.pyx":1015 * * ############################################################################ * def defineCollection(self, const char * cName, vector[string] cMembers): # <<<<<<<<<<<<<< @@ -44859,7 +45307,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_90defineCollection(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":1021 +/* "PyCafe.pyx":1020 * * ############################################################################ * def collectionList(self): # <<<<<<<<<<<<<< @@ -44887,7 +45335,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_92collectionList(struct __pyx_obj_6PyC PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("collectionList", 0); - /* "PyCafe.pyx":1023 + /* "PyCafe.pyx":1022 * def collectionList(self): * cdef vector[string] collectionList * with nogil: # <<<<<<<<<<<<<< @@ -44902,7 +45350,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_92collectionList(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":1024 + /* "PyCafe.pyx":1023 * cdef vector[string] collectionList * with nogil: * self._c_cafe.collectionList(collectionList) # <<<<<<<<<<<<<< @@ -44912,7 +45360,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_92collectionList(struct __pyx_obj_6PyC (void)(__pyx_v_self->_c_cafe->collectionList(__pyx_v_collectionList)); } - /* "PyCafe.pyx":1023 + /* "PyCafe.pyx":1022 * def collectionList(self): * cdef vector[string] collectionList * with nogil: # <<<<<<<<<<<<<< @@ -44931,7 +45379,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_92collectionList(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":1025 + /* "PyCafe.pyx":1024 * with nogil: * self._c_cafe.collectionList(collectionList) * return collectionList # <<<<<<<<<<<<<< @@ -44939,13 +45387,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_92collectionList(struct __pyx_obj_6PyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_collectionList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1025, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_collectionList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1024, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1021 + /* "PyCafe.pyx":1020 * * ############################################################################ * def collectionList(self): # <<<<<<<<<<<<<< @@ -44966,7 +45414,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_92collectionList(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":1029 +/* "PyCafe.pyx":1028 * * ############################################################################ * def collectionMemberList(self, const char * cName): # <<<<<<<<<<<<<< @@ -44982,7 +45430,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_95collectionMemberList(PyObject *__pyx __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("collectionMemberList (wrapper)", 0); assert(__pyx_arg_cName); { - __pyx_v_cName = __Pyx_PyObject_AsString(__pyx_arg_cName); if (unlikely((!__pyx_v_cName) && PyErr_Occurred())) __PYX_ERR(3, 1029, __pyx_L3_error) + __pyx_v_cName = __Pyx_PyObject_AsString(__pyx_arg_cName); if (unlikely((!__pyx_v_cName) && PyErr_Occurred())) __PYX_ERR(3, 1028, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -45004,7 +45452,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_94collectionMemberList(struct __pyx_ob PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("collectionMemberList", 0); - /* "PyCafe.pyx":1031 + /* "PyCafe.pyx":1030 * def collectionMemberList(self, const char * cName): * cdef vector[string] cMemberList * with nogil: # <<<<<<<<<<<<<< @@ -45019,7 +45467,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_94collectionMemberList(struct __pyx_ob #endif /*try:*/ { - /* "PyCafe.pyx":1032 + /* "PyCafe.pyx":1031 * cdef vector[string] cMemberList * with nogil: * self._c_cafe.collectionMemberList(cName, cMemberList) # <<<<<<<<<<<<<< @@ -45029,7 +45477,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_94collectionMemberList(struct __pyx_ob (void)(__pyx_v_self->_c_cafe->collectionMemberList(__pyx_v_cName, __pyx_v_cMemberList)); } - /* "PyCafe.pyx":1031 + /* "PyCafe.pyx":1030 * def collectionMemberList(self, const char * cName): * cdef vector[string] cMemberList * with nogil: # <<<<<<<<<<<<<< @@ -45048,7 +45496,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_94collectionMemberList(struct __pyx_ob } } - /* "PyCafe.pyx":1033 + /* "PyCafe.pyx":1032 * with nogil: * self._c_cafe.collectionMemberList(cName, cMemberList) * return cMemberList # <<<<<<<<<<<<<< @@ -45056,13 +45504,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_94collectionMemberList(struct __pyx_ob * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_cMemberList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1033, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_cMemberList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1032, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1029 + /* "PyCafe.pyx":1028 * * ############################################################################ * def collectionMemberList(self, const char * cName): # <<<<<<<<<<<<<< @@ -45083,7 +45531,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_94collectionMemberList(struct __pyx_ob return __pyx_r; } -/* "PyCafe.pyx":1052 +/* "PyCafe.pyx":1051 * ############################################################################ * * def devicePositionMap(self, const char * collectionName): # <<<<<<<<<<<<<< @@ -45099,7 +45547,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_97devicePositionMap(PyObject *__pyx_v_ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("devicePositionMap (wrapper)", 0); assert(__pyx_arg_collectionName); { - __pyx_v_collectionName = __Pyx_PyObject_AsString(__pyx_arg_collectionName); if (unlikely((!__pyx_v_collectionName) && PyErr_Occurred())) __PYX_ERR(3, 1052, __pyx_L3_error) + __pyx_v_collectionName = __Pyx_PyObject_AsString(__pyx_arg_collectionName); if (unlikely((!__pyx_v_collectionName) && PyErr_Occurred())) __PYX_ERR(3, 1051, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -45127,31 +45575,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_96devicePositionMap(struct __pyx_obj_6 int __pyx_t_3; __Pyx_RefNannySetupContext("devicePositionMap", 0); - /* "PyCafe.pyx":1053 + /* "PyCafe.pyx":1052 * * def devicePositionMap(self, const char * collectionName): * p = [] # <<<<<<<<<<<<<< * d = [] * cdef map[float, string] mmfs */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1053, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1052, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_p = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1054 + /* "PyCafe.pyx":1053 * def devicePositionMap(self, const char * collectionName): * p = [] * d = [] # <<<<<<<<<<<<<< * cdef map[float, string] mmfs * cdef map[float, string].iterator it */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1054, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1053, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_d = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1057 + /* "PyCafe.pyx":1056 * cdef map[float, string] mmfs * cdef map[float, string].iterator it * self._c_cafe.devicePositionMap(collectionName, mmfs) # <<<<<<<<<<<<<< @@ -45160,7 +45608,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_96devicePositionMap(struct __pyx_obj_6 */ (void)(__pyx_v_self->_c_cafe->devicePositionMap(__pyx_v_collectionName, __pyx_v_mmfs)); - /* "PyCafe.pyx":1058 + /* "PyCafe.pyx":1057 * cdef map[float, string].iterator it * self._c_cafe.devicePositionMap(collectionName, mmfs) * it = mmfs.begin() # <<<<<<<<<<<<<< @@ -45169,7 +45617,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_96devicePositionMap(struct __pyx_obj_6 */ __pyx_v_it = __pyx_v_mmfs.begin(); - /* "PyCafe.pyx":1059 + /* "PyCafe.pyx":1058 * self._c_cafe.devicePositionMap(collectionName, mmfs) * it = mmfs.begin() * tup = () # tuple # <<<<<<<<<<<<<< @@ -45179,7 +45627,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_96devicePositionMap(struct __pyx_obj_6 __Pyx_INCREF(__pyx_empty_tuple); __pyx_v_tup = __pyx_empty_tuple; - /* "PyCafe.pyx":1060 + /* "PyCafe.pyx":1059 * it = mmfs.begin() * tup = () # tuple * while it != mmfs.end(): # <<<<<<<<<<<<<< @@ -45190,43 +45638,43 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_96devicePositionMap(struct __pyx_obj_6 __pyx_t_2 = ((__pyx_v_it != __pyx_v_mmfs.end()) != 0); if (!__pyx_t_2) break; - /* "PyCafe.pyx":1061 + /* "PyCafe.pyx":1060 * tup = () # tuple * while it != mmfs.end(): * tup = deref(it) # <<<<<<<<<<<<<< * p.append(tup[0]) * d.append(tup[1]) */ - __pyx_t_1 = __pyx_convert_pair_to_py_float____std_3a__3a_string((*__pyx_v_it)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1061, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_pair_to_py_float____std_3a__3a_string((*__pyx_v_it)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1060, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_tup, __pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1062 + /* "PyCafe.pyx":1061 * while it != mmfs.end(): * tup = deref(it) * p.append(tup[0]) # <<<<<<<<<<<<<< * d.append(tup[1]) * inc(it) */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_tup, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1062, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_tup, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_p, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1062, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_p, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1061, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1063 + /* "PyCafe.pyx":1062 * tup = deref(it) * p.append(tup[0]) * d.append(tup[1]) # <<<<<<<<<<<<<< * inc(it) * return d, p */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_tup, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1063, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_tup, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1062, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_d, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1063, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_d, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1062, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1064 + /* "PyCafe.pyx":1063 * p.append(tup[0]) * d.append(tup[1]) * inc(it) # <<<<<<<<<<<<<< @@ -45236,7 +45684,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_96devicePositionMap(struct __pyx_obj_6 (void)((++__pyx_v_it)); } - /* "PyCafe.pyx":1065 + /* "PyCafe.pyx":1064 * d.append(tup[1]) * inc(it) * return d, p # <<<<<<<<<<<<<< @@ -45244,7 +45692,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_96devicePositionMap(struct __pyx_obj_6 * def devicePositionV(self, const char * collectionName): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1065, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_d); __Pyx_GIVEREF(__pyx_v_d); @@ -45256,7 +45704,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_96devicePositionMap(struct __pyx_obj_6 __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1052 + /* "PyCafe.pyx":1051 * ############################################################################ * * def devicePositionMap(self, const char * collectionName): # <<<<<<<<<<<<<< @@ -45280,7 +45728,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_96devicePositionMap(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":1067 +/* "PyCafe.pyx":1066 * return d, p * * def devicePositionV(self, const char * collectionName): # <<<<<<<<<<<<<< @@ -45296,7 +45744,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_99devicePositionV(PyObject *__pyx_v_se __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("devicePositionV (wrapper)", 0); assert(__pyx_arg_collectionName); { - __pyx_v_collectionName = __Pyx_PyObject_AsString(__pyx_arg_collectionName); if (unlikely((!__pyx_v_collectionName) && PyErr_Occurred())) __PYX_ERR(3, 1067, __pyx_L3_error) + __pyx_v_collectionName = __Pyx_PyObject_AsString(__pyx_arg_collectionName); if (unlikely((!__pyx_v_collectionName) && PyErr_Occurred())) __PYX_ERR(3, 1066, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -45329,7 +45777,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("devicePositionV", 0); - /* "PyCafe.pyx":1068 + /* "PyCafe.pyx":1067 * * def devicePositionV(self, const char * collectionName): * cdef str _METHOD = "devicePositionV" # <<<<<<<<<<<<<< @@ -45339,7 +45787,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py __Pyx_INCREF(__pyx_n_u_devicePositionV); __pyx_v__METHOD = __pyx_n_u_devicePositionV; - /* "PyCafe.pyx":1073 + /* "PyCafe.pyx":1072 * cdef vector[string] dev * cdef vector[float] pos * status = self._c_cafe.devicePositionV(collectionName, dev, pos) # <<<<<<<<<<<<<< @@ -45348,7 +45796,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py */ __pyx_v_status = __pyx_v_self->_c_cafe->devicePositionV(__pyx_v_collectionName, __pyx_v_dev, __pyx_v_pos); - /* "PyCafe.pyx":1075 + /* "PyCafe.pyx":1074 * status = self._c_cafe.devicePositionV(collectionName, dev, pos) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -45358,28 +45806,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1076 + /* "PyCafe.pyx":1075 * * if status != ICAFE_NORMAL: * raise Exception("{} {} {} {} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "status=", status, self.cs.code(status), self.cs.code(status))) */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__41, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1076, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__41, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "PyCafe.pyx":1078 + /* "PyCafe.pyx":1077 * raise Exception("{} {} {} {} {} {}".format( * self._exception_text, _METHOD, * "status=", status, self.cs.code(status), self.cs.code(status))) # <<<<<<<<<<<<<< * * # for i in range (0, dev.size()): */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1078, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1077, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1078, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1077, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1078, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1077, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -45396,7 +45844,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[7] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_status_4, __pyx_t_4, __pyx_t_5, __pyx_t_6}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 6+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1076, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 6+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1075, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -45407,7 +45855,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[7] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_status_4, __pyx_t_4, __pyx_t_5, __pyx_t_6}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 6+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1076, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 6+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1075, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -45416,7 +45864,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py } else #endif { - __pyx_t_9 = PyTuple_New(6+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1076, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(6+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -45439,27 +45887,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1076, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":1076 + /* "PyCafe.pyx":1075 * * if status != ICAFE_NORMAL: * raise Exception("{} {} {} {} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "status=", status, self.cs.code(status), self.cs.code(status))) */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1076, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 1076, __pyx_L1_error) + __PYX_ERR(3, 1075, __pyx_L1_error) - /* "PyCafe.pyx":1075 + /* "PyCafe.pyx":1074 * status = self._c_cafe.devicePositionV(collectionName, dev, pos) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -45468,7 +45916,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":1083 + /* "PyCafe.pyx":1082 * # d.append(dev[i]) * # p.append(pos[i]) * return dev, pos # <<<<<<<<<<<<<< @@ -45476,11 +45924,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_dev); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1083, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_dev); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1082, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __pyx_convert_vector_to_py_float(__pyx_v_pos); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1083, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_float(__pyx_v_pos); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1082, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1083, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1082, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_3); @@ -45492,7 +45940,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py __pyx_t_9 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1067 + /* "PyCafe.pyx":1066 * return d, p * * def devicePositionV(self, const char * collectionName): # <<<<<<<<<<<<<< @@ -45520,7 +45968,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_98devicePositionV(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":1087 +/* "PyCafe.pyx":1086 * ############################################################################ * * def groupList(self): # <<<<<<<<<<<<<< @@ -45548,7 +45996,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_100groupList(struct __pyx_obj_6PyCafe_ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("groupList", 0); - /* "PyCafe.pyx":1090 + /* "PyCafe.pyx":1089 * cdef vector[string] gList * # conservative guess * gList.reserve(36) # <<<<<<<<<<<<<< @@ -45557,7 +46005,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_100groupList(struct __pyx_obj_6PyCafe_ */ __pyx_v_gList.reserve(36); - /* "PyCafe.pyx":1092 + /* "PyCafe.pyx":1091 * gList.reserve(36) * * self._c_cafe.groupList(gList) # <<<<<<<<<<<<<< @@ -45566,7 +46014,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_100groupList(struct __pyx_obj_6PyCafe_ */ (void)(__pyx_v_self->_c_cafe->groupList(__pyx_v_gList)); - /* "PyCafe.pyx":1099 + /* "PyCafe.pyx":1098 * # for i in range (0, len(gList)): * # gl.append(gList[i]) * return gList # <<<<<<<<<<<<<< @@ -45574,13 +46022,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_100groupList(struct __pyx_obj_6PyCafe_ * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_gList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1099, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_gList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1098, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1087 + /* "PyCafe.pyx":1086 * ############################################################################ * * def groupList(self): # <<<<<<<<<<<<<< @@ -45601,7 +46049,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_100groupList(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":1102 +/* "PyCafe.pyx":1101 * ############################################################################ * * def getDataTypeNative(self, handlePV): # <<<<<<<<<<<<<< @@ -45639,7 +46087,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("getDataTypeNative", 0); - /* "PyCafe.pyx":1103 + /* "PyCafe.pyx":1102 * * def getDataTypeNative(self, handlePV): * cdef str _METHOD = "getDataTypeNative" # <<<<<<<<<<<<<< @@ -45649,7 +46097,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ __Pyx_INCREF(__pyx_n_u_getDataTypeNative); __pyx_v__METHOD = __pyx_n_u_getDataTypeNative; - /* "PyCafe.pyx":1104 + /* "PyCafe.pyx":1103 * def getDataTypeNative(self, handlePV): * cdef str _METHOD = "getDataTypeNative" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -45658,7 +46106,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1105 + /* "PyCafe.pyx":1104 * cdef str _METHOD = "getDataTypeNative" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -45679,17 +46127,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1106 + /* "PyCafe.pyx":1105 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1106, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1105, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1105 + /* "PyCafe.pyx":1104 * cdef str _METHOD = "getDataTypeNative" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -45699,7 +46147,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ goto __pyx_L3; } - /* "PyCafe.pyx":1107 + /* "PyCafe.pyx":1106 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -45710,21 +46158,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1108 + /* "PyCafe.pyx":1107 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1108, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1108, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1107, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1108, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1107, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1107 + /* "PyCafe.pyx":1106 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -45734,7 +46182,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ goto __pyx_L3; } - /* "PyCafe.pyx":1110 + /* "PyCafe.pyx":1109 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -45742,10 +46190,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ * "First input argument, should be of type if handle, \ */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1110, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1111 + /* "PyCafe.pyx":1110 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -45767,7 +46215,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1110, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1109, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -45775,13 +46223,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1110, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1109, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1110, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -45795,29 +46243,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_3); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_3); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_3); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1110, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1110 + /* "PyCafe.pyx":1109 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be of type if handle, \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1110, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1110, __pyx_L1_error) + __PYX_ERR(3, 1109, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1115 + /* "PyCafe.pyx":1114 * else if PV")) * * cdef long ndt = -1 # <<<<<<<<<<<<<< @@ -45826,7 +46274,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ */ __pyx_v_ndt = -1L; - /* "PyCafe.pyx":1117 + /* "PyCafe.pyx":1116 * cdef long ndt = -1 * * self.hh.getDataTypeNative(handle, ndt) # <<<<<<<<<<<<<< @@ -45835,7 +46283,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ */ (void)(__pyx_v_self->hh.getDataTypeNative(__pyx_v_handle, __pyx_v_ndt)); - /* "PyCafe.pyx":1118 + /* "PyCafe.pyx":1117 * * self.hh.getDataTypeNative(handle, ndt) * return ndt # <<<<<<<<<<<<<< @@ -45843,13 +46291,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ * def getDataTypeRequest(self, handlePV): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_long(__pyx_v_ndt); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1118, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_long(__pyx_v_ndt); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1102 + /* "PyCafe.pyx":1101 * ############################################################################ * * def getDataTypeNative(self, handlePV): # <<<<<<<<<<<<<< @@ -45874,7 +46322,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_102getDataTypeNative(struct __pyx_obj_ return __pyx_r; } -/* "PyCafe.pyx":1120 +/* "PyCafe.pyx":1119 * return ndt * * def getDataTypeRequest(self, handlePV): # <<<<<<<<<<<<<< @@ -45912,7 +46360,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("getDataTypeRequest", 0); - /* "PyCafe.pyx":1121 + /* "PyCafe.pyx":1120 * * def getDataTypeRequest(self, handlePV): * cdef str _METHOD = "getDataTypeRequest" # <<<<<<<<<<<<<< @@ -45922,7 +46370,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj __Pyx_INCREF(__pyx_n_u_getDataTypeRequest); __pyx_v__METHOD = __pyx_n_u_getDataTypeRequest; - /* "PyCafe.pyx":1122 + /* "PyCafe.pyx":1121 * def getDataTypeRequest(self, handlePV): * cdef str _METHOD = "getDataTypeRequest" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -45931,7 +46379,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1123 + /* "PyCafe.pyx":1122 * cdef str _METHOD = "getDataTypeRequest" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -45952,17 +46400,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1124 + /* "PyCafe.pyx":1123 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1124, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1123, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1123 + /* "PyCafe.pyx":1122 * cdef str _METHOD = "getDataTypeRequest" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -45972,7 +46420,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj goto __pyx_L3; } - /* "PyCafe.pyx":1125 + /* "PyCafe.pyx":1124 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -45983,21 +46431,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1126 + /* "PyCafe.pyx":1125 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1126, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1126, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1125, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1126, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1125, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1125 + /* "PyCafe.pyx":1124 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -46007,7 +46455,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj goto __pyx_L3; } - /* "PyCafe.pyx":1128 + /* "PyCafe.pyx":1127 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -46015,10 +46463,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj * "First input argument, should be of type if handle,\ */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1128, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1129 + /* "PyCafe.pyx":1128 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -46040,7 +46488,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_5}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1128, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1127, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -46048,13 +46496,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_5}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1128, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1127, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1128, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -46068,29 +46516,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_5); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_5); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_5); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1128, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1128 + /* "PyCafe.pyx":1127 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be of type if handle,\ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1128, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1128, __pyx_L1_error) + __PYX_ERR(3, 1127, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1133 + /* "PyCafe.pyx":1132 * else if PV")) * * cdef long rdt = -1 # <<<<<<<<<<<<<< @@ -46099,7 +46547,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj */ __pyx_v_rdt = -1L; - /* "PyCafe.pyx":1134 + /* "PyCafe.pyx":1133 * * cdef long rdt = -1 * self.hh.getDataTypeRequest(handle, rdt) # <<<<<<<<<<<<<< @@ -46108,7 +46556,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj */ (void)(__pyx_v_self->hh.getDataTypeRequest(__pyx_v_handle, __pyx_v_rdt)); - /* "PyCafe.pyx":1135 + /* "PyCafe.pyx":1134 * cdef long rdt = -1 * self.hh.getDataTypeRequest(handle, rdt) * return rdt # <<<<<<<<<<<<<< @@ -46116,13 +46564,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj * def getMonitorIDInCallback(self, handlePV): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_long(__pyx_v_rdt); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1135, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_long(__pyx_v_rdt); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1120 + /* "PyCafe.pyx":1119 * return ndt * * def getDataTypeRequest(self, handlePV): # <<<<<<<<<<<<<< @@ -46147,7 +46595,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_104getDataTypeRequest(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":1137 +/* "PyCafe.pyx":1136 * return rdt * * def getMonitorIDInCallback(self, handlePV): # <<<<<<<<<<<<<< @@ -46184,7 +46632,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("getMonitorIDInCallback", 0); - /* "PyCafe.pyx":1138 + /* "PyCafe.pyx":1137 * * def getMonitorIDInCallback(self, handlePV): * cdef str _METHOD = "getMonitorIDInCallback" # <<<<<<<<<<<<<< @@ -46194,7 +46642,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx __Pyx_INCREF(__pyx_n_u_getMonitorIDInCallback); __pyx_v__METHOD = __pyx_n_u_getMonitorIDInCallback; - /* "PyCafe.pyx":1139 + /* "PyCafe.pyx":1138 * def getMonitorIDInCallback(self, handlePV): * cdef str _METHOD = "getMonitorIDInCallback" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -46203,7 +46651,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1140 + /* "PyCafe.pyx":1139 * cdef str _METHOD = "getMonitorIDInCallback" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -46224,17 +46672,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1141 + /* "PyCafe.pyx":1140 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1141, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1140, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1140 + /* "PyCafe.pyx":1139 * cdef str _METHOD = "getMonitorIDInCallback" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -46244,7 +46692,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx goto __pyx_L3; } - /* "PyCafe.pyx":1142 + /* "PyCafe.pyx":1141 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -46255,21 +46703,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1143 + /* "PyCafe.pyx":1142 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1143, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1143, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1142, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1143, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1142, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1142 + /* "PyCafe.pyx":1141 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -46279,7 +46727,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx goto __pyx_L3; } - /* "PyCafe.pyx":1145 + /* "PyCafe.pyx":1144 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -46287,10 +46735,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx * "First input argument, should be of type if handle, \ */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1145, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1146 + /* "PyCafe.pyx":1145 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -46312,7 +46760,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1145, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1144, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -46320,13 +46768,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1145, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1144, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1145, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -46340,29 +46788,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_3); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_3); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_3); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1145, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1145 + /* "PyCafe.pyx":1144 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be of type if handle, \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1145, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1145, __pyx_L1_error) + __PYX_ERR(3, 1144, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1149 + /* "PyCafe.pyx":1148 * "First input argument, should be of type if handle, \ * else if PV")) * return self.hh.getUsrArgsAsUInt(handle) # <<<<<<<<<<<<<< @@ -46370,13 +46818,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx * def getDataTypeInCallback(self, handlePV): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getUsrArgsAsUInt(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1149, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getUsrArgsAsUInt(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1137 + /* "PyCafe.pyx":1136 * return rdt * * def getMonitorIDInCallback(self, handlePV): # <<<<<<<<<<<<<< @@ -46401,7 +46849,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_106getMonitorIDInCallback(struct __pyx return __pyx_r; } -/* "PyCafe.pyx":1151 +/* "PyCafe.pyx":1150 * return self.hh.getUsrArgsAsUInt(handle) * * def getDataTypeInCallback(self, handlePV): # <<<<<<<<<<<<<< @@ -46438,7 +46886,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("getDataTypeInCallback", 0); - /* "PyCafe.pyx":1152 + /* "PyCafe.pyx":1151 * * def getDataTypeInCallback(self, handlePV): * cdef str _METHOD = "getDataTypeInCallback" # <<<<<<<<<<<<<< @@ -46448,7 +46896,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ __Pyx_INCREF(__pyx_n_u_getDataTypeInCallback); __pyx_v__METHOD = __pyx_n_u_getDataTypeInCallback; - /* "PyCafe.pyx":1153 + /* "PyCafe.pyx":1152 * def getDataTypeInCallback(self, handlePV): * cdef str _METHOD = "getDataTypeInCallback" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -46457,7 +46905,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1154 + /* "PyCafe.pyx":1153 * cdef str _METHOD = "getDataTypeInCallback" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -46478,17 +46926,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1155 + /* "PyCafe.pyx":1154 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1155, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1154, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1154 + /* "PyCafe.pyx":1153 * cdef str _METHOD = "getDataTypeInCallback" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -46498,7 +46946,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ goto __pyx_L3; } - /* "PyCafe.pyx":1156 + /* "PyCafe.pyx":1155 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -46509,21 +46957,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1157 + /* "PyCafe.pyx":1156 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1157, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1157, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1156, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1157, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1156, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1156 + /* "PyCafe.pyx":1155 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -46533,7 +46981,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ goto __pyx_L3; } - /* "PyCafe.pyx":1159 + /* "PyCafe.pyx":1158 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -46541,10 +46989,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ * "First input argument, should be of type if handle, \ */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1159, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1160 + /* "PyCafe.pyx":1159 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -46566,7 +47014,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1159, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1158, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -46574,13 +47022,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1159, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1158, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1159, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -46594,29 +47042,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_3); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_3); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_3); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1159, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1159 + /* "PyCafe.pyx":1158 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be of type if handle, \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1159, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1159, __pyx_L1_error) + __PYX_ERR(3, 1158, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1163 + /* "PyCafe.pyx":1162 * "First input argument, should be of type if handle, \ * else if PV")) * return < long > self.hh.getDataTypeCB(handle) # <<<<<<<<<<<<<< @@ -46624,13 +47072,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ * def getDbrDataTypeInCallback(self, handlePV): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_long(((long)__pyx_v_self->hh.getDataTypeCB(__pyx_v_handle))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1163, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_long(((long)__pyx_v_self->hh.getDataTypeCB(__pyx_v_handle))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1151 + /* "PyCafe.pyx":1150 * return self.hh.getUsrArgsAsUInt(handle) * * def getDataTypeInCallback(self, handlePV): # <<<<<<<<<<<<<< @@ -46655,7 +47103,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_108getDataTypeInCallback(struct __pyx_ return __pyx_r; } -/* "PyCafe.pyx":1165 +/* "PyCafe.pyx":1164 * return < long > self.hh.getDataTypeCB(handle) * * def getDbrDataTypeInCallback(self, handlePV): # <<<<<<<<<<<<<< @@ -46692,7 +47140,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("getDbrDataTypeInCallback", 0); - /* "PyCafe.pyx":1166 + /* "PyCafe.pyx":1165 * * def getDbrDataTypeInCallback(self, handlePV): * cdef str _METHOD = "getDbrDataTypeInCallback" # <<<<<<<<<<<<<< @@ -46702,7 +47150,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p __Pyx_INCREF(__pyx_n_u_getDbrDataTypeInCallback); __pyx_v__METHOD = __pyx_n_u_getDbrDataTypeInCallback; - /* "PyCafe.pyx":1167 + /* "PyCafe.pyx":1166 * def getDbrDataTypeInCallback(self, handlePV): * cdef str _METHOD = "getDbrDataTypeInCallback" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -46711,7 +47159,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1168 + /* "PyCafe.pyx":1167 * cdef str _METHOD = "getDbrDataTypeInCallback" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -46732,17 +47180,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1169 + /* "PyCafe.pyx":1168 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1169, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1168, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1168 + /* "PyCafe.pyx":1167 * cdef str _METHOD = "getDbrDataTypeInCallback" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -46752,7 +47200,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p goto __pyx_L3; } - /* "PyCafe.pyx":1170 + /* "PyCafe.pyx":1169 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -46763,21 +47211,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1171 + /* "PyCafe.pyx":1170 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1171, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1171, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1170, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1171, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1170 + /* "PyCafe.pyx":1169 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -46787,7 +47235,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p goto __pyx_L3; } - /* "PyCafe.pyx":1173 + /* "PyCafe.pyx":1172 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -46795,10 +47243,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p * ("First input argument, should be of type if handle," + */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1173, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1174 + /* "PyCafe.pyx":1173 * else: * raise Exception("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -46820,7 +47268,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_6}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1173, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1172, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -46828,13 +47276,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_6}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1173, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1172, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1173, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -46848,29 +47296,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_6); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_6); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_6); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1173, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1173 + /* "PyCafe.pyx":1172 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First input argument, should be of type if handle," + */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1173, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1173, __pyx_L1_error) + __PYX_ERR(3, 1172, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1177 + /* "PyCafe.pyx":1176 * ("First input argument, should be of type if handle," + * "else if PV"))) * return < long > self.hh.getDbrDataTypeCB(handle) # <<<<<<<<<<<<<< @@ -46878,13 +47326,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p * def getDbrBaseInCallback(self, handlePV): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_long(((long)__pyx_v_self->hh.getDbrDataTypeCB(__pyx_v_handle))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1177, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_long(((long)__pyx_v_self->hh.getDbrDataTypeCB(__pyx_v_handle))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1165 + /* "PyCafe.pyx":1164 * return < long > self.hh.getDataTypeCB(handle) * * def getDbrDataTypeInCallback(self, handlePV): # <<<<<<<<<<<<<< @@ -46909,7 +47357,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_110getDbrDataTypeInCallback(struct __p return __pyx_r; } -/* "PyCafe.pyx":1179 +/* "PyCafe.pyx":1178 * return < long > self.hh.getDbrDataTypeCB(handle) * * def getDbrBaseInCallback(self, handlePV): # <<<<<<<<<<<<<< @@ -46946,7 +47394,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("getDbrBaseInCallback", 0); - /* "PyCafe.pyx":1180 + /* "PyCafe.pyx":1179 * * def getDbrBaseInCallback(self, handlePV): * cdef str _METHOD = "getDbrBaseInCallback" # <<<<<<<<<<<<<< @@ -46956,7 +47404,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o __Pyx_INCREF(__pyx_n_u_getDbrBaseInCallback); __pyx_v__METHOD = __pyx_n_u_getDbrBaseInCallback; - /* "PyCafe.pyx":1181 + /* "PyCafe.pyx":1180 * def getDbrBaseInCallback(self, handlePV): * cdef str _METHOD = "getDbrBaseInCallback" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -46965,7 +47413,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1182 + /* "PyCafe.pyx":1181 * cdef str _METHOD = "getDbrBaseInCallback" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -46986,17 +47434,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1183 + /* "PyCafe.pyx":1182 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1183, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1182, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1182 + /* "PyCafe.pyx":1181 * cdef str _METHOD = "getDbrBaseInCallback" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -47006,7 +47454,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o goto __pyx_L3; } - /* "PyCafe.pyx":1184 + /* "PyCafe.pyx":1183 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -47017,21 +47465,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1185 + /* "PyCafe.pyx":1184 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1185, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1185, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1184, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1185, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1184, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1184 + /* "PyCafe.pyx":1183 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -47041,7 +47489,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o goto __pyx_L3; } - /* "PyCafe.pyx":1187 + /* "PyCafe.pyx":1186 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -47049,10 +47497,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o * ("First input argument, should be of type if handle," + */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1187, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1188 + /* "PyCafe.pyx":1187 * else: * raise Exception("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -47074,7 +47522,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_6}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1187, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1186, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -47082,13 +47530,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_6}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1187, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1186, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1187, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -47102,29 +47550,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_6); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_6); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_6); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1187, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1187 + /* "PyCafe.pyx":1186 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First input argument, should be of type if handle," + */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1187, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1187, __pyx_L1_error) + __PYX_ERR(3, 1186, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1191 + /* "PyCafe.pyx":1190 * ("First input argument, should be of type if handle," + * "else if PV"))) * return < unsigned int > self.hh.getCafeDbrTypeCB(handle) # <<<<<<<<<<<<<< @@ -47132,13 +47580,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(((unsigned int)__pyx_v_self->hh.getCafeDbrTypeCB(__pyx_v_handle))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1191, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(((unsigned int)__pyx_v_self->hh.getCafeDbrTypeCB(__pyx_v_handle))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1179 + /* "PyCafe.pyx":1178 * return < long > self.hh.getDbrDataTypeCB(handle) * * def getDbrBaseInCallback(self, handlePV): # <<<<<<<<<<<<<< @@ -47163,7 +47611,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_112getDbrBaseInCallback(struct __pyx_o return __pyx_r; } -/* "PyCafe.pyx":1194 +/* "PyCafe.pyx":1193 * * ############################################################################ * def getHandlesFromWithinGroup(self, gHandleName): # <<<<<<<<<<<<<< @@ -47202,7 +47650,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ PyObject *__pyx_t_10 = NULL; __Pyx_RefNannySetupContext("getHandlesFromWithinGroup", 0); - /* "PyCafe.pyx":1196 + /* "PyCafe.pyx":1195 * def getHandlesFromWithinGroup(self, gHandleName): * * cdef str _METHOD = "getHandlesFromWithinGroup" # <<<<<<<<<<<<<< @@ -47212,7 +47660,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ __Pyx_INCREF(__pyx_n_u_getHandlesFromWithinGroup); __pyx_v__METHOD = __pyx_n_u_getHandlesFromWithinGroup; - /* "PyCafe.pyx":1198 + /* "PyCafe.pyx":1197 * cdef str _METHOD = "getHandlesFromWithinGroup" * * cdef unsigned int groupHandle = 0 # <<<<<<<<<<<<<< @@ -47221,7 +47669,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ */ __pyx_v_groupHandle = 0; - /* "PyCafe.pyx":1199 + /* "PyCafe.pyx":1198 * * cdef unsigned int groupHandle = 0 * if isinstance(gHandleName, (int, long)): # <<<<<<<<<<<<<< @@ -47242,17 +47690,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1200 + /* "PyCafe.pyx":1199 * cdef unsigned int groupHandle = 0 * if isinstance(gHandleName, (int, long)): * groupHandle = gHandleName # <<<<<<<<<<<<<< * elif isinstance(gHandleName, (str)): * groupHandle = self.hh.getGroupHandleFromGroupName(gHandleName) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_gHandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1200, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_gHandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1199, __pyx_L1_error) __pyx_v_groupHandle = __pyx_t_4; - /* "PyCafe.pyx":1199 + /* "PyCafe.pyx":1198 * * cdef unsigned int groupHandle = 0 * if isinstance(gHandleName, (int, long)): # <<<<<<<<<<<<<< @@ -47262,7 +47710,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ goto __pyx_L3; } - /* "PyCafe.pyx":1201 + /* "PyCafe.pyx":1200 * if isinstance(gHandleName, (int, long)): * groupHandle = gHandleName * elif isinstance(gHandleName, (str)): # <<<<<<<<<<<<<< @@ -47273,17 +47721,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1202 + /* "PyCafe.pyx":1201 * groupHandle = gHandleName * elif isinstance(gHandleName, (str)): * groupHandle = self.hh.getGroupHandleFromGroupName(gHandleName) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} \n{}".format( */ - __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_gHandleName); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(3, 1202, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_gHandleName); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(3, 1201, __pyx_L1_error) __pyx_v_groupHandle = __pyx_v_self->hh.getGroupHandleFromGroupName(__pyx_t_5); - /* "PyCafe.pyx":1201 + /* "PyCafe.pyx":1200 * if isinstance(gHandleName, (int, long)): * groupHandle = gHandleName * elif isinstance(gHandleName, (str)): # <<<<<<<<<<<<<< @@ -47293,7 +47741,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ goto __pyx_L3; } - /* "PyCafe.pyx":1204 + /* "PyCafe.pyx":1203 * groupHandle = self.hh.getGroupHandleFromGroupName(gHandleName) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -47301,10 +47749,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ * ("First input argument, should be of type if group handle," */ /*else*/ { - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1204, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "PyCafe.pyx":1205 + /* "PyCafe.pyx":1204 * else: * raise Exception("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -47326,7 +47774,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_7}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1204, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1203, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else @@ -47334,13 +47782,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_7}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1204, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1203, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { - __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1204, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -47354,29 +47802,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_7); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_7); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_kp_u_First_input_argument_should_be_o_7); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1204, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":1204 + /* "PyCafe.pyx":1203 * groupHandle = self.hh.getGroupHandleFromGroupName(gHandleName) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First input argument, should be of type if group handle," */ - __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1204, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(3, 1204, __pyx_L1_error) + __PYX_ERR(3, 1203, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1210 + /* "PyCafe.pyx":1209 * * cdef vector[unsigned int] hList * hList = self.hh.getHandlesFromWithinGroupV(groupHandle) # <<<<<<<<<<<<<< @@ -47385,7 +47833,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ */ __pyx_v_hList = __pyx_v_self->hh.getHandlesFromWithinGroupV(__pyx_v_groupHandle); - /* "PyCafe.pyx":1211 + /* "PyCafe.pyx":1210 * cdef vector[unsigned int] hList * hList = self.hh.getHandlesFromWithinGroupV(groupHandle) * return hList # <<<<<<<<<<<<<< @@ -47393,13 +47841,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_hList); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1211, __pyx_L1_error) + __pyx_t_7 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_hList); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_r = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1194 + /* "PyCafe.pyx":1193 * * ############################################################################ * def getHandlesFromWithinGroup(self, gHandleName): # <<<<<<<<<<<<<< @@ -47424,7 +47872,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_114getHandlesFromWithinGroup(struct __ return __pyx_r; } -/* "PyCafe.pyx":1216 +/* "PyCafe.pyx":1215 * ############################################################################ * * def close(self, handlePV): # <<<<<<<<<<<<<< @@ -47462,7 +47910,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("close", 0); - /* "PyCafe.pyx":1217 + /* "PyCafe.pyx":1216 * * def close(self, handlePV): * cdef str _METHOD = "close" # <<<<<<<<<<<<<< @@ -47472,7 +47920,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa __Pyx_INCREF(__pyx_n_u_close); __pyx_v__METHOD = __pyx_n_u_close; - /* "PyCafe.pyx":1218 + /* "PyCafe.pyx":1217 * def close(self, handlePV): * cdef str _METHOD = "close" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -47481,7 +47929,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1219 + /* "PyCafe.pyx":1218 * cdef str _METHOD = "close" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -47502,17 +47950,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1220 + /* "PyCafe.pyx":1219 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1220, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1219, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1219 + /* "PyCafe.pyx":1218 * cdef str _METHOD = "close" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -47522,7 +47970,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa goto __pyx_L3; } - /* "PyCafe.pyx":1221 + /* "PyCafe.pyx":1220 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -47533,21 +47981,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1222 + /* "PyCafe.pyx":1221 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1222, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1222, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1221, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1222, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1221, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1221 + /* "PyCafe.pyx":1220 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -47557,7 +48005,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa goto __pyx_L3; } - /* "PyCafe.pyx":1224 + /* "PyCafe.pyx":1223 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -47565,10 +48013,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa * ("First input argument, should be of type if handle," + */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1224, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1225 + /* "PyCafe.pyx":1224 * else: * raise Exception("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -47590,7 +48038,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_6}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1224, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1223, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -47598,13 +48046,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_6}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1224, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1223, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1224, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -47618,29 +48066,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_6); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_6); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_6); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1224, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1224 + /* "PyCafe.pyx":1223 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First input argument, should be of type if handle," + */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1224, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1224, __pyx_L1_error) + __PYX_ERR(3, 1223, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1230 + /* "PyCafe.pyx":1229 * * cdef int status * with nogil: # <<<<<<<<<<<<<< @@ -47655,7 +48103,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa #endif /*try:*/ { - /* "PyCafe.pyx":1231 + /* "PyCafe.pyx":1230 * cdef int status * with nogil: * status = self._c_cafe.close(handle) # <<<<<<<<<<<<<< @@ -47665,7 +48113,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa __pyx_v_status = __pyx_v_self->_c_cafe->close(__pyx_v_handle); } - /* "PyCafe.pyx":1230 + /* "PyCafe.pyx":1229 * * cdef int status * with nogil: # <<<<<<<<<<<<<< @@ -47684,7 +48132,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa } } - /* "PyCafe.pyx":1233 + /* "PyCafe.pyx":1232 * status = self._c_cafe.close(handle) * * return status # <<<<<<<<<<<<<< @@ -47692,13 +48140,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1233, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1216 + /* "PyCafe.pyx":1215 * ############################################################################ * * def close(self, handlePV): # <<<<<<<<<<<<<< @@ -47723,7 +48171,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_116close(struct __pyx_obj_6PyCafe_CyCa return __pyx_r; } -/* "PyCafe.pyx":1236 +/* "PyCafe.pyx":1235 * * ############################################################################ * def closeChannels(self): # <<<<<<<<<<<<<< @@ -47751,7 +48199,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_118closeChannels(struct __pyx_obj_6PyC PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("closeChannels", 0); - /* "PyCafe.pyx":1238 + /* "PyCafe.pyx":1237 * def closeChannels(self): * cdef int status * with nogil: # <<<<<<<<<<<<<< @@ -47766,7 +48214,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_118closeChannels(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":1239 + /* "PyCafe.pyx":1238 * cdef int status * with nogil: * status = self._c_cafe.closeChannels() # <<<<<<<<<<<<<< @@ -47776,7 +48224,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_118closeChannels(struct __pyx_obj_6PyC __pyx_v_status = __pyx_v_self->_c_cafe->closeChannels(); } - /* "PyCafe.pyx":1238 + /* "PyCafe.pyx":1237 * def closeChannels(self): * cdef int status * with nogil: # <<<<<<<<<<<<<< @@ -47795,7 +48243,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_118closeChannels(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":1240 + /* "PyCafe.pyx":1239 * with nogil: * status = self._c_cafe.closeChannels() * return status # <<<<<<<<<<<<<< @@ -47803,13 +48251,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_118closeChannels(struct __pyx_obj_6PyC * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1240, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1236 + /* "PyCafe.pyx":1235 * * ############################################################################ * def closeChannels(self): # <<<<<<<<<<<<<< @@ -47830,7 +48278,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_118closeChannels(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":1243 +/* "PyCafe.pyx":1242 * * ############################################################################ * def closeHandles(self, list handleList): # <<<<<<<<<<<<<< @@ -47844,7 +48292,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_121closeHandles(PyObject *__pyx_v_self PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("closeHandles (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handleList), (&PyList_Type), 1, "handleList", 1))) __PYX_ERR(3, 1243, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handleList), (&PyList_Type), 1, "handleList", 1))) __PYX_ERR(3, 1242, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_120closeHandles(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), ((PyObject*)__pyx_v_handleList)); /* function exit code */ @@ -47879,7 +48327,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa __Pyx_RefNannySetupContext("closeHandles", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":1244 + /* "PyCafe.pyx":1243 * ############################################################################ * def closeHandles(self, list handleList): * cdef str _METHOD = "closeHandles" # <<<<<<<<<<<<<< @@ -47889,7 +48337,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_n_u_closeHandles); __pyx_v__METHOD = __pyx_n_u_closeHandles; - /* "PyCafe.pyx":1245 + /* "PyCafe.pyx":1244 * def closeHandles(self, list handleList): * cdef str _METHOD = "closeHandles" * if not handleList: # <<<<<<<<<<<<<< @@ -47900,7 +48348,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa __pyx_t_2 = ((!__pyx_t_1) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1246 + /* "PyCafe.pyx":1245 * cdef str _METHOD = "closeHandles" * if not handleList: * return ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -47908,13 +48356,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa * handleList = self.checkForHandleList(handleList, force=False) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1246, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1245 + /* "PyCafe.pyx":1244 * def closeHandles(self, list handleList): * cdef str _METHOD = "closeHandles" * if not handleList: # <<<<<<<<<<<<<< @@ -47923,7 +48371,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":1247 + /* "PyCafe.pyx":1246 * if not handleList: * return ICAFE_NORMAL * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -47932,16 +48380,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1247, __pyx_L1_error) + __PYX_ERR(3, 1246, __pyx_L1_error) } - __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1247, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyUnicode_Check(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1248 + /* "PyCafe.pyx":1247 * return ICAFE_NORMAL * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList, force=False) # <<<<<<<<<<<<<< @@ -47950,13 +48398,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa */ __pyx_t_4.__pyx_n = 1; __pyx_t_4.force = 0; - __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, __pyx_v_handleList, 0, &__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1248, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, __pyx_v_handleList, 0, &__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyList_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(3, 1248, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(3, 1247, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_handleList, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "PyCafe.pyx":1247 + /* "PyCafe.pyx":1246 * if not handleList: * return ICAFE_NORMAL * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -47966,7 +48414,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa goto __pyx_L4; } - /* "PyCafe.pyx":1249 + /* "PyCafe.pyx":1248 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList, force=False) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -47975,9 +48423,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1249, __pyx_L1_error) + __PYX_ERR(3, 1248, __pyx_L1_error) } - __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1249, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyInt_Check(__pyx_t_3); __pyx_t_5 = (__pyx_t_2 != 0); @@ -47994,14 +48442,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1250 + /* "PyCafe.pyx":1249 * handleList = self.checkForHandleList(handleList, force=False) * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format(self._exception_text, _METHOD, # <<<<<<<<<<<<<< * "First input argument, should be a 'list' of of type \ * if handles or if PVs")) */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1250, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -48018,7 +48466,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1250, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1249, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); } else @@ -48026,13 +48474,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1250, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1249, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1250, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -48046,19 +48494,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_a); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_a); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_a); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1250, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1250, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1250, __pyx_L1_error) + __PYX_ERR(3, 1249, __pyx_L1_error) - /* "PyCafe.pyx":1249 + /* "PyCafe.pyx":1248 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList, force=False) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -48068,7 +48516,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa } __pyx_L4:; - /* "PyCafe.pyx":1256 + /* "PyCafe.pyx":1255 * # Do this only to avoid compiler warnings * cdef vector[unsigned int] v * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -48077,14 +48525,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 1256, __pyx_L1_error) + __PYX_ERR(3, 1255, __pyx_L1_error) } - __pyx_t_10 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1256, __pyx_L1_error) + __pyx_t_10 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1255, __pyx_L1_error) __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; - /* "PyCafe.pyx":1257 + /* "PyCafe.pyx":1256 * cdef vector[unsigned int] v * for i in range(0, len(handleList)): * v.push_back(handleList[i]) # <<<<<<<<<<<<<< @@ -48093,21 +48541,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1257, __pyx_L1_error) + __PYX_ERR(3, 1256, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1257, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1257, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1256, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_v.push_back(__pyx_t_13); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1257, __pyx_L1_error) + __PYX_ERR(3, 1256, __pyx_L1_error) } } - /* "PyCafe.pyx":1259 + /* "PyCafe.pyx":1258 * v.push_back(handleList[i]) * cdef int status * with nogil: # <<<<<<<<<<<<<< @@ -48122,7 +48570,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa #endif /*try:*/ { - /* "PyCafe.pyx":1260 + /* "PyCafe.pyx":1259 * cdef int status * with nogil: * status = self._c_cafe.closeHandlesV(v) # <<<<<<<<<<<<<< @@ -48132,7 +48580,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa __pyx_v_status = __pyx_v_self->_c_cafe->closeHandlesV(__pyx_v_v); } - /* "PyCafe.pyx":1259 + /* "PyCafe.pyx":1258 * v.push_back(handleList[i]) * cdef int status * with nogil: # <<<<<<<<<<<<<< @@ -48151,7 +48599,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa } } - /* "PyCafe.pyx":1261 + /* "PyCafe.pyx":1260 * with nogil: * status = self._c_cafe.closeHandlesV(v) * return status # <<<<<<<<<<<<<< @@ -48159,13 +48607,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1261, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1243 + /* "PyCafe.pyx":1242 * * ############################################################################ * def closeHandles(self, list handleList): # <<<<<<<<<<<<<< @@ -48191,7 +48639,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_120closeHandles(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":1265 +/* "PyCafe.pyx":1264 * ############################################################################ * * def closeDisconnectedChannelsWithinGroup(self, ghandleName): # <<<<<<<<<<<<<< @@ -48232,7 +48680,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou PyObject *__pyx_t_12 = NULL; __Pyx_RefNannySetupContext("closeDisconnectedChannelsWithinGroup", 0); - /* "PyCafe.pyx":1266 + /* "PyCafe.pyx":1265 * * def closeDisconnectedChannelsWithinGroup(self, ghandleName): * cdef str _METHOD = "closeDisconnectedChannelsWithinGroup" # <<<<<<<<<<<<<< @@ -48242,7 +48690,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou __Pyx_INCREF(__pyx_n_u_closeDisconnectedChannelsWithinG); __pyx_v__METHOD = __pyx_n_u_closeDisconnectedChannelsWithinG; - /* "PyCafe.pyx":1270 + /* "PyCafe.pyx":1269 * cdef vector[unsigned int] disHandles * * if isinstance(ghandleName, (list)): # <<<<<<<<<<<<<< @@ -48253,26 +48701,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1271 + /* "PyCafe.pyx":1270 * * if isinstance(ghandleName, (list)): * for i in range(0, len(ghandleName)): # <<<<<<<<<<<<<< * if isinstance(ghandleName[i], (int, long)): * hList.push_back(ghandleName[i]) */ - __pyx_t_3 = PyObject_Length(__pyx_v_ghandleName); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1271, __pyx_L1_error) + __pyx_t_3 = PyObject_Length(__pyx_v_ghandleName); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1270, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":1272 + /* "PyCafe.pyx":1271 * if isinstance(ghandleName, (list)): * for i in range(0, len(ghandleName)): * if isinstance(ghandleName[i], (int, long)): # <<<<<<<<<<<<<< * hList.push_back(ghandleName[i]) * elif isinstance(ghandleName[i], (str)): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_ghandleName, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1272, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_ghandleName, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyInt_Check(__pyx_t_6); __pyx_t_7 = (__pyx_t_1 != 0); @@ -48289,25 +48737,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1273 + /* "PyCafe.pyx":1272 * for i in range(0, len(ghandleName)): * if isinstance(ghandleName[i], (int, long)): * hList.push_back(ghandleName[i]) # <<<<<<<<<<<<<< * elif isinstance(ghandleName[i], (str)): * hList.push_back(self.checkForGroupHandle(ghandleName[i])) */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_ghandleName, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1273, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_ghandleName, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1273, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1272, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1273, __pyx_L1_error) + __PYX_ERR(3, 1272, __pyx_L1_error) } - /* "PyCafe.pyx":1272 + /* "PyCafe.pyx":1271 * if isinstance(ghandleName, (list)): * for i in range(0, len(ghandleName)): * if isinstance(ghandleName[i], (int, long)): # <<<<<<<<<<<<<< @@ -48317,43 +48765,43 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou goto __pyx_L6; } - /* "PyCafe.pyx":1274 + /* "PyCafe.pyx":1273 * if isinstance(ghandleName[i], (int, long)): * hList.push_back(ghandleName[i]) * elif isinstance(ghandleName[i], (str)): # <<<<<<<<<<<<<< * hList.push_back(self.checkForGroupHandle(ghandleName[i])) * else: */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_ghandleName, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1274, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_ghandleName, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyUnicode_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1275 + /* "PyCafe.pyx":1274 * hList.push_back(ghandleName[i]) * elif isinstance(ghandleName[i], (str)): * hList.push_back(self.checkForGroupHandle(ghandleName[i])) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_ghandleName, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1275, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_ghandleName, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (!(likely(PyUnicode_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_6)->tp_name), 0))) __PYX_ERR(3, 1275, __pyx_L1_error) - __pyx_t_9 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_t_6), 0, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1275, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_6)->tp_name), 0))) __PYX_ERR(3, 1274, __pyx_L1_error) + __pyx_t_9 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_t_6), 0, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1275, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1274, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1275, __pyx_L1_error) + __PYX_ERR(3, 1274, __pyx_L1_error) } - /* "PyCafe.pyx":1274 + /* "PyCafe.pyx":1273 * if isinstance(ghandleName[i], (int, long)): * hList.push_back(ghandleName[i]) * elif isinstance(ghandleName[i], (str)): # <<<<<<<<<<<<<< @@ -48363,7 +48811,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou goto __pyx_L6; } - /* "PyCafe.pyx":1277 + /* "PyCafe.pyx":1276 * hList.push_back(self.checkForGroupHandle(ghandleName[i])) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -48371,10 +48819,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou * "List input arguments, should be of type \ */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1277, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1278 + /* "PyCafe.pyx":1277 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -48396,7 +48844,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_o}; - __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1277, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1276, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_9); } else @@ -48404,13 +48852,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_o}; - __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1277, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1276, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_9); } else #endif { - __pyx_t_12 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 1277, __pyx_L1_error) + __pyx_t_12 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 1276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); if (__pyx_t_10) { __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL; @@ -48424,30 +48872,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou __Pyx_INCREF(__pyx_kp_u_List_input_arguments_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_List_input_arguments_should_be_o); PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_11, __pyx_kp_u_List_input_arguments_should_be_o); - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1277, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1277 + /* "PyCafe.pyx":1276 * hList.push_back(self.checkForGroupHandle(ghandleName[i])) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "List input arguments, should be of type \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1277, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1277, __pyx_L1_error) + __PYX_ERR(3, 1276, __pyx_L1_error) } __pyx_L6:; } - /* "PyCafe.pyx":1270 + /* "PyCafe.pyx":1269 * cdef vector[unsigned int] disHandles * * if isinstance(ghandleName, (list)): # <<<<<<<<<<<<<< @@ -48457,7 +48905,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou goto __pyx_L3; } - /* "PyCafe.pyx":1282 + /* "PyCafe.pyx":1281 * if group handle, else if group name")) * * elif isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -48478,22 +48926,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1283 + /* "PyCafe.pyx":1282 * * elif isinstance(ghandleName, (int, long)): * hList.push_back(ghandleName) # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * hList.push_back(self.checkForGroupHandle(ghandleName)) */ - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1283, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1282, __pyx_L1_error) try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1283, __pyx_L1_error) + __PYX_ERR(3, 1282, __pyx_L1_error) } - /* "PyCafe.pyx":1282 + /* "PyCafe.pyx":1281 * if group handle, else if group name")) * * elif isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -48503,7 +48951,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou goto __pyx_L3; } - /* "PyCafe.pyx":1284 + /* "PyCafe.pyx":1283 * elif isinstance(ghandleName, (int, long)): * hList.push_back(ghandleName) * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -48514,26 +48962,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1285 + /* "PyCafe.pyx":1284 * hList.push_back(ghandleName) * elif isinstance(ghandleName, (str)): * hList.push_back(self.checkForGroupHandle(ghandleName)) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 1285, __pyx_L1_error) - __pyx_t_6 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1285, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 1284, __pyx_L1_error) + __pyx_t_6 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1285, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1284, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1285, __pyx_L1_error) + __PYX_ERR(3, 1284, __pyx_L1_error) } - /* "PyCafe.pyx":1284 + /* "PyCafe.pyx":1283 * elif isinstance(ghandleName, (int, long)): * hList.push_back(ghandleName) * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -48543,7 +48991,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou goto __pyx_L3; } - /* "PyCafe.pyx":1287 + /* "PyCafe.pyx":1286 * hList.push_back(self.checkForGroupHandle(ghandleName)) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -48551,10 +48999,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou * "First input argument (if not list), should be of type \ */ /*else*/ { - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1287, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - /* "PyCafe.pyx":1288 + /* "PyCafe.pyx":1287 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -48576,7 +49024,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_if_not_list}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1287, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1286, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else @@ -48584,13 +49032,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_if_not_list}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1287, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1286, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { - __pyx_t_10 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1287, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_12) { __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_12); __pyx_t_12 = NULL; @@ -48604,44 +49052,44 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou __Pyx_INCREF(__pyx_kp_u_First_input_argument_if_not_list); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_if_not_list); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_11, __pyx_kp_u_First_input_argument_if_not_list); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1287, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":1287 + /* "PyCafe.pyx":1286 * hList.push_back(self.checkForGroupHandle(ghandleName)) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument (if not list), should be of type \ */ - __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1287, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_9, 0, 0, 0); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __PYX_ERR(3, 1287, __pyx_L1_error) + __PYX_ERR(3, 1286, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1292 + /* "PyCafe.pyx":1291 * if group handle, else if group name")) * * for i in range(0, len(hList)): # <<<<<<<<<<<<<< * with nogil: * self._c_cafe.closeDisconnectedChannelsFromWithinGroupV( */ - __pyx_t_9 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_hList); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1292, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_hList); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_3 = PyObject_Length(__pyx_t_9); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1292, __pyx_L1_error) + __pyx_t_3 = PyObject_Length(__pyx_t_9); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1291, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_4 = __pyx_t_3; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":1293 + /* "PyCafe.pyx":1292 * * for i in range(0, len(hList)): * with nogil: # <<<<<<<<<<<<<< @@ -48656,7 +49104,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou #endif /*try:*/ { - /* "PyCafe.pyx":1294 + /* "PyCafe.pyx":1293 * for i in range(0, len(hList)): * with nogil: * self._c_cafe.closeDisconnectedChannelsFromWithinGroupV( # <<<<<<<<<<<<<< @@ -48666,7 +49114,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou (void)(__pyx_v_self->_c_cafe->closeDisconnectedChannelsFromWithinGroupV((__pyx_v_hList[__pyx_v_i]))); } - /* "PyCafe.pyx":1293 + /* "PyCafe.pyx":1292 * * for i in range(0, len(hList)): * with nogil: # <<<<<<<<<<<<<< @@ -48686,7 +49134,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou } } - /* "PyCafe.pyx":1296 + /* "PyCafe.pyx":1295 * self._c_cafe.closeDisconnectedChannelsFromWithinGroupV( * hList[i]) * return # <<<<<<<<<<<<<< @@ -48697,7 +49145,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":1265 + /* "PyCafe.pyx":1264 * ############################################################################ * * def closeDisconnectedChannelsWithinGroup(self, ghandleName): # <<<<<<<<<<<<<< @@ -48722,7 +49170,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_122closeDisconnectedChannelsWithinGrou return __pyx_r; } -/* "PyCafe.pyx":1299 +/* "PyCafe.pyx":1298 * * ############################################################################ * def closeChannelKeepHandle(self, handlePV): # <<<<<<<<<<<<<< @@ -48764,7 +49212,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx PyObject *__pyx_t_12 = NULL; __Pyx_RefNannySetupContext("closeChannelKeepHandle", 0); - /* "PyCafe.pyx":1300 + /* "PyCafe.pyx":1299 * ############################################################################ * def closeChannelKeepHandle(self, handlePV): * cdef str _METHOD = "closeChannelKeepHandle" # <<<<<<<<<<<<<< @@ -48774,7 +49222,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx __Pyx_INCREF(__pyx_n_u_closeChannelKeepHandle); __pyx_v__METHOD = __pyx_n_u_closeChannelKeepHandle; - /* "PyCafe.pyx":1305 + /* "PyCafe.pyx":1304 * cdef int statusClose * * if isinstance(handlePV, (list)): # <<<<<<<<<<<<<< @@ -48785,26 +49233,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1306 + /* "PyCafe.pyx":1305 * * if isinstance(handlePV, (list)): * for i in range(0, len(handlePV)): # <<<<<<<<<<<<<< * if isinstance(handlePV[i], (int, long)): * hList.push_back(handlePV[i]) */ - __pyx_t_3 = PyObject_Length(__pyx_v_handlePV); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1306, __pyx_L1_error) + __pyx_t_3 = PyObject_Length(__pyx_v_handlePV); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1305, __pyx_L1_error) __pyx_t_4 = __pyx_t_3; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":1307 + /* "PyCafe.pyx":1306 * if isinstance(handlePV, (list)): * for i in range(0, len(handlePV)): * if isinstance(handlePV[i], (int, long)): # <<<<<<<<<<<<<< * hList.push_back(handlePV[i]) * elif isinstance(handlePV[i], (str)): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1307, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyInt_Check(__pyx_t_6); __pyx_t_7 = (__pyx_t_1 != 0); @@ -48821,25 +49269,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1308 + /* "PyCafe.pyx":1307 * for i in range(0, len(handlePV)): * if isinstance(handlePV[i], (int, long)): * hList.push_back(handlePV[i]) # <<<<<<<<<<<<<< * elif isinstance(handlePV[i], (str)): * hList.push_back(self.checkForHandle(handlePV[i])) */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1308, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1308, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1307, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1308, __pyx_L1_error) + __PYX_ERR(3, 1307, __pyx_L1_error) } - /* "PyCafe.pyx":1307 + /* "PyCafe.pyx":1306 * if isinstance(handlePV, (list)): * for i in range(0, len(handlePV)): * if isinstance(handlePV[i], (int, long)): # <<<<<<<<<<<<<< @@ -48849,43 +49297,43 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx goto __pyx_L6; } - /* "PyCafe.pyx":1309 + /* "PyCafe.pyx":1308 * if isinstance(handlePV[i], (int, long)): * hList.push_back(handlePV[i]) * elif isinstance(handlePV[i], (str)): # <<<<<<<<<<<<<< * hList.push_back(self.checkForHandle(handlePV[i])) * else: */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1309, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyUnicode_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1310 + /* "PyCafe.pyx":1309 * hList.push_back(handlePV[i]) * elif isinstance(handlePV[i], (str)): * hList.push_back(self.checkForHandle(handlePV[i])) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1310, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handlePV, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (!(likely(PyUnicode_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_6)->tp_name), 0))) __PYX_ERR(3, 1310, __pyx_L1_error) - __pyx_t_9 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_t_6), 0, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1310, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_6)->tp_name), 0))) __PYX_ERR(3, 1309, __pyx_L1_error) + __pyx_t_9 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_t_6), 0, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1310, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1309, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1310, __pyx_L1_error) + __PYX_ERR(3, 1309, __pyx_L1_error) } - /* "PyCafe.pyx":1309 + /* "PyCafe.pyx":1308 * if isinstance(handlePV[i], (int, long)): * hList.push_back(handlePV[i]) * elif isinstance(handlePV[i], (str)): # <<<<<<<<<<<<<< @@ -48895,7 +49343,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx goto __pyx_L6; } - /* "PyCafe.pyx":1312 + /* "PyCafe.pyx":1311 * hList.push_back(self.checkForHandle(handlePV[i])) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -48903,10 +49351,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx * "List input arguments, should be of type \ */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1312, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1313 + /* "PyCafe.pyx":1312 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -48928,7 +49376,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_o}; - __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1312, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1311, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_9); } else @@ -48936,13 +49384,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_List_input_arguments_should_be_o}; - __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1312, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1311, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_9); } else #endif { - __pyx_t_12 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 1312, __pyx_L1_error) + __pyx_t_12 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 1311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); if (__pyx_t_10) { __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL; @@ -48956,30 +49404,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx __Pyx_INCREF(__pyx_kp_u_List_input_arguments_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_List_input_arguments_should_be_o); PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_11, __pyx_kp_u_List_input_arguments_should_be_o); - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1312, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1312 + /* "PyCafe.pyx":1311 * hList.push_back(self.checkForHandle(handlePV[i])) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "List input arguments, should be of type \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1312, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1312, __pyx_L1_error) + __PYX_ERR(3, 1311, __pyx_L1_error) } __pyx_L6:; } - /* "PyCafe.pyx":1305 + /* "PyCafe.pyx":1304 * cdef int statusClose * * if isinstance(handlePV, (list)): # <<<<<<<<<<<<<< @@ -48989,7 +49437,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx goto __pyx_L3; } - /* "PyCafe.pyx":1317 + /* "PyCafe.pyx":1316 * if group handle, else if group name")) * * elif isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -49010,22 +49458,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1318 + /* "PyCafe.pyx":1317 * * elif isinstance(handlePV, (int, long)): * hList.push_back(handlePV) # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * hList.push_back(self.checkForHandle(handlePV)) */ - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1318, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1317, __pyx_L1_error) try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1318, __pyx_L1_error) + __PYX_ERR(3, 1317, __pyx_L1_error) } - /* "PyCafe.pyx":1317 + /* "PyCafe.pyx":1316 * if group handle, else if group name")) * * elif isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -49035,7 +49483,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx goto __pyx_L3; } - /* "PyCafe.pyx":1319 + /* "PyCafe.pyx":1318 * elif isinstance(handlePV, (int, long)): * hList.push_back(handlePV) * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -49046,26 +49494,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1320 + /* "PyCafe.pyx":1319 * hList.push_back(handlePV) * elif isinstance(handlePV, (str)): * hList.push_back(self.checkForHandle(handlePV)) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1320, __pyx_L1_error) - __pyx_t_6 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1320, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1319, __pyx_L1_error) + __pyx_t_6 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1320, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1319, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_hList.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1320, __pyx_L1_error) + __PYX_ERR(3, 1319, __pyx_L1_error) } - /* "PyCafe.pyx":1319 + /* "PyCafe.pyx":1318 * elif isinstance(handlePV, (int, long)): * hList.push_back(handlePV) * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -49075,7 +49523,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx goto __pyx_L3; } - /* "PyCafe.pyx":1322 + /* "PyCafe.pyx":1321 * hList.push_back(self.checkForHandle(handlePV)) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -49083,10 +49531,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx * "First input argument (if not list), should be of type \ */ /*else*/ { - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1322, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - /* "PyCafe.pyx":1323 + /* "PyCafe.pyx":1322 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -49108,7 +49556,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_if_not_list_2}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1322, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1321, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else @@ -49116,13 +49564,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_if_not_list_2}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1322, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1321, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { - __pyx_t_10 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1322, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_12) { __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_12); __pyx_t_12 = NULL; @@ -49136,29 +49584,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx __Pyx_INCREF(__pyx_kp_u_First_input_argument_if_not_list_2); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_if_not_list_2); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_11, __pyx_kp_u_First_input_argument_if_not_list_2); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1322, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":1322 + /* "PyCafe.pyx":1321 * hList.push_back(self.checkForHandle(handlePV)) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument (if not list), should be of type \ */ - __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1322, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_9, 0, 0, 0); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __PYX_ERR(3, 1322, __pyx_L1_error) + __PYX_ERR(3, 1321, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1327 + /* "PyCafe.pyx":1326 * if handle, else if PV")) * * with nogil: # <<<<<<<<<<<<<< @@ -49173,7 +49621,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx #endif /*try:*/ { - /* "PyCafe.pyx":1328 + /* "PyCafe.pyx":1327 * * with nogil: * statusClose = self._c_cafe.closeChannelsKeepHandles(hList) # <<<<<<<<<<<<<< @@ -49183,7 +49631,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx __pyx_v_statusClose = __pyx_v_self->_c_cafe->closeChannelsKeepHandles(__pyx_v_hList); } - /* "PyCafe.pyx":1327 + /* "PyCafe.pyx":1326 * if handle, else if PV")) * * with nogil: # <<<<<<<<<<<<<< @@ -49202,7 +49650,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx } } - /* "PyCafe.pyx":1329 + /* "PyCafe.pyx":1328 * with nogil: * statusClose = self._c_cafe.closeChannelsKeepHandles(hList) * return statusClose # <<<<<<<<<<<<<< @@ -49210,13 +49658,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx * #def reconnect(self, vector[unsigned int] handleList): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_statusClose); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1329, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_statusClose); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_r = __pyx_t_9; __pyx_t_9 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1299 + /* "PyCafe.pyx":1298 * * ############################################################################ * def closeChannelKeepHandle(self, handlePV): # <<<<<<<<<<<<<< @@ -49241,7 +49689,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_124closeChannelKeepHandle(struct __pyx return __pyx_r; } -/* "PyCafe.pyx":1332 +/* "PyCafe.pyx":1331 * * #def reconnect(self, vector[unsigned int] handleList): * def reconnect(self, list handleList): # <<<<<<<<<<<<<< @@ -49255,7 +49703,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_127reconnect(PyObject *__pyx_v_self, P PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("reconnect (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handleList), (&PyList_Type), 1, "handleList", 1))) __PYX_ERR(3, 1332, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handleList), (&PyList_Type), 1, "handleList", 1))) __PYX_ERR(3, 1331, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_126reconnect(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), ((PyObject*)__pyx_v_handleList)); /* function exit code */ @@ -49289,7 +49737,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ int __pyx_t_13; __Pyx_RefNannySetupContext("reconnect", 0); - /* "PyCafe.pyx":1333 + /* "PyCafe.pyx":1332 * #def reconnect(self, vector[unsigned int] handleList): * def reconnect(self, list handleList): * cdef int status1 = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -49298,7 +49746,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ */ __pyx_v_status1 = ICAFE_NORMAL; - /* "PyCafe.pyx":1334 + /* "PyCafe.pyx":1333 * def reconnect(self, list handleList): * cdef int status1 = ICAFE_NORMAL * cdef int status2 = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -49307,7 +49755,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ */ __pyx_v_status2 = ICAFE_NORMAL; - /* "PyCafe.pyx":1336 + /* "PyCafe.pyx":1335 * cdef int status2 = ICAFE_NORMAL * cdef vector[unsigned int] v * v.reserve(len(handleList)) # <<<<<<<<<<<<<< @@ -49316,12 +49764,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 1336, __pyx_L1_error) + __PYX_ERR(3, 1335, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1336, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1335, __pyx_L1_error) __pyx_v_v.reserve(__pyx_t_1); - /* "PyCafe.pyx":1337 + /* "PyCafe.pyx":1336 * cdef vector[unsigned int] v * v.reserve(len(handleList)) * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -49330,14 +49778,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 1337, __pyx_L1_error) + __PYX_ERR(3, 1336, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1337, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1336, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "PyCafe.pyx":1338 + /* "PyCafe.pyx":1337 * v.reserve(len(handleList)) * for i in range(0, len(handleList)): * v.push_back(handleList[i]) # <<<<<<<<<<<<<< @@ -49346,28 +49794,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1338, __pyx_L1_error) + __PYX_ERR(3, 1337, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1338, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_5 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1338, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_5 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1337, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_v.push_back(__pyx_t_5); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1338, __pyx_L1_error) + __PYX_ERR(3, 1337, __pyx_L1_error) } } - /* "PyCafe.pyx":1340 + /* "PyCafe.pyx":1339 * v.push_back(handleList[i]) * #print("Channels Closing...") * self.openMonitorPrepare() # <<<<<<<<<<<<<< * * for i in range (0, len(handleList)): */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openMonitorPrepare); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1340, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openMonitorPrepare); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -49381,12 +49829,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1340, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1342 + /* "PyCafe.pyx":1341 * self.openMonitorPrepare() * * for i in range (0, len(handleList)): # <<<<<<<<<<<<<< @@ -49395,27 +49843,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 1342, __pyx_L1_error) + __PYX_ERR(3, 1341, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1342, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1341, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "PyCafe.pyx":1343 + /* "PyCafe.pyx":1342 * * for i in range (0, len(handleList)): * self.monitorStop(handleList[i]) # <<<<<<<<<<<<<< * * self.openMonitorNow() */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_monitorStop); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1343, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_monitorStop); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1343, __pyx_L1_error) + __PYX_ERR(3, 1342, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1343, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -49430,20 +49878,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ __pyx_t_4 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1343, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":1345 + /* "PyCafe.pyx":1344 * self.monitorStop(handleList[i]) * * self.openMonitorNow() # <<<<<<<<<<<<<< * time.sleep(0.05) * #with nogil: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openMonitorNow); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1345, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openMonitorNow); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -49457,21 +49905,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1345, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1346 + /* "PyCafe.pyx":1345 * * self.openMonitorNow() * time.sleep(0.05) # <<<<<<<<<<<<<< * #with nogil: * # status= self._c_cafe.reconnect(handleList) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1346, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_sleep); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1346, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_sleep); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -49486,12 +49934,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_float_0_05) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_float_0_05); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1346, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1350 + /* "PyCafe.pyx":1349 * # status= self._c_cafe.reconnect(handleList) * #print("Channels Closing...") * with nogil: # <<<<<<<<<<<<<< @@ -49506,7 +49954,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ #endif /*try:*/ { - /* "PyCafe.pyx":1351 + /* "PyCafe.pyx":1350 * #print("Channels Closing...") * with nogil: * status1 = self._c_cafe.closeChannelsKeepHandles(v) # <<<<<<<<<<<<<< @@ -49516,7 +49964,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ __pyx_v_status1 = __pyx_v_self->_c_cafe->closeChannelsKeepHandles(__pyx_v_v); } - /* "PyCafe.pyx":1350 + /* "PyCafe.pyx":1349 * # status= self._c_cafe.reconnect(handleList) * #print("Channels Closing...") * with nogil: # <<<<<<<<<<<<<< @@ -49535,16 +49983,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } } - /* "PyCafe.pyx":1352 + /* "PyCafe.pyx":1351 * with nogil: * status1 = self._c_cafe.closeChannelsKeepHandles(v) * time.sleep(0.05) # <<<<<<<<<<<<<< * #print("Channels Closed") * self.openPrepare() */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1352, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_sleep); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1352, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_sleep); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -49559,19 +50007,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_float_0_05) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_float_0_05); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1352, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1354 + /* "PyCafe.pyx":1353 * time.sleep(0.05) * #print("Channels Closed") * self.openPrepare() # <<<<<<<<<<<<<< * with nogil: * status2 = self._c_cafe.openChannelsWithHandles(v) */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openPrepare); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1354, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openPrepare); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -49585,12 +50033,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1354, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1355 + /* "PyCafe.pyx":1354 * #print("Channels Closed") * self.openPrepare() * with nogil: # <<<<<<<<<<<<<< @@ -49605,7 +50053,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ #endif /*try:*/ { - /* "PyCafe.pyx":1356 + /* "PyCafe.pyx":1355 * self.openPrepare() * with nogil: * status2 = self._c_cafe.openChannelsWithHandles(v) # <<<<<<<<<<<<<< @@ -49615,7 +50063,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ __pyx_v_status2 = __pyx_v_self->_c_cafe->openChannelsWithHandles(__pyx_v_v); } - /* "PyCafe.pyx":1355 + /* "PyCafe.pyx":1354 * #print("Channels Closed") * self.openPrepare() * with nogil: # <<<<<<<<<<<<<< @@ -49634,18 +50082,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } } - /* "PyCafe.pyx":1359 + /* "PyCafe.pyx":1358 * #print("Channels Opened") * * self.openNowAndWait(self._c_cafe.channelOpenPolicy.getTimeout(), v) # <<<<<<<<<<<<<< * #print("Channels Opened//", status1, status2) * time.sleep(0.05) */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openNowAndWait); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1359, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openNowAndWait); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_self->_c_cafe->channelOpenPolicy.getTimeout()); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1359, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_self->_c_cafe->channelOpenPolicy.getTimeout()); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_v); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1359, __pyx_L1_error) + __pyx_t_8 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_v); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; __pyx_t_10 = 0; @@ -49662,7 +50110,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_t_8}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1359, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1358, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -49672,7 +50120,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_t_8}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1359, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1358, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -49680,7 +50128,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } else #endif { - __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 1359, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 1358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; @@ -49691,23 +50139,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1359, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1361 + /* "PyCafe.pyx":1360 * self.openNowAndWait(self._c_cafe.channelOpenPolicy.getTimeout(), v) * #print("Channels Opened//", status1, status2) * time.sleep(0.05) # <<<<<<<<<<<<<< * return max(status1, status2) * */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1361, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_sleep); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 1361, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_sleep); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 1360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -49722,12 +50170,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_6, __pyx_float_0_05) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_float_0_05); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1361, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1362 + /* "PyCafe.pyx":1361 * #print("Channels Opened//", status1, status2) * time.sleep(0.05) * return max(status1, status2) # <<<<<<<<<<<<<< @@ -49742,13 +50190,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ } else { __pyx_t_13 = __pyx_t_12; } - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1362, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1332 + /* "PyCafe.pyx":1331 * * #def reconnect(self, vector[unsigned int] handleList): * def reconnect(self, list handleList): # <<<<<<<<<<<<<< @@ -49774,7 +50222,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_126reconnect(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":1366 +/* "PyCafe.pyx":1365 * ############################################################################ * * def allConnected(self): # <<<<<<<<<<<<<< @@ -49801,7 +50249,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_128allConnected(struct __pyx_obj_6PyCa PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("allConnected", 0); - /* "PyCafe.pyx":1367 + /* "PyCafe.pyx":1366 * * def allConnected(self): * return self._c_cafe.allChannelsConnected() # <<<<<<<<<<<<<< @@ -49809,13 +50257,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_128allConnected(struct __pyx_obj_6PyCa * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_v_self->_c_cafe->allChannelsConnected() != 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1367, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_v_self->_c_cafe->allChannelsConnected() != 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1366 + /* "PyCafe.pyx":1365 * ############################################################################ * * def allConnected(self): # <<<<<<<<<<<<<< @@ -49836,7 +50284,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_128allConnected(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":1372 +/* "PyCafe.pyx":1371 * * @verify_handlepv * def isConnected(self, handlePV): # <<<<<<<<<<<<<< @@ -49865,7 +50313,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_130isConnected(struct __pyx_obj_6PyCaf PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("isConnected", 0); - /* "PyCafe.pyx":1373 + /* "PyCafe.pyx":1372 * @verify_handlepv * def isConnected(self, handlePV): * cdef str _METHOD = "isConnected" # <<<<<<<<<<<<<< @@ -49875,7 +50323,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_130isConnected(struct __pyx_obj_6PyCaf __Pyx_INCREF(__pyx_n_u_isConnected); __pyx_v__METHOD = __pyx_n_u_isConnected; - /* "PyCafe.pyx":1374 + /* "PyCafe.pyx":1373 * def isConnected(self, handlePV): * cdef str _METHOD = "isConnected" * return self._c_cafe.isChannelConnected(handlePV) # <<<<<<<<<<<<<< @@ -49883,14 +50331,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_130isConnected(struct __pyx_obj_6PyCaf * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1374, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyBool_FromLong((__pyx_v_self->_c_cafe->isChannelConnected(__pyx_t_1) != 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1374, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1373, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong((__pyx_v_self->_c_cafe->isChannelConnected(__pyx_t_1) != 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1372 + /* "PyCafe.pyx":1371 * * @verify_handlepv * def isConnected(self, handlePV): # <<<<<<<<<<<<<< @@ -49912,7 +50360,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_130isConnected(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":1377 +/* "PyCafe.pyx":1376 * * ############################################################################ * def supplementHandles(self, handleList=None): # <<<<<<<<<<<<<< @@ -49949,7 +50397,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_133supplementHandles(PyObject *__pyx_v } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "supplementHandles") < 0)) __PYX_ERR(3, 1377, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "supplementHandles") < 0)) __PYX_ERR(3, 1376, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -49963,7 +50411,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_133supplementHandles(PyObject *__pyx_v } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("supplementHandles", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1377, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("supplementHandles", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1376, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.supplementHandles", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -49990,7 +50438,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("supplementHandles", 0); - /* "PyCafe.pyx":1378 + /* "PyCafe.pyx":1377 * ############################################################################ * def supplementHandles(self, handleList=None): * cdef str _METHOD = "supplementHandles" # <<<<<<<<<<<<<< @@ -50000,7 +50448,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ __Pyx_INCREF(__pyx_n_u_supplementHandles); __pyx_v__METHOD = __pyx_n_u_supplementHandles; - /* "PyCafe.pyx":1379 + /* "PyCafe.pyx":1378 * def supplementHandles(self, handleList=None): * cdef str _METHOD = "supplementHandles" * if handleList is None: # <<<<<<<<<<<<<< @@ -50011,7 +50459,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1380 + /* "PyCafe.pyx":1379 * cdef str _METHOD = "supplementHandles" * if handleList is None: * with nogil: # <<<<<<<<<<<<<< @@ -50026,7 +50474,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ #endif /*try:*/ { - /* "PyCafe.pyx":1381 + /* "PyCafe.pyx":1380 * if handleList is None: * with nogil: * self._c_cafe.supplementHandles() # <<<<<<<<<<<<<< @@ -50036,7 +50484,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ (void)(__pyx_v_self->_c_cafe->supplementHandles()); } - /* "PyCafe.pyx":1380 + /* "PyCafe.pyx":1379 * cdef str _METHOD = "supplementHandles" * if handleList is None: * with nogil: # <<<<<<<<<<<<<< @@ -50055,7 +50503,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ } } - /* "PyCafe.pyx":1379 + /* "PyCafe.pyx":1378 * def supplementHandles(self, handleList=None): * cdef str _METHOD = "supplementHandles" * if handleList is None: # <<<<<<<<<<<<<< @@ -50065,7 +50513,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ goto __pyx_L3; } - /* "PyCafe.pyx":1382 + /* "PyCafe.pyx":1381 * with nogil: * self._c_cafe.supplementHandles() * elif isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -50076,14 +50524,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1384 + /* "PyCafe.pyx":1383 * elif isinstance(handleList, (list)): * #Convert to vector * self.supplementHandlesV(handleList) # <<<<<<<<<<<<<< * elif isinstance(handleList, (int, long, str)): * self.supplementHandle(handleList) */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_supplementHandlesV); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1384, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_supplementHandlesV); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -50097,12 +50545,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_handleList) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_handleList); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1384, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":1382 + /* "PyCafe.pyx":1381 * with nogil: * self._c_cafe.supplementHandles() * elif isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -50112,7 +50560,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ goto __pyx_L3; } - /* "PyCafe.pyx":1385 + /* "PyCafe.pyx":1384 * #Convert to vector * self.supplementHandlesV(handleList) * elif isinstance(handleList, (int, long, str)): # <<<<<<<<<<<<<< @@ -50140,14 +50588,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ __pyx_t_6 = (__pyx_t_1 != 0); if (__pyx_t_6) { - /* "PyCafe.pyx":1386 + /* "PyCafe.pyx":1385 * self.supplementHandlesV(handleList) * elif isinstance(handleList, (int, long, str)): * self.supplementHandle(handleList) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_supplementHandle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1386, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_supplementHandle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1385, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -50161,12 +50609,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_handleList) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_handleList); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1386, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1385, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":1385 + /* "PyCafe.pyx":1384 * #Convert to vector * self.supplementHandlesV(handleList) * elif isinstance(handleList, (int, long, str)): # <<<<<<<<<<<<<< @@ -50176,7 +50624,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ goto __pyx_L3; } - /* "PyCafe.pyx":1388 + /* "PyCafe.pyx":1387 * self.supplementHandle(handleList) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -50184,10 +50632,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ * "Input argument, if given, should be if list of \ */ /*else*/ { - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1388, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "PyCafe.pyx":1389 + /* "PyCafe.pyx":1388 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -50209,7 +50657,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Input_argument_if_given_should_b}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1388, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1387, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else @@ -50217,13 +50665,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Input_argument_if_given_should_b}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1388, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1387, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { - __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1388, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -50237,29 +50685,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ __Pyx_INCREF(__pyx_kp_u_Input_argument_if_given_should_b); __Pyx_GIVEREF(__pyx_kp_u_Input_argument_if_given_should_b); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_kp_u_Input_argument_if_given_should_b); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1388, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1388 + /* "PyCafe.pyx":1387 * self.supplementHandle(handleList) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "Input argument, if given, should be if list of \ */ - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1388, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 1388, __pyx_L1_error) + __PYX_ERR(3, 1387, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1377 + /* "PyCafe.pyx":1376 * * ############################################################################ * def supplementHandles(self, handleList=None): # <<<<<<<<<<<<<< @@ -50284,7 +50732,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_132supplementHandles(struct __pyx_obj_ return __pyx_r; } -/* "PyCafe.pyx":1396 +/* "PyCafe.pyx":1395 * ############################################################################ * @verify_handlepv * def supplementHandle(self, handlePV): # <<<<<<<<<<<<<< @@ -50312,17 +50760,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_134supplementHandle(struct __pyx_obj_6 unsigned int __pyx_t_1; __Pyx_RefNannySetupContext("supplementHandle", 0); - /* "PyCafe.pyx":1398 + /* "PyCafe.pyx":1397 * def supplementHandle(self, handlePV): * #decorator casts handlePV to int * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * with nogil: * self._c_cafe.supplementHandle(handle) */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1398, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1397, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":1399 + /* "PyCafe.pyx":1398 * #decorator casts handlePV to int * cdef unsigned int handle = handlePV * with nogil: # <<<<<<<<<<<<<< @@ -50337,7 +50785,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_134supplementHandle(struct __pyx_obj_6 #endif /*try:*/ { - /* "PyCafe.pyx":1400 + /* "PyCafe.pyx":1399 * cdef unsigned int handle = handlePV * with nogil: * self._c_cafe.supplementHandle(handle) # <<<<<<<<<<<<<< @@ -50347,7 +50795,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_134supplementHandle(struct __pyx_obj_6 (void)(__pyx_v_self->_c_cafe->supplementHandle(__pyx_v_handle)); } - /* "PyCafe.pyx":1399 + /* "PyCafe.pyx":1398 * #decorator casts handlePV to int * cdef unsigned int handle = handlePV * with nogil: # <<<<<<<<<<<<<< @@ -50366,7 +50814,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_134supplementHandle(struct __pyx_obj_6 } } - /* "PyCafe.pyx":1396 + /* "PyCafe.pyx":1395 * ############################################################################ * @verify_handlepv * def supplementHandle(self, handlePV): # <<<<<<<<<<<<<< @@ -50386,7 +50834,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_134supplementHandle(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":1404 +/* "PyCafe.pyx":1403 * ############################################################################ * * def supplementHandlesV(self, handleList): # <<<<<<<<<<<<<< @@ -50430,7 +50878,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj __Pyx_RefNannySetupContext("supplementHandlesV", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":1405 + /* "PyCafe.pyx":1404 * * def supplementHandlesV(self, handleList): * cdef str _METHOD = "supplementHandlesV" # <<<<<<<<<<<<<< @@ -50440,7 +50888,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj __Pyx_INCREF(__pyx_n_u_supplementHandlesV); __pyx_v__METHOD = __pyx_n_u_supplementHandlesV; - /* "PyCafe.pyx":1406 + /* "PyCafe.pyx":1405 * def supplementHandlesV(self, handleList): * cdef str _METHOD = "supplementHandlesV" * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -50468,28 +50916,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":1407 + /* "PyCafe.pyx":1406 * cdef str _METHOD = "supplementHandlesV" * if isinstance(handleList, (str, int, long)): * hl = [] # <<<<<<<<<<<<<< * hl.append(handleList) * #handleList = [] */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1407, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_hl = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1408 + /* "PyCafe.pyx":1407 * if isinstance(handleList, (str, int, long)): * hl = [] * hl.append(handleList) # <<<<<<<<<<<<<< * #handleList = [] * handleList = hl */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_hl, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 1408, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_hl, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 1407, __pyx_L1_error) - /* "PyCafe.pyx":1410 + /* "PyCafe.pyx":1409 * hl.append(handleList) * #handleList = [] * handleList = hl # <<<<<<<<<<<<<< @@ -50499,7 +50947,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj __Pyx_INCREF(__pyx_v_hl); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_v_hl); - /* "PyCafe.pyx":1406 + /* "PyCafe.pyx":1405 * def supplementHandlesV(self, handleList): * cdef str _METHOD = "supplementHandlesV" * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -50508,34 +50956,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj */ } - /* "PyCafe.pyx":1411 + /* "PyCafe.pyx":1410 * #handleList = [] * handleList = hl * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1411, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1412 + /* "PyCafe.pyx":1411 * handleList = hl * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) # <<<<<<<<<<<<<< * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 1412, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1412, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 1411, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1411 + /* "PyCafe.pyx":1410 * #handleList = [] * handleList = hl * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -50545,14 +50993,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj goto __pyx_L7; } - /* "PyCafe.pyx":1413 + /* "PyCafe.pyx":1412 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1413, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyInt_Check(__pyx_t_4); __pyx_t_2 = (__pyx_t_3 != 0); @@ -50569,17 +51017,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":1414 + /* "PyCafe.pyx":1413 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument should be a 'list' of of type \ */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1414, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":1415 + /* "PyCafe.pyx":1414 * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -50601,7 +51049,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_2}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1414, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1413, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else @@ -50609,13 +51057,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_2}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1414, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1413, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1414, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -50629,27 +51077,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_a_2); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_a_2); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_a_2); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1414, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":1414 + /* "PyCafe.pyx":1413 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument should be a 'list' of of type \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1414, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 1414, __pyx_L1_error) + __PYX_ERR(3, 1413, __pyx_L1_error) - /* "PyCafe.pyx":1413 + /* "PyCafe.pyx":1412 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -50659,38 +51107,38 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj } __pyx_L7:; - /* "PyCafe.pyx":1419 + /* "PyCafe.pyx":1418 * if handles, else if PVs")) * cdef vector[unsigned int] v * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * v.push_back(handleList[i]) * */ - __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1419, __pyx_L1_error) + __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1418, __pyx_L1_error) __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; - /* "PyCafe.pyx":1420 + /* "PyCafe.pyx":1419 * cdef vector[unsigned int] v * for i in range(0, len(handleList)): * v.push_back(handleList[i]) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1420, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 1419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1420, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1419, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_v.push_back(__pyx_t_13); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1420, __pyx_L1_error) + __PYX_ERR(3, 1419, __pyx_L1_error) } } - /* "PyCafe.pyx":1422 + /* "PyCafe.pyx":1421 * v.push_back(handleList[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -50705,7 +51153,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj #endif /*try:*/ { - /* "PyCafe.pyx":1423 + /* "PyCafe.pyx":1422 * * with nogil: * self._c_cafe.supplementHandlesV(v) # <<<<<<<<<<<<<< @@ -50715,7 +51163,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj (void)(__pyx_v_self->_c_cafe->supplementHandlesV(__pyx_v_v)); } - /* "PyCafe.pyx":1422 + /* "PyCafe.pyx":1421 * v.push_back(handleList[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -50734,7 +51182,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj } } - /* "PyCafe.pyx":1404 + /* "PyCafe.pyx":1403 * ############################################################################ * * def supplementHandlesV(self, handleList): # <<<<<<<<<<<<<< @@ -50761,7 +51209,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_136supplementHandlesV(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":1427 +/* "PyCafe.pyx":1426 * ############################################################################ * * def printDisconnected(self): # <<<<<<<<<<<<<< @@ -50787,7 +51235,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_138printDisconnected(struct __pyx_obj_ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("printDisconnected", 0); - /* "PyCafe.pyx":1428 + /* "PyCafe.pyx":1427 * * def printDisconnected(self): * self._c_cafe.printDisconnectedHandles() # <<<<<<<<<<<<<< @@ -50796,7 +51244,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_138printDisconnected(struct __pyx_obj_ */ (void)(__pyx_v_self->_c_cafe->printDisconnectedHandles()); - /* "PyCafe.pyx":1427 + /* "PyCafe.pyx":1426 * ############################################################################ * * def printDisconnected(self): # <<<<<<<<<<<<<< @@ -50811,7 +51259,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_138printDisconnected(struct __pyx_obj_ return __pyx_r; } -/* "PyCafe.pyx":1430 +/* "PyCafe.pyx":1429 * self._c_cafe.printDisconnectedHandles() * * def printDisconnectedHandles(self): # <<<<<<<<<<<<<< @@ -50837,7 +51285,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_140printDisconnectedHandles(struct __p __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("printDisconnectedHandles", 0); - /* "PyCafe.pyx":1431 + /* "PyCafe.pyx":1430 * * def printDisconnectedHandles(self): * self._c_cafe.printDisconnectedHandles() # <<<<<<<<<<<<<< @@ -50846,7 +51294,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_140printDisconnectedHandles(struct __p */ (void)(__pyx_v_self->_c_cafe->printDisconnectedHandles()); - /* "PyCafe.pyx":1430 + /* "PyCafe.pyx":1429 * self._c_cafe.printDisconnectedHandles() * * def printDisconnectedHandles(self): # <<<<<<<<<<<<<< @@ -50861,7 +51309,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_140printDisconnectedHandles(struct __p return __pyx_r; } -/* "PyCafe.pyx":1434 +/* "PyCafe.pyx":1433 * * ############################################################################ * def printHandles(self): # <<<<<<<<<<<<<< @@ -50887,7 +51335,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_142printHandles(struct __pyx_obj_6PyCa __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("printHandles", 0); - /* "PyCafe.pyx":1435 + /* "PyCafe.pyx":1434 * ############################################################################ * def printHandles(self): * self._c_cafe.printHandles() # <<<<<<<<<<<<<< @@ -50896,7 +51344,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_142printHandles(struct __pyx_obj_6PyCa */ (void)(__pyx_v_self->_c_cafe->printHandles()); - /* "PyCafe.pyx":1434 + /* "PyCafe.pyx":1433 * * ############################################################################ * def printHandles(self): # <<<<<<<<<<<<<< @@ -50911,7 +51359,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_142printHandles(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":1439 +/* "PyCafe.pyx":1438 * ############################################################################ * @verify_handlepv * def printHandle(self, handlePV): # <<<<<<<<<<<<<< @@ -50938,17 +51386,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_144printHandle(struct __pyx_obj_6PyCaf unsigned int __pyx_t_1; __Pyx_RefNannySetupContext("printHandle", 0); - /* "PyCafe.pyx":1440 + /* "PyCafe.pyx":1439 * @verify_handlepv * def printHandle(self, handlePV): * self._c_cafe.printHandle(handlePV) # <<<<<<<<<<<<<< * * ############################################################################ */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1440, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1439, __pyx_L1_error) (void)(__pyx_v_self->_c_cafe->printHandle(__pyx_t_1)); - /* "PyCafe.pyx":1439 + /* "PyCafe.pyx":1438 * ############################################################################ * @verify_handlepv * def printHandle(self, handlePV): # <<<<<<<<<<<<<< @@ -50968,7 +51416,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_144printHandle(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":1445 +/* "PyCafe.pyx":1444 * * ############################################################################ * def printHandlesV(self, list handleList): # <<<<<<<<<<<<<< @@ -50982,7 +51430,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_147printHandlesV(PyObject *__pyx_v_sel PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("printHandlesV (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handleList), (&PyList_Type), 1, "handleList", 1))) __PYX_ERR(3, 1445, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handleList), (&PyList_Type), 1, "handleList", 1))) __PYX_ERR(3, 1444, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_146printHandlesV(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), ((PyObject*)__pyx_v_handleList)); /* function exit code */ @@ -51015,7 +51463,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC __Pyx_RefNannySetupContext("printHandlesV", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":1446 + /* "PyCafe.pyx":1445 * ############################################################################ * def printHandlesV(self, list handleList): * cdef str _METHOD = "printHandlesV" # <<<<<<<<<<<<<< @@ -51025,7 +51473,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_printHandlesV); __pyx_v__METHOD = __pyx_n_u_printHandlesV; - /* "PyCafe.pyx":1447 + /* "PyCafe.pyx":1446 * def printHandlesV(self, list handleList): * cdef str _METHOD = "printHandlesV" * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -51034,29 +51482,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1447, __pyx_L1_error) + __PYX_ERR(3, 1446, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1447, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyUnicode_Check(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":1448 + /* "PyCafe.pyx":1447 * cdef str _METHOD = "printHandlesV" * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) # <<<<<<<<<<<<<< * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( */ - __pyx_t_1 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, __pyx_v_handleList, 0, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1448, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, __pyx_v_handleList, 0, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(3, 1448, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(3, 1447, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_handleList, ((PyObject*)__pyx_t_1)); __pyx_t_1 = 0; - /* "PyCafe.pyx":1447 + /* "PyCafe.pyx":1446 * def printHandlesV(self, list handleList): * cdef str _METHOD = "printHandlesV" * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -51066,7 +51514,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":1449 + /* "PyCafe.pyx":1448 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -51075,9 +51523,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1449, __pyx_L1_error) + __PYX_ERR(3, 1448, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1449, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyInt_Check(__pyx_t_1); __pyx_t_4 = (__pyx_t_2 != 0); @@ -51094,17 +51542,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1450 + /* "PyCafe.pyx":1449 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be a 'list' of of type \ */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1450, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - /* "PyCafe.pyx":1451 + /* "PyCafe.pyx":1450 * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -51126,7 +51574,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_3}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1450, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1449, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -51134,13 +51582,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_3}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1450, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1449, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1450, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; @@ -51154,27 +51602,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_a_3); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_a_3); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_kp_u_First_input_argument_should_be_a_3); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1450, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":1450 + /* "PyCafe.pyx":1449 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be a 'list' of of type \ */ - __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1450, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 1450, __pyx_L1_error) + __PYX_ERR(3, 1449, __pyx_L1_error) - /* "PyCafe.pyx":1449 + /* "PyCafe.pyx":1448 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -51184,7 +51632,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC } __pyx_L3:; - /* "PyCafe.pyx":1457 + /* "PyCafe.pyx":1456 * # Do this only to avoid compiler warnings * cdef vector[unsigned int] v * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -51193,14 +51641,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 1457, __pyx_L1_error) + __PYX_ERR(3, 1456, __pyx_L1_error) } - __pyx_t_9 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1457, __pyx_L1_error) + __pyx_t_9 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1456, __pyx_L1_error) __pyx_t_10 = __pyx_t_9; for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_i = __pyx_t_11; - /* "PyCafe.pyx":1458 + /* "PyCafe.pyx":1457 * cdef vector[unsigned int] v * for i in range(0, len(handleList)): * v.push_back(handleList[i]) # <<<<<<<<<<<<<< @@ -51209,21 +51657,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1458, __pyx_L1_error) + __PYX_ERR(3, 1457, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1458, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_12 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1458, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1457, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; try { __pyx_v_v.push_back(__pyx_t_12); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 1458, __pyx_L1_error) + __PYX_ERR(3, 1457, __pyx_L1_error) } } - /* "PyCafe.pyx":1459 + /* "PyCafe.pyx":1458 * for i in range(0, len(handleList)): * v.push_back(handleList[i]) * self.hh.printHandlesV(v) # <<<<<<<<<<<<<< @@ -51232,7 +51680,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC */ (void)(__pyx_v_self->hh.printHandlesV(__pyx_v_v)); - /* "PyCafe.pyx":1460 + /* "PyCafe.pyx":1459 * v.push_back(handleList[i]) * self.hh.printHandlesV(v) * return # <<<<<<<<<<<<<< @@ -51243,7 +51691,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":1445 + /* "PyCafe.pyx":1444 * * ############################################################################ * def printHandlesV(self, list handleList): # <<<<<<<<<<<<<< @@ -51269,7 +51717,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_146printHandlesV(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":1464 +/* "PyCafe.pyx":1463 * * ############################################################################ * def getDisconnectedHandles(self): # <<<<<<<<<<<<<< @@ -51300,7 +51748,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_148getDisconnectedHandles(struct __pyx PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("getDisconnectedHandles", 0); - /* "PyCafe.pyx":1467 + /* "PyCafe.pyx":1466 * cdef vector[unsigned int] dhV * cdef vector[string] pvV * self.hh.getDisconnectedHandles(dhV, pvV) # <<<<<<<<<<<<<< @@ -51309,7 +51757,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_148getDisconnectedHandles(struct __pyx */ (void)(__pyx_v_self->hh.getDisconnectedHandles(__pyx_v_dhV, __pyx_v_pvV)); - /* "PyCafe.pyx":1468 + /* "PyCafe.pyx":1467 * cdef vector[string] pvV * self.hh.getDisconnectedHandles(dhV, pvV) * return dhV, pvV # <<<<<<<<<<<<<< @@ -51317,11 +51765,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_148getDisconnectedHandles(struct __pyx * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_dhV); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1468, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_dhV); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1468, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1468, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); @@ -51333,7 +51781,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_148getDisconnectedHandles(struct __pyx __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1464 + /* "PyCafe.pyx":1463 * * ############################################################################ * def getDisconnectedHandles(self): # <<<<<<<<<<<<<< @@ -51356,7 +51804,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_148getDisconnectedHandles(struct __pyx return __pyx_r; } -/* "PyCafe.pyx":1473 +/* "PyCafe.pyx":1472 * ############################################################################ * * def getHandles(self, asDict=False): # <<<<<<<<<<<<<< @@ -51393,7 +51841,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_151getHandles(PyObject *__pyx_v_self, } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getHandles") < 0)) __PYX_ERR(3, 1473, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getHandles") < 0)) __PYX_ERR(3, 1472, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -51407,7 +51855,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_151getHandles(PyObject *__pyx_v_self, } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getHandles", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1473, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getHandles", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1472, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getHandles", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -51431,7 +51879,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_150getHandles(struct __pyx_obj_6PyCafe PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getHandles", 0); - /* "PyCafe.pyx":1476 + /* "PyCafe.pyx":1475 * cdef vector[unsigned int] dhV * cdef vector[string] pvV * self.hh.getHandles(dhV, pvV) # <<<<<<<<<<<<<< @@ -51440,17 +51888,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_150getHandles(struct __pyx_obj_6PyCafe */ (void)(__pyx_v_self->hh.getHandles(__pyx_v_dhV, __pyx_v_pvV)); - /* "PyCafe.pyx":1477 + /* "PyCafe.pyx":1476 * cdef vector[string] pvV * self.hh.getHandles(dhV, pvV) * if asDict: # <<<<<<<<<<<<<< * return dict(zip(dhV, pvV)) * else: */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_asDict); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 1477, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_asDict); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 1476, __pyx_L1_error) if (__pyx_t_1) { - /* "PyCafe.pyx":1478 + /* "PyCafe.pyx":1477 * self.hh.getHandles(dhV, pvV) * if asDict: * return dict(zip(dhV, pvV)) # <<<<<<<<<<<<<< @@ -51458,11 +51906,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_150getHandles(struct __pyx_obj_6PyCafe * return dhV, pvV */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_dhV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1478, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_dhV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvV); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1478, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvV); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1478, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); @@ -51470,17 +51918,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_150getHandles(struct __pyx_obj_6PyCafe PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); __pyx_t_2 = 0; __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1478, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyDict_Type)), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1478, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyDict_Type)), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1477 + /* "PyCafe.pyx":1476 * cdef vector[string] pvV * self.hh.getHandles(dhV, pvV) * if asDict: # <<<<<<<<<<<<<< @@ -51490,7 +51938,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_150getHandles(struct __pyx_obj_6PyCafe goto __pyx_L3; } - /* "PyCafe.pyx":1480 + /* "PyCafe.pyx":1479 * return dict(zip(dhV, pvV)) * else: * return dhV, pvV # <<<<<<<<<<<<<< @@ -51499,11 +51947,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_150getHandles(struct __pyx_obj_6PyCafe */ /*else*/ { __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_dhV); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1480, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_dhV); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvV); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1480, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvV); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1480, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); @@ -51517,7 +51965,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_150getHandles(struct __pyx_obj_6PyCafe } __pyx_L3:; - /* "PyCafe.pyx":1473 + /* "PyCafe.pyx":1472 * ############################################################################ * * def getHandles(self, asDict=False): # <<<<<<<<<<<<<< @@ -51540,7 +51988,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_150getHandles(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":1485 +/* "PyCafe.pyx":1484 * ############################################################################ * * def getHandleStates(self): # <<<<<<<<<<<<<< @@ -51573,7 +52021,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_152getHandleStates(struct __pyx_obj_6P PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getHandleStates", 0); - /* "PyCafe.pyx":1489 + /* "PyCafe.pyx":1488 * cdef vector[string] pvV * cdef vector[unsigned short] stateV * self.hh.getHandleStates(dhV, pvV, stateV) # <<<<<<<<<<<<<< @@ -51582,7 +52030,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_152getHandleStates(struct __pyx_obj_6P */ (void)(__pyx_v_self->hh.getHandleStates(__pyx_v_dhV, __pyx_v_pvV, __pyx_v_stateV)); - /* "PyCafe.pyx":1490 + /* "PyCafe.pyx":1489 * cdef vector[unsigned short] stateV * self.hh.getHandleStates(dhV, pvV, stateV) * return dhV, pvV, stateV # <<<<<<<<<<<<<< @@ -51590,13 +52038,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_152getHandleStates(struct __pyx_obj_6P * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_dhV); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1490, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_dhV); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1490, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __pyx_convert_vector_to_py_unsigned_short(__pyx_v_stateV); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1490, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_unsigned_short(__pyx_v_stateV); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1490, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); @@ -51611,7 +52059,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_152getHandleStates(struct __pyx_obj_6P __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1485 + /* "PyCafe.pyx":1484 * ############################################################################ * * def getHandleStates(self): # <<<<<<<<<<<<<< @@ -51635,7 +52083,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_152getHandleStates(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":1494 +/* "PyCafe.pyx":1493 * * ############################################################################ * def getStatusSeverity(self, int statusCode): # <<<<<<<<<<<<<< @@ -51651,7 +52099,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_155getStatusSeverity(PyObject *__pyx_v __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getStatusSeverity (wrapper)", 0); assert(__pyx_arg_statusCode); { - __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1494, __pyx_L3_error) + __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1493, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -51672,7 +52120,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_154getStatusSeverity(struct __pyx_obj_ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("getStatusSeverity", 0); - /* "PyCafe.pyx":1495 + /* "PyCafe.pyx":1494 * ############################################################################ * def getStatusSeverity(self, int statusCode): * return self._c_cafe.getCafeStatusSeverity().message(statusCode) # <<<<<<<<<<<<<< @@ -51680,13 +52128,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_154getStatusSeverity(struct __pyx_obj_ * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->_c_cafe->getCafeStatusSeverity().message(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1495, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->_c_cafe->getCafeStatusSeverity().message(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1494 + /* "PyCafe.pyx":1493 * * ############################################################################ * def getStatusSeverity(self, int statusCode): # <<<<<<<<<<<<<< @@ -51707,7 +52155,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_154getStatusSeverity(struct __pyx_obj_ return __pyx_r; } -/* "PyCafe.pyx":1498 +/* "PyCafe.pyx":1497 * * ############################################################################ * def getStatusCodeAsText(self, int statusCode): # <<<<<<<<<<<<<< @@ -51723,7 +52171,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_157getStatusCodeAsText(PyObject *__pyx __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getStatusCodeAsText (wrapper)", 0); assert(__pyx_arg_statusCode); { - __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1498, __pyx_L3_error) + __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1497, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -51744,7 +52192,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_156getStatusCodeAsText(struct __pyx_ob PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("getStatusCodeAsText", 0); - /* "PyCafe.pyx":1499 + /* "PyCafe.pyx":1498 * ############################################################################ * def getStatusCodeAsText(self, int statusCode): * return self.cs.code(statusCode) # <<<<<<<<<<<<<< @@ -51752,13 +52200,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_156getStatusCodeAsText(struct __pyx_ob * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1499, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1498 + /* "PyCafe.pyx":1497 * * ############################################################################ * def getStatusCodeAsText(self, int statusCode): # <<<<<<<<<<<<<< @@ -51779,7 +52227,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_156getStatusCodeAsText(struct __pyx_ob return __pyx_r; } -/* "PyCafe.pyx":1502 +/* "PyCafe.pyx":1501 * * ############################################################################ * def getStatusCodeAsString(self, int statusCode): # <<<<<<<<<<<<<< @@ -51795,7 +52243,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_159getStatusCodeAsString(PyObject *__p __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getStatusCodeAsString (wrapper)", 0); assert(__pyx_arg_statusCode); { - __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1502, __pyx_L3_error) + __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1501, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -51816,7 +52264,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_158getStatusCodeAsString(struct __pyx_ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("getStatusCodeAsString", 0); - /* "PyCafe.pyx":1503 + /* "PyCafe.pyx":1502 * ############################################################################ * def getStatusCodeAsString(self, int statusCode): * return self.cs.code(statusCode) # <<<<<<<<<<<<<< @@ -51824,13 +52272,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_158getStatusCodeAsString(struct __pyx_ * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1503, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1502 + /* "PyCafe.pyx":1501 * * ############################################################################ * def getStatusCodeAsString(self, int statusCode): # <<<<<<<<<<<<<< @@ -51851,7 +52299,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_158getStatusCodeAsString(struct __pyx_ return __pyx_r; } -/* "PyCafe.pyx":1506 +/* "PyCafe.pyx":1505 * * ############################################################################ * def getStatusInfo(self, int statusCode): # <<<<<<<<<<<<<< @@ -51867,7 +52315,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_161getStatusInfo(PyObject *__pyx_v_sel __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getStatusInfo (wrapper)", 0); assert(__pyx_arg_statusCode); { - __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1506, __pyx_L3_error) + __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1505, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -51888,7 +52336,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_160getStatusInfo(struct __pyx_obj_6PyC PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("getStatusInfo", 0); - /* "PyCafe.pyx":1507 + /* "PyCafe.pyx":1506 * ############################################################################ * def getStatusInfo(self, int statusCode): * return self.cs.info(statusCode) # <<<<<<<<<<<<<< @@ -51896,13 +52344,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_160getStatusInfo(struct __pyx_obj_6PyC * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1507, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1506 + /* "PyCafe.pyx":1505 * * ############################################################################ * def getStatusInfo(self, int statusCode): # <<<<<<<<<<<<<< @@ -51923,7 +52371,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_160getStatusInfo(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":1510 +/* "PyCafe.pyx":1509 * * ############################################################################ * def getStatusMsg(self, int statusCode): # <<<<<<<<<<<<<< @@ -51939,7 +52387,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_163getStatusMsg(PyObject *__pyx_v_self __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getStatusMsg (wrapper)", 0); assert(__pyx_arg_statusCode); { - __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1510, __pyx_L3_error) + __pyx_v_statusCode = __Pyx_PyInt_As_int(__pyx_arg_statusCode); if (unlikely((__pyx_v_statusCode == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1509, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -51960,7 +52408,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_162getStatusMsg(struct __pyx_obj_6PyCa PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("getStatusMsg", 0); - /* "PyCafe.pyx":1511 + /* "PyCafe.pyx":1510 * ############################################################################ * def getStatusMsg(self, int statusCode): * return self.cs.message(statusCode) # <<<<<<<<<<<<<< @@ -51968,13 +52416,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_162getStatusMsg(struct __pyx_obj_6PyCa * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.message(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1511, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.message(__pyx_v_statusCode)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1510, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1510 + /* "PyCafe.pyx":1509 * * ############################################################################ * def getStatusMsg(self, int statusCode): # <<<<<<<<<<<<<< @@ -51995,7 +52443,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_162getStatusMsg(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":1515 +/* "PyCafe.pyx":1514 * ############################################################################ * @verify_handlepv * def getStatus(self, handlePV): # <<<<<<<<<<<<<< @@ -52023,7 +52471,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_164getStatus(struct __pyx_obj_6PyCafe_ PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getStatus", 0); - /* "PyCafe.pyx":1516 + /* "PyCafe.pyx":1515 * @verify_handlepv * def getStatus(self, handlePV): * return self.hh.getStatus(handlePV) # <<<<<<<<<<<<<< @@ -52031,14 +52479,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_164getStatus(struct __pyx_obj_6PyCafe_ * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1516, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->hh.getStatus(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1516, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1515, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->hh.getStatus(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1515 + /* "PyCafe.pyx":1514 * ############################################################################ * @verify_handlepv * def getStatus(self, handlePV): # <<<<<<<<<<<<<< @@ -52059,7 +52507,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_164getStatus(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":1519 +/* "PyCafe.pyx":1518 * * ############################################################################ * def getChannelDevice(self, handlePV): # <<<<<<<<<<<<<< @@ -52102,7 +52550,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 Py_ssize_t __pyx_t_12; __Pyx_RefNannySetupContext("getChannelDevice", 0); - /* "PyCafe.pyx":1520 + /* "PyCafe.pyx":1519 * ############################################################################ * def getChannelDevice(self, handlePV): * cdef str _METHOD = "getChannelDevice" # <<<<<<<<<<<<<< @@ -52112,20 +52560,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 __Pyx_INCREF(__pyx_n_u_getChannelDevice); __pyx_v__METHOD = __pyx_n_u_getChannelDevice; - /* "PyCafe.pyx":1521 + /* "PyCafe.pyx":1520 * def getChannelDevice(self, handlePV): * cdef str _METHOD = "getChannelDevice" * cdef string valString = str("") # <<<<<<<<<<<<<< * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1521, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1521, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1520, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_valString = __pyx_t_2; - /* "PyCafe.pyx":1522 + /* "PyCafe.pyx":1521 * cdef str _METHOD = "getChannelDevice" * cdef string valString = str("") * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -52134,7 +52582,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1523 + /* "PyCafe.pyx":1522 * cdef string valString = str("") * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -52155,17 +52603,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafe.pyx":1524 + /* "PyCafe.pyx":1523 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(pv=handlePV, force=False) */ - __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1524, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1523, __pyx_L1_error) __pyx_v_handle = __pyx_t_6; - /* "PyCafe.pyx":1523 + /* "PyCafe.pyx":1522 * cdef string valString = str("") * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -52175,7 +52623,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 goto __pyx_L3; } - /* "PyCafe.pyx":1525 + /* "PyCafe.pyx":1524 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -52186,23 +52634,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":1526 + /* "PyCafe.pyx":1525 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(pv=handlePV, force=False) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1526, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1525, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.force = 0; - __pyx_t_1 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1526, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1525, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1526, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1525, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_handle = __pyx_t_6; - /* "PyCafe.pyx":1525 + /* "PyCafe.pyx":1524 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -52212,7 +52660,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 goto __pyx_L3; } - /* "PyCafe.pyx":1528 + /* "PyCafe.pyx":1527 * handle = self.checkForHandle(pv=handlePV, force=False) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -52220,10 +52668,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 * "First input argument, should be of type if handle, \ */ /*else*/ { - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1528, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "PyCafe.pyx":1529 + /* "PyCafe.pyx":1528 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -52245,7 +52693,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1528, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1527, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -52253,13 +52701,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1528, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1527, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_11 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 1528, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 1527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; @@ -52273,29 +52721,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_3); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_3); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_kp_u_First_input_argument_should_be_o_3); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1528, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":1528 + /* "PyCafe.pyx":1527 * handle = self.checkForHandle(pv=handlePV, force=False) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be of type if handle, \ */ - __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1528, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(3, 1528, __pyx_L1_error) + __PYX_ERR(3, 1527, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1532 + /* "PyCafe.pyx":1531 * "First input argument, should be of type if handle, \ * else if PV")) * if handle == 0: # <<<<<<<<<<<<<< @@ -52305,20 +52753,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 __pyx_t_3 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":1533 + /* "PyCafe.pyx":1532 * else if PV")) * if handle == 0: * valString = str("") # <<<<<<<<<<<<<< * if isinstance(handlePV, (str)): * delSplit = handlePV.split(":") */ - __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1533, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1533, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1532, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_valString = __pyx_t_2; - /* "PyCafe.pyx":1534 + /* "PyCafe.pyx":1533 * if handle == 0: * valString = str("") * if isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -52329,14 +52777,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafe.pyx":1535 + /* "PyCafe.pyx":1534 * valString = str("") * if isinstance(handlePV, (str)): * delSplit = handlePV.split(":") # <<<<<<<<<<<<<< * if (len(delSplit) > 1): * valString = str(delSplit[0]) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_handlePV, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1535, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_handlePV, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { @@ -52350,40 +52798,40 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 } __pyx_t_8 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_11, __pyx_kp_u__42) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_kp_u__42); __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1535, __pyx_L1_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_delSplit = __pyx_t_8; __pyx_t_8 = 0; - /* "PyCafe.pyx":1536 + /* "PyCafe.pyx":1535 * if isinstance(handlePV, (str)): * delSplit = handlePV.split(":") * if (len(delSplit) > 1): # <<<<<<<<<<<<<< * valString = str(delSplit[0]) * else: */ - __pyx_t_12 = PyObject_Length(__pyx_v_delSplit); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1536, __pyx_L1_error) + __pyx_t_12 = PyObject_Length(__pyx_v_delSplit); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1535, __pyx_L1_error) __pyx_t_4 = ((__pyx_t_12 > 1) != 0); if (__pyx_t_4) { - /* "PyCafe.pyx":1537 + /* "PyCafe.pyx":1536 * delSplit = handlePV.split(":") * if (len(delSplit) > 1): * valString = str(delSplit[0]) # <<<<<<<<<<<<<< * else: * statusLocal = self.hh.getChannelDevice(handle, valString) */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_delSplit, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1537, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_delSplit, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1537, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1537, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1536, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_valString = __pyx_t_2; - /* "PyCafe.pyx":1536 + /* "PyCafe.pyx":1535 * if isinstance(handlePV, (str)): * delSplit = handlePV.split(":") * if (len(delSplit) > 1): # <<<<<<<<<<<<<< @@ -52392,7 +52840,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 */ } - /* "PyCafe.pyx":1534 + /* "PyCafe.pyx":1533 * if handle == 0: * valString = str("") * if isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -52401,7 +52849,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 */ } - /* "PyCafe.pyx":1532 + /* "PyCafe.pyx":1531 * "First input argument, should be of type if handle, \ * else if PV")) * if handle == 0: # <<<<<<<<<<<<<< @@ -52411,7 +52859,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 goto __pyx_L6; } - /* "PyCafe.pyx":1539 + /* "PyCafe.pyx":1538 * valString = str(delSplit[0]) * else: * statusLocal = self.hh.getChannelDevice(handle, valString) # <<<<<<<<<<<<<< @@ -52423,7 +52871,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 } __pyx_L6:; - /* "PyCafe.pyx":1540 + /* "PyCafe.pyx":1539 * else: * statusLocal = self.hh.getChannelDevice(handle, valString) * return valString # <<<<<<<<<<<<<< @@ -52431,13 +52879,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_valString); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1540, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_valString); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1519 + /* "PyCafe.pyx":1518 * * ############################################################################ * def getChannelDevice(self, handlePV): # <<<<<<<<<<<<<< @@ -52463,7 +52911,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_166getChannelDevice(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":1543 +/* "PyCafe.pyx":1542 * * ############################################################################ * def getChannelAttribute(self, handlePV): # <<<<<<<<<<<<<< @@ -52506,7 +52954,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob Py_ssize_t __pyx_t_12; __Pyx_RefNannySetupContext("getChannelAttribute", 0); - /* "PyCafe.pyx":1544 + /* "PyCafe.pyx":1543 * ############################################################################ * def getChannelAttribute(self, handlePV): * cdef str _METHOD = "getChannelAttribute" # <<<<<<<<<<<<<< @@ -52516,20 +52964,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob __Pyx_INCREF(__pyx_n_u_getChannelAttribute); __pyx_v__METHOD = __pyx_n_u_getChannelAttribute; - /* "PyCafe.pyx":1545 + /* "PyCafe.pyx":1544 * def getChannelAttribute(self, handlePV): * cdef str _METHOD = "getChannelAttribute" * cdef string valString = str("") # <<<<<<<<<<<<<< * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1545, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1544, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1545, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1544, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_valString = __pyx_t_2; - /* "PyCafe.pyx":1546 + /* "PyCafe.pyx":1545 * cdef str _METHOD = "getChannelAttribute" * cdef string valString = str("") * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -52538,7 +52986,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1547 + /* "PyCafe.pyx":1546 * cdef string valString = str("") * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -52559,17 +53007,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafe.pyx":1548 + /* "PyCafe.pyx":1547 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(pv=handlePV, force=False) */ - __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1548, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1547, __pyx_L1_error) __pyx_v_handle = __pyx_t_6; - /* "PyCafe.pyx":1547 + /* "PyCafe.pyx":1546 * cdef string valString = str("") * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -52579,7 +53027,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob goto __pyx_L3; } - /* "PyCafe.pyx":1549 + /* "PyCafe.pyx":1548 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -52590,23 +53038,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":1550 + /* "PyCafe.pyx":1549 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(pv=handlePV, force=False) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1550, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1549, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.force = 0; - __pyx_t_1 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1550, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1549, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1550, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1549, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_handle = __pyx_t_6; - /* "PyCafe.pyx":1549 + /* "PyCafe.pyx":1548 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -52616,7 +53064,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob goto __pyx_L3; } - /* "PyCafe.pyx":1552 + /* "PyCafe.pyx":1551 * handle = self.checkForHandle(pv=handlePV, force=False) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -52624,10 +53072,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob * "First input argument, should be of type if handle, \ */ /*else*/ { - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1552, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "PyCafe.pyx":1553 + /* "PyCafe.pyx":1552 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -52649,7 +53097,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1552, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1551, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -52657,13 +53105,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_3}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1552, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1551, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_11 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 1552, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 1551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; @@ -52677,29 +53125,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_3); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_3); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_kp_u_First_input_argument_should_be_o_3); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1552, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":1552 + /* "PyCafe.pyx":1551 * handle = self.checkForHandle(pv=handlePV, force=False) * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument, should be of type if handle, \ */ - __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1552, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(3, 1552, __pyx_L1_error) + __PYX_ERR(3, 1551, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1556 + /* "PyCafe.pyx":1555 * "First input argument, should be of type if handle, \ * else if PV")) * if handle == 0: # <<<<<<<<<<<<<< @@ -52709,20 +53157,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob __pyx_t_3 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":1557 + /* "PyCafe.pyx":1556 * else if PV")) * if handle == 0: * valString = str("") # <<<<<<<<<<<<<< * if isinstance(handlePV, (str)): * delSplit = handlePV.split(":") */ - __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1557, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1557, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1556, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_valString = __pyx_t_2; - /* "PyCafe.pyx":1558 + /* "PyCafe.pyx":1557 * if handle == 0: * valString = str("") * if isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -52733,14 +53181,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "PyCafe.pyx":1559 + /* "PyCafe.pyx":1558 * valString = str("") * if isinstance(handlePV, (str)): * delSplit = handlePV.split(":") # <<<<<<<<<<<<<< * if (len(delSplit) > 1): * valString = str(delSplit[0]) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_handlePV, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1559, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_handlePV, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { @@ -52754,40 +53202,40 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob } __pyx_t_8 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_11, __pyx_kp_u__42) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_kp_u__42); __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1559, __pyx_L1_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_delSplit = __pyx_t_8; __pyx_t_8 = 0; - /* "PyCafe.pyx":1560 + /* "PyCafe.pyx":1559 * if isinstance(handlePV, (str)): * delSplit = handlePV.split(":") * if (len(delSplit) > 1): # <<<<<<<<<<<<<< * valString = str(delSplit[0]) * else: */ - __pyx_t_12 = PyObject_Length(__pyx_v_delSplit); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1560, __pyx_L1_error) + __pyx_t_12 = PyObject_Length(__pyx_v_delSplit); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1559, __pyx_L1_error) __pyx_t_4 = ((__pyx_t_12 > 1) != 0); if (__pyx_t_4) { - /* "PyCafe.pyx":1561 + /* "PyCafe.pyx":1560 * delSplit = handlePV.split(":") * if (len(delSplit) > 1): * valString = str(delSplit[0]) # <<<<<<<<<<<<<< * else: * statusLocal = self.hh.getChannelAttribute(handle, valString) */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_delSplit, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1561, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_delSplit, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1561, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1561, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1560, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_valString = __pyx_t_2; - /* "PyCafe.pyx":1560 + /* "PyCafe.pyx":1559 * if isinstance(handlePV, (str)): * delSplit = handlePV.split(":") * if (len(delSplit) > 1): # <<<<<<<<<<<<<< @@ -52796,7 +53244,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob */ } - /* "PyCafe.pyx":1558 + /* "PyCafe.pyx":1557 * if handle == 0: * valString = str("") * if isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -52805,7 +53253,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob */ } - /* "PyCafe.pyx":1556 + /* "PyCafe.pyx":1555 * "First input argument, should be of type if handle, \ * else if PV")) * if handle == 0: # <<<<<<<<<<<<<< @@ -52815,7 +53263,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob goto __pyx_L6; } - /* "PyCafe.pyx":1563 + /* "PyCafe.pyx":1562 * valString = str(delSplit[0]) * else: * statusLocal = self.hh.getChannelAttribute(handle, valString) # <<<<<<<<<<<<<< @@ -52827,7 +53275,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob } __pyx_L6:; - /* "PyCafe.pyx":1564 + /* "PyCafe.pyx":1563 * else: * statusLocal = self.hh.getChannelAttribute(handle, valString) * return valString # <<<<<<<<<<<<<< @@ -52835,13 +53283,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_valString); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1564, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_valString); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1543 + /* "PyCafe.pyx":1542 * * ############################################################################ * def getChannelAttribute(self, handlePV): # <<<<<<<<<<<<<< @@ -52867,7 +53315,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_168getChannelAttribute(struct __pyx_ob return __pyx_r; } -/* "PyCafe.pyx":1569 +/* "PyCafe.pyx":1568 * * @verify_handlepv * def getDescription(self, handlePV): # <<<<<<<<<<<<<< @@ -52898,17 +53346,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_170getDescription(struct __pyx_obj_6Py PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("getDescription", 0); - /* "PyCafe.pyx":1570 + /* "PyCafe.pyx":1569 * @verify_handlepv * def getDescription(self, handlePV): * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * if not self.hh.hasDescription(handle): * with nogil: */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1570, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1569, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":1571 + /* "PyCafe.pyx":1570 * def getDescription(self, handlePV): * cdef unsigned int handle = handlePV * if not self.hh.hasDescription(handle): # <<<<<<<<<<<<<< @@ -52918,7 +53366,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_170getDescription(struct __pyx_obj_6Py __pyx_t_2 = ((!(__pyx_v_self->hh.hasDescription(__pyx_v_handle) != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1572 + /* "PyCafe.pyx":1571 * cdef unsigned int handle = handlePV * if not self.hh.hasDescription(handle): * with nogil: # <<<<<<<<<<<<<< @@ -52933,7 +53381,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_170getDescription(struct __pyx_obj_6Py #endif /*try:*/ { - /* "PyCafe.pyx":1573 + /* "PyCafe.pyx":1572 * if not self.hh.hasDescription(handle): * with nogil: * self._c_cafe.supplementHandle(handle) # <<<<<<<<<<<<<< @@ -52943,7 +53391,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_170getDescription(struct __pyx_obj_6Py (void)(__pyx_v_self->_c_cafe->supplementHandle(__pyx_v_handle)); } - /* "PyCafe.pyx":1572 + /* "PyCafe.pyx":1571 * cdef unsigned int handle = handlePV * if not self.hh.hasDescription(handle): * with nogil: # <<<<<<<<<<<<<< @@ -52962,7 +53410,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_170getDescription(struct __pyx_obj_6Py } } - /* "PyCafe.pyx":1571 + /* "PyCafe.pyx":1570 * def getDescription(self, handlePV): * cdef unsigned int handle = handlePV * if not self.hh.hasDescription(handle): # <<<<<<<<<<<<<< @@ -52971,7 +53419,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_170getDescription(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":1575 + /* "PyCafe.pyx":1574 * self._c_cafe.supplementHandle(handle) * cdef string valString * self.hh.getDescription(handle, valString) # <<<<<<<<<<<<<< @@ -52980,7 +53428,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_170getDescription(struct __pyx_obj_6Py */ (void)(__pyx_v_self->hh.getDescription(__pyx_v_handle, __pyx_v_valString)); - /* "PyCafe.pyx":1576 + /* "PyCafe.pyx":1575 * cdef string valString * self.hh.getDescription(handle, valString) * return valString # <<<<<<<<<<<<<< @@ -52988,13 +53436,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_170getDescription(struct __pyx_obj_6Py * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_valString); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1576, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_valString); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1569 + /* "PyCafe.pyx":1568 * * @verify_handlepv * def getDescription(self, handlePV): # <<<<<<<<<<<<<< @@ -53015,7 +53463,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_170getDescription(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":1580 +/* "PyCafe.pyx":1579 * ############################################################################ * @verify_handlepv * def hasDescription(self, handlePV): # <<<<<<<<<<<<<< @@ -53043,7 +53491,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_172hasDescription(struct __pyx_obj_6Py PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("hasDescription", 0); - /* "PyCafe.pyx":1581 + /* "PyCafe.pyx":1580 * @verify_handlepv * def hasDescription(self, handlePV): * return self.hh.hasDescription(handlePV) # <<<<<<<<<<<<<< @@ -53051,14 +53499,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_172hasDescription(struct __pyx_obj_6Py * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1581, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->hh.hasDescription(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1581, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1580, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->hh.hasDescription(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1580, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1580 + /* "PyCafe.pyx":1579 * ############################################################################ * @verify_handlepv * def hasDescription(self, handlePV): # <<<<<<<<<<<<<< @@ -53079,7 +53527,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_172hasDescription(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":1585 +/* "PyCafe.pyx":1584 * ############################################################################ * @verify_handlepv * def getUnits(self, handlePV): # <<<<<<<<<<<<<< @@ -53111,24 +53559,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_174getUnits(struct __pyx_obj_6PyCafe_C PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("getUnits", 0); - /* "PyCafe.pyx":1587 + /* "PyCafe.pyx":1586 * def getUnits(self, handlePV): * cdef string valString * self.hh.getUnits(handlePV, valString) # <<<<<<<<<<<<<< * cdef bytes bVal * bVal = valString */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1587, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1586, __pyx_L1_error) (void)(__pyx_v_self->hh.getUnits(__pyx_t_1, __pyx_v_valString)); - /* "PyCafe.pyx":1589 + /* "PyCafe.pyx":1588 * self.hh.getUnits(handlePV, valString) * cdef bytes bVal * bVal = valString # <<<<<<<<<<<<<< * unicode_units = (bVal).decode('latin-1') * return unicode_units */ - __pyx_t_2 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_valString); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1589, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_valString); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); @@ -53136,7 +53584,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_174getUnits(struct __pyx_obj_6PyCafe_C __pyx_v_bVal = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":1590 + /* "PyCafe.pyx":1589 * cdef bytes bVal * bVal = valString * unicode_units = (bVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -53145,14 +53593,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_174getUnits(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 1590, __pyx_L1_error) + __PYX_ERR(3, 1589, __pyx_L1_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1590, __pyx_L1_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_unicode_units = __pyx_t_3; __pyx_t_3 = 0; - /* "PyCafe.pyx":1591 + /* "PyCafe.pyx":1590 * bVal = valString * unicode_units = (bVal).decode('latin-1') * return unicode_units # <<<<<<<<<<<<<< @@ -53164,7 +53612,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_174getUnits(struct __pyx_obj_6PyCafe_C __pyx_r = __pyx_v_unicode_units; goto __pyx_L0; - /* "PyCafe.pyx":1585 + /* "PyCafe.pyx":1584 * ############################################################################ * @verify_handlepv * def getUnits(self, handlePV): # <<<<<<<<<<<<<< @@ -53188,7 +53636,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_174getUnits(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":1595 +/* "PyCafe.pyx":1594 * ############################################################################ * @verify_handlepv * def getPrecision(self, handlePV): # <<<<<<<<<<<<<< @@ -53217,7 +53665,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_176getPrecision(struct __pyx_obj_6PyCa PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getPrecision", 0); - /* "PyCafe.pyx":1596 + /* "PyCafe.pyx":1595 * @verify_handlepv * def getPrecision(self, handlePV): * cdef short precision = 0 # <<<<<<<<<<<<<< @@ -53226,17 +53674,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_176getPrecision(struct __pyx_obj_6PyCa */ __pyx_v_precision = 0; - /* "PyCafe.pyx":1597 + /* "PyCafe.pyx":1596 * def getPrecision(self, handlePV): * cdef short precision = 0 * self.hh.getPrecision(handlePV, precision) # <<<<<<<<<<<<<< * return precision * */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1597, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1596, __pyx_L1_error) (void)(__pyx_v_self->hh.getPrecision(__pyx_t_1, __pyx_v_precision)); - /* "PyCafe.pyx":1598 + /* "PyCafe.pyx":1597 * cdef short precision = 0 * self.hh.getPrecision(handlePV, precision) * return precision # <<<<<<<<<<<<<< @@ -53244,13 +53692,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_176getPrecision(struct __pyx_obj_6PyCa * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_short(__pyx_v_precision); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1598, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_short(__pyx_v_precision); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1597, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1595 + /* "PyCafe.pyx":1594 * ############################################################################ * @verify_handlepv * def getPrecision(self, handlePV): # <<<<<<<<<<<<<< @@ -53271,7 +53719,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_176getPrecision(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":1602 +/* "PyCafe.pyx":1601 * ############################################################################ * @verify_handlepv * def hasAlarmStatusSeverity(self, handlePV): # <<<<<<<<<<<<<< @@ -53299,7 +53747,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_178hasAlarmStatusSeverity(struct __pyx PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("hasAlarmStatusSeverity", 0); - /* "PyCafe.pyx":1603 + /* "PyCafe.pyx":1602 * @verify_handlepv * def hasAlarmStatusSeverity(self, handlePV): * return self.hh.hasAlarmStatusSeverity(handlePV) # <<<<<<<<<<<<<< @@ -53307,14 +53755,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_178hasAlarmStatusSeverity(struct __pyx * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1603, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->hh.hasAlarmStatusSeverity(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1603, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1602, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->hh.hasAlarmStatusSeverity(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1602 + /* "PyCafe.pyx":1601 * ############################################################################ * @verify_handlepv * def hasAlarmStatusSeverity(self, handlePV): # <<<<<<<<<<<<<< @@ -53335,7 +53783,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_178hasAlarmStatusSeverity(struct __pyx return __pyx_r; } -/* "PyCafe.pyx":1607 +/* "PyCafe.pyx":1606 * ############################################################################ * @verify_handlepv * def getAlarmStatusSeverity(self, handlePV): # <<<<<<<<<<<<<< @@ -53366,17 +53814,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_180getAlarmStatusSeverity(struct __pyx PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getAlarmStatusSeverity", 0); - /* "PyCafe.pyx":1609 + /* "PyCafe.pyx":1608 * def getAlarmStatusSeverity(self, handlePV): * cdef short aStatSev[2] * self.hh.getAlarmStatusSeverity(handlePV, aStatSev) # <<<<<<<<<<<<<< * return aStatSev[0], aStatSev[1] * */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1609, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1608, __pyx_L1_error) (void)(__pyx_v_self->hh.getAlarmStatusSeverity(__pyx_t_1, __pyx_v_aStatSev)); - /* "PyCafe.pyx":1610 + /* "PyCafe.pyx":1609 * cdef short aStatSev[2] * self.hh.getAlarmStatusSeverity(handlePV, aStatSev) * return aStatSev[0], aStatSev[1] # <<<<<<<<<<<<<< @@ -53384,11 +53832,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_180getAlarmStatusSeverity(struct __pyx * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_short((__pyx_v_aStatSev[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1610, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_short((__pyx_v_aStatSev[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_From_short((__pyx_v_aStatSev[1])); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1610, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_short((__pyx_v_aStatSev[1])); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1610, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); @@ -53400,7 +53848,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_180getAlarmStatusSeverity(struct __pyx __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1607 + /* "PyCafe.pyx":1606 * ############################################################################ * @verify_handlepv * def getAlarmStatusSeverity(self, handlePV): # <<<<<<<<<<<<<< @@ -53423,7 +53871,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_180getAlarmStatusSeverity(struct __pyx return __pyx_r; } -/* "PyCafe.pyx":1614 +/* "PyCafe.pyx":1613 * ############################################################################ * @verify_handlepv * def getTimeStamp(self, handlePV): # <<<<<<<<<<<<<< @@ -53454,53 +53902,53 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_182getTimeStamp(struct __pyx_obj_6PyCa int __pyx_t_3; __Pyx_RefNannySetupContext("getTimeStamp", 0); - /* "PyCafe.pyx":1617 + /* "PyCafe.pyx":1616 * * cdef HandleHelper hh * hh._etsNorm = self.hh.getEpicsTimeStampAsUInt32(handlePV) # <<<<<<<<<<<<<< * * cpdef ll = [] */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1617, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1616, __pyx_L1_error) __pyx_v_hh._etsNorm = __pyx_v_self->hh.getEpicsTimeStampAsUInt32(__pyx_t_1); - /* "PyCafe.pyx":1619 + /* "PyCafe.pyx":1618 * hh._etsNorm = self.hh.getEpicsTimeStampAsUInt32(handlePV) * * cpdef ll = [] # <<<<<<<<<<<<<< * ll.append(hh._etsNorm.secPastEpoch) * ll.append(hh._etsNorm.nsec) */ - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1619, __pyx_L1_error) + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_ll = __pyx_t_2; __pyx_t_2 = 0; - /* "PyCafe.pyx":1620 + /* "PyCafe.pyx":1619 * * cpdef ll = [] * ll.append(hh._etsNorm.secPastEpoch) # <<<<<<<<<<<<<< * ll.append(hh._etsNorm.nsec) * */ - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_hh._etsNorm.secPastEpoch); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1620, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_hh._etsNorm.secPastEpoch); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ll, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1620, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ll, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1619, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1621 + /* "PyCafe.pyx":1620 * cpdef ll = [] * ll.append(hh._etsNorm.secPastEpoch) * ll.append(hh._etsNorm.nsec) # <<<<<<<<<<<<<< * * return ll */ - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_hh._etsNorm.nsec); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1621, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_hh._etsNorm.nsec); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1620, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ll, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1621, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ll, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1620, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1623 + /* "PyCafe.pyx":1622 * ll.append(hh._etsNorm.nsec) * * return ll # <<<<<<<<<<<<<< @@ -53512,7 +53960,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_182getTimeStamp(struct __pyx_obj_6PyCa __pyx_r = __pyx_v_ll; goto __pyx_L0; - /* "PyCafe.pyx":1614 + /* "PyCafe.pyx":1613 * ############################################################################ * @verify_handlepv * def getTimeStamp(self, handlePV): # <<<<<<<<<<<<<< @@ -53534,7 +53982,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_182getTimeStamp(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":1627 +/* "PyCafe.pyx":1626 * ############################################################################ * @verify_handlepv * def getTimeStampAsDate(self, handlePV): # <<<<<<<<<<<<<< @@ -53565,113 +54013,113 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_184getTimeStampAsDate(struct __pyx_obj int __pyx_t_3; __Pyx_RefNannySetupContext("getTimeStampAsDate", 0); - /* "PyCafe.pyx":1630 + /* "PyCafe.pyx":1629 * * cdef HandleHelper hh * cpdef ld = [] # <<<<<<<<<<<<<< * * hh._etsDate = self.hh.getEpicsTimeStampAsDate(handlePV) */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1630, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ld = __pyx_t_1; __pyx_t_1 = 0; - /* "PyCafe.pyx":1632 + /* "PyCafe.pyx":1631 * cpdef ld = [] * * hh._etsDate = self.hh.getEpicsTimeStampAsDate(handlePV) # <<<<<<<<<<<<<< * ld.append(hh._etsDate.year) * ld.append(hh._etsDate.mon) */ - __pyx_t_2 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_2 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1632, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_2 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1631, __pyx_L1_error) __pyx_v_hh._etsDate = __pyx_v_self->hh.getEpicsTimeStampAsDate(__pyx_t_2); - /* "PyCafe.pyx":1633 + /* "PyCafe.pyx":1632 * * hh._etsDate = self.hh.getEpicsTimeStampAsDate(handlePV) * ld.append(hh._etsDate.year) # <<<<<<<<<<<<<< * ld.append(hh._etsDate.mon) * ld.append(hh._etsDate.day) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.year); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1633, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.year); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1632, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1633, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1632, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1634 + /* "PyCafe.pyx":1633 * hh._etsDate = self.hh.getEpicsTimeStampAsDate(handlePV) * ld.append(hh._etsDate.year) * ld.append(hh._etsDate.mon) # <<<<<<<<<<<<<< * ld.append(hh._etsDate.day) * ld.append(hh._etsDate.hour) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.mon); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1634, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.mon); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1634, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1633, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1635 + /* "PyCafe.pyx":1634 * 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) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.day); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1635, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.day); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1634, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1635, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1634, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1636 + /* "PyCafe.pyx":1635 * 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) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.hour); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1636, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.hour); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1635, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1636, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1635, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1637 + /* "PyCafe.pyx":1636 * 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) */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.min); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1637, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.min); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1636, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1637, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1636, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1638 + /* "PyCafe.pyx":1637 * ld.append(hh._etsDate.hour) * ld.append(hh._etsDate.min) * ld.append(hh._etsDate.sec) # <<<<<<<<<<<<<< * ld.append(hh._etsDate.nsec) * */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.sec); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1638, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_hh._etsDate.sec); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1637, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1638, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1637, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1639 + /* "PyCafe.pyx":1638 * ld.append(hh._etsDate.min) * ld.append(hh._etsDate.sec) * ld.append(hh._etsDate.nsec) # <<<<<<<<<<<<<< * * return ld */ - __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_hh._etsDate.nsec); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1639, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_hh._etsDate.nsec); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1638, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1639, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_ld, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 1638, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1641 + /* "PyCafe.pyx":1640 * ld.append(hh._etsDate.nsec) * * return ld # <<<<<<<<<<<<<< @@ -53683,7 +54131,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_184getTimeStampAsDate(struct __pyx_obj __pyx_r = __pyx_v_ld; goto __pyx_L0; - /* "PyCafe.pyx":1627 + /* "PyCafe.pyx":1626 * ############################################################################ * @verify_handlepv * def getTimeStampAsDate(self, handlePV): # <<<<<<<<<<<<<< @@ -53705,7 +54153,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_184getTimeStampAsDate(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":1645 +/* "PyCafe.pyx":1644 * ############################################################################ * ### Allow user to choose whether or not to open ##### * cpdef checkForHandle(self, str pv, bint force=True): # <<<<<<<<<<<<<< @@ -53744,11 +54192,11 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe else { PY_UINT64_T type_dict_guard = (likely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dict)) ? __PYX_GET_DICT_VERSION(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dict) : 0; #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checkForHandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1645, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checkForHandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_6PyCafe_6CyCafe_187checkForHandle)) { __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_force); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1645, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_force); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; @@ -53766,7 +54214,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_pv, __pyx_t_3}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1645, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1644, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -53775,14 +54223,14 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_pv, __pyx_t_3}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1645, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1644, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { - __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1645, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -53793,7 +54241,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1645, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } @@ -53816,7 +54264,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe #endif } - /* "PyCafe.pyx":1646 + /* "PyCafe.pyx":1645 * ### Allow user to choose whether or not to open ##### * cpdef checkForHandle(self, str pv, bint force=True): * cdef unsigned int _handle = 0 # <<<<<<<<<<<<<< @@ -53825,17 +54273,17 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe */ __pyx_v__handle = 0; - /* "PyCafe.pyx":1647 + /* "PyCafe.pyx":1646 * cpdef checkForHandle(self, str pv, bint force=True): * cdef unsigned int _handle = 0 * _handle = self.hh.getHandleFromPV(pv) # <<<<<<<<<<<<<< * if _handle == 0: * if (force): */ - __pyx_t_8 = __Pyx_PyObject_AsString(__pyx_v_pv); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(3, 1647, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_AsString(__pyx_v_pv); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(3, 1646, __pyx_L1_error) __pyx_v__handle = __pyx_v_self->hh.getHandleFromPV(__pyx_t_8); - /* "PyCafe.pyx":1648 + /* "PyCafe.pyx":1647 * cdef unsigned int _handle = 0 * _handle = self.hh.getHandleFromPV(pv) * if _handle == 0: # <<<<<<<<<<<<<< @@ -53845,7 +54293,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe __pyx_t_9 = ((__pyx_v__handle == 0) != 0); if (__pyx_t_9) { - /* "PyCafe.pyx":1649 + /* "PyCafe.pyx":1648 * _handle = self.hh.getHandleFromPV(pv) * if _handle == 0: * if (force): # <<<<<<<<<<<<<< @@ -53855,7 +54303,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe __pyx_t_9 = (__pyx_v_force != 0); if (__pyx_t_9) { - /* "PyCafe.pyx":1650 + /* "PyCafe.pyx":1649 * if _handle == 0: * if (force): * return self.open(pv) # <<<<<<<<<<<<<< @@ -53863,7 +54311,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe * return 0 */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_open); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1650, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_open); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1649, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -53877,14 +54325,14 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_pv) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_pv); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1650, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1649, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1649 + /* "PyCafe.pyx":1648 * _handle = self.hh.getHandleFromPV(pv) * if _handle == 0: * if (force): # <<<<<<<<<<<<<< @@ -53894,7 +54342,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe goto __pyx_L4; } - /* "PyCafe.pyx":1652 + /* "PyCafe.pyx":1651 * return self.open(pv) * else: * return 0 # <<<<<<<<<<<<<< @@ -53909,7 +54357,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe } __pyx_L4:; - /* "PyCafe.pyx":1648 + /* "PyCafe.pyx":1647 * cdef unsigned int _handle = 0 * _handle = self.hh.getHandleFromPV(pv) * if _handle == 0: # <<<<<<<<<<<<<< @@ -53919,7 +54367,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe goto __pyx_L3; } - /* "PyCafe.pyx":1654 + /* "PyCafe.pyx":1653 * return 0 * else: * return _handle # <<<<<<<<<<<<<< @@ -53928,7 +54376,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe */ /*else*/ { __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v__handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1654, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v__handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -53936,7 +54384,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandle(struct __pyx_obj_6PyCafe } __pyx_L3:; - /* "PyCafe.pyx":1645 + /* "PyCafe.pyx":1644 * ############################################################################ * ### Allow user to choose whether or not to open ##### * cpdef checkForHandle(self, str pv, bint force=True): # <<<<<<<<<<<<<< @@ -53997,7 +54445,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_187checkForHandle(PyObject *__pyx_v_se } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "checkForHandle") < 0)) __PYX_ERR(3, 1645, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "checkForHandle") < 0)) __PYX_ERR(3, 1644, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -54010,20 +54458,20 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_187checkForHandle(PyObject *__pyx_v_se } __pyx_v_pv = ((PyObject*)values[0]); if (values[1]) { - __pyx_v_force = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_force == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1645, __pyx_L3_error) + __pyx_v_force = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_force == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1644, __pyx_L3_error) } else { __pyx_v_force = ((int)1); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("checkForHandle", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1645, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("checkForHandle", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1644, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.checkForHandle", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pv), (&PyUnicode_Type), 1, "pv", 1))) __PYX_ERR(3, 1645, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pv), (&PyUnicode_Type), 1, "pv", 1))) __PYX_ERR(3, 1644, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_186checkForHandle(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_pv, __pyx_v_force); /* function exit code */ @@ -54044,7 +54492,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_186checkForHandle(struct __pyx_obj_6Py __Pyx_XDECREF(__pyx_r); __pyx_t_2.__pyx_n = 1; __pyx_t_2.force = __pyx_v_force; - __pyx_t_1 = __pyx_vtabptr_6PyCafe_CyCafe->checkForHandle(__pyx_v_self, __pyx_v_pv, 1, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1645, __pyx_L1_error) + __pyx_t_1 = __pyx_vtabptr_6PyCafe_CyCafe->checkForHandle(__pyx_v_self, __pyx_v_pv, 1, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -54061,7 +54509,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_186checkForHandle(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":1658 +/* "PyCafe.pyx":1657 * * ############################################################################ * cpdef checkForHandleList(self, list pvList, bint force=True): # <<<<<<<<<<<<<< @@ -54108,11 +54556,11 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py else { PY_UINT64_T type_dict_guard = (likely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dict)) ? __PYX_GET_DICT_VERSION(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dict) : 0; #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checkForHandleList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1658, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checkForHandleList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_6PyCafe_6CyCafe_189checkForHandleList)) { __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_force); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1658, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_force); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; @@ -54130,7 +54578,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_pvList, __pyx_t_3}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1658, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1657, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -54139,14 +54587,14 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_pvList, __pyx_t_3}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1658, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1657, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { - __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1658, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -54157,7 +54605,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1658, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } @@ -54180,7 +54628,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py #endif } - /* "PyCafe.pyx":1660 + /* "PyCafe.pyx":1659 * cpdef checkForHandleList(self, list pvList, bint force=True): * * cdef unsigned int nToOpen = 0 # <<<<<<<<<<<<<< @@ -54189,19 +54637,19 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py */ __pyx_v_nToOpen = 0; - /* "PyCafe.pyx":1661 + /* "PyCafe.pyx":1660 * * cdef unsigned int nToOpen = 0 * handleList = [] # <<<<<<<<<<<<<< * cdef unsigned int _handle = 0 * for i in range(0, len(pvList)): */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1661, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_handleList = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1662 + /* "PyCafe.pyx":1661 * cdef unsigned int nToOpen = 0 * handleList = [] * cdef unsigned int _handle = 0 # <<<<<<<<<<<<<< @@ -54210,7 +54658,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py */ __pyx_v__handle = 0; - /* "PyCafe.pyx":1663 + /* "PyCafe.pyx":1662 * handleList = [] * cdef unsigned int _handle = 0 * for i in range(0, len(pvList)): # <<<<<<<<<<<<<< @@ -54219,14 +54667,14 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py */ if (unlikely(__pyx_v_pvList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 1663, __pyx_L1_error) + __PYX_ERR(3, 1662, __pyx_L1_error) } - __pyx_t_8 = PyList_GET_SIZE(__pyx_v_pvList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1663, __pyx_L1_error) + __pyx_t_8 = PyList_GET_SIZE(__pyx_v_pvList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 1662, __pyx_L1_error) __pyx_t_9 = __pyx_t_8; for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { __pyx_v_i = __pyx_t_10; - /* "PyCafe.pyx":1664 + /* "PyCafe.pyx":1663 * cdef unsigned int _handle = 0 * for i in range(0, len(pvList)): * _handle = self.hh.getHandleFromPV(pvList[i]) # <<<<<<<<<<<<<< @@ -54235,15 +54683,15 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py */ if (unlikely(__pyx_v_pvList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1664, __pyx_L1_error) + __PYX_ERR(3, 1663, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_pvList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1664, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_pvList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) __PYX_ERR(3, 1664, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) __PYX_ERR(3, 1663, __pyx_L1_error) __pyx_v__handle = __pyx_v_self->hh.getHandleFromPV(__pyx_t_11); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1665 + /* "PyCafe.pyx":1664 * for i in range(0, len(pvList)): * _handle = self.hh.getHandleFromPV(pvList[i]) * if _handle == 0: # <<<<<<<<<<<<<< @@ -54253,7 +54701,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py __pyx_t_12 = ((__pyx_v__handle == 0) != 0); if (__pyx_t_12) { - /* "PyCafe.pyx":1666 + /* "PyCafe.pyx":1665 * _handle = self.hh.getHandleFromPV(pvList[i]) * if _handle == 0: * if (force): # <<<<<<<<<<<<<< @@ -54263,7 +54711,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py __pyx_t_12 = (__pyx_v_force != 0); if (__pyx_t_12) { - /* "PyCafe.pyx":1667 + /* "PyCafe.pyx":1666 * if _handle == 0: * if (force): * nToOpen = nToOpen+1 # <<<<<<<<<<<<<< @@ -54272,14 +54720,14 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py */ __pyx_v_nToOpen = (__pyx_v_nToOpen + 1); - /* "PyCafe.pyx":1668 + /* "PyCafe.pyx":1667 * if (force): * nToOpen = nToOpen+1 * self.openNoWait() # <<<<<<<<<<<<<< * _handle = self.open(pvList[i]) * handleList.append(_handle) */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openNoWait); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1668, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openNoWait); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -54293,25 +54741,25 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1668, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1669 + /* "PyCafe.pyx":1668 * nToOpen = nToOpen+1 * self.openNoWait() * _handle = self.open(pvList[i]) # <<<<<<<<<<<<<< * handleList.append(_handle) * else: */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_open); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1669, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_open); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (unlikely(__pyx_v_pvList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 1669, __pyx_L1_error) + __PYX_ERR(3, 1668, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_pvList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1669, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_pvList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -54326,14 +54774,14 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_7, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1669, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1669, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1668, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v__handle = __pyx_t_13; - /* "PyCafe.pyx":1666 + /* "PyCafe.pyx":1665 * _handle = self.hh.getHandleFromPV(pvList[i]) * if _handle == 0: * if (force): # <<<<<<<<<<<<<< @@ -54342,19 +54790,19 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":1670 + /* "PyCafe.pyx":1669 * self.openNoWait() * _handle = self.open(pvList[i]) * handleList.append(_handle) # <<<<<<<<<<<<<< * else: * handleList.append(_handle) */ - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v__handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1670, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v__handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1669, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_handleList, __pyx_t_1); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 1670, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_handleList, __pyx_t_1); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 1669, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1665 + /* "PyCafe.pyx":1664 * for i in range(0, len(pvList)): * _handle = self.hh.getHandleFromPV(pvList[i]) * if _handle == 0: # <<<<<<<<<<<<<< @@ -54364,7 +54812,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py goto __pyx_L5; } - /* "PyCafe.pyx":1672 + /* "PyCafe.pyx":1671 * handleList.append(_handle) * else: * handleList.append(_handle) # <<<<<<<<<<<<<< @@ -54372,15 +54820,15 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py * self.openNowAndWait(2.0+nToOpen*0.01) */ /*else*/ { - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v__handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1672, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v__handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1671, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_handleList, __pyx_t_1); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 1672, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_handleList, __pyx_t_1); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 1671, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_L5:; } - /* "PyCafe.pyx":1673 + /* "PyCafe.pyx":1672 * else: * handleList.append(_handle) * if nToOpen > 0: # <<<<<<<<<<<<<< @@ -54390,16 +54838,16 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py __pyx_t_12 = ((__pyx_v_nToOpen > 0) != 0); if (__pyx_t_12) { - /* "PyCafe.pyx":1674 + /* "PyCafe.pyx":1673 * handleList.append(_handle) * if nToOpen > 0: * self.openNowAndWait(2.0+nToOpen*0.01) # <<<<<<<<<<<<<< * return handleList * ############################################################################ */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openNowAndWait); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1674, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_openNowAndWait); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1673, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = PyFloat_FromDouble((2.0 + (__pyx_v_nToOpen * 0.01))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1674, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((2.0 + (__pyx_v_nToOpen * 0.01))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1673, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -54414,12 +54862,12 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_7, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1674, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1673, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":1673 + /* "PyCafe.pyx":1672 * else: * handleList.append(_handle) * if nToOpen > 0: # <<<<<<<<<<<<<< @@ -54428,7 +54876,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":1675 + /* "PyCafe.pyx":1674 * if nToOpen > 0: * self.openNowAndWait(2.0+nToOpen*0.01) * return handleList # <<<<<<<<<<<<<< @@ -54440,7 +54888,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForHandleList(struct __pyx_obj_6Py __pyx_r = __pyx_v_handleList; goto __pyx_L0; - /* "PyCafe.pyx":1658 + /* "PyCafe.pyx":1657 * * ############################################################################ * cpdef checkForHandleList(self, list pvList, bint force=True): # <<<<<<<<<<<<<< @@ -54502,7 +54950,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_189checkForHandleList(PyObject *__pyx_ } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "checkForHandleList") < 0)) __PYX_ERR(3, 1658, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "checkForHandleList") < 0)) __PYX_ERR(3, 1657, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -54515,20 +54963,20 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_189checkForHandleList(PyObject *__pyx_ } __pyx_v_pvList = ((PyObject*)values[0]); if (values[1]) { - __pyx_v_force = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_force == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1658, __pyx_L3_error) + __pyx_v_force = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_force == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1657, __pyx_L3_error) } else { __pyx_v_force = ((int)1); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("checkForHandleList", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1658, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("checkForHandleList", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1657, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.checkForHandleList", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pvList), (&PyList_Type), 1, "pvList", 1))) __PYX_ERR(3, 1658, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pvList), (&PyList_Type), 1, "pvList", 1))) __PYX_ERR(3, 1657, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_188checkForHandleList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_pvList, __pyx_v_force); /* function exit code */ @@ -54549,7 +54997,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_188checkForHandleList(struct __pyx_obj __Pyx_XDECREF(__pyx_r); __pyx_t_2.__pyx_n = 1; __pyx_t_2.force = __pyx_v_force; - __pyx_t_1 = __pyx_vtabptr_6PyCafe_CyCafe->checkForHandleList(__pyx_v_self, __pyx_v_pvList, 1, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1658, __pyx_L1_error) + __pyx_t_1 = __pyx_vtabptr_6PyCafe_CyCafe->checkForHandleList(__pyx_v_self, __pyx_v_pvList, 1, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -54566,7 +55014,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_188checkForHandleList(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":1679 +/* "PyCafe.pyx":1678 * * ############################################################################ * cpdef checkForGroupHandle(self, str gName, bint force=True): # <<<<<<<<<<<<<< @@ -54605,11 +55053,11 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P else { PY_UINT64_T type_dict_guard = (likely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dict)) ? __PYX_GET_DICT_VERSION(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dict) : 0; #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checkForGroupHandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1679, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checkForGroupHandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_6PyCafe_6CyCafe_191checkForGroupHandle)) { __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_force); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1679, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_force); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; @@ -54627,7 +55075,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_gName, __pyx_t_3}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1679, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1678, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -54636,14 +55084,14 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_gName, __pyx_t_3}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1679, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1678, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { - __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1679, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -54654,7 +55102,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1679, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } @@ -54677,7 +55125,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P #endif } - /* "PyCafe.pyx":1680 + /* "PyCafe.pyx":1679 * ############################################################################ * cpdef checkForGroupHandle(self, str gName, bint force=True): * cdef unsigned int _ghandle = 0 # <<<<<<<<<<<<<< @@ -54686,17 +55134,17 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P */ __pyx_v__ghandle = 0; - /* "PyCafe.pyx":1681 + /* "PyCafe.pyx":1680 * cpdef checkForGroupHandle(self, str gName, bint force=True): * cdef unsigned int _ghandle = 0 * _ghandle = self.hh.getGroupHandleFromGroupName(gName) # <<<<<<<<<<<<<< * if _ghandle == 0: * if (force): */ - __pyx_t_8 = __Pyx_PyObject_AsString(__pyx_v_gName); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(3, 1681, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_AsString(__pyx_v_gName); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(3, 1680, __pyx_L1_error) __pyx_v__ghandle = __pyx_v_self->hh.getGroupHandleFromGroupName(__pyx_t_8); - /* "PyCafe.pyx":1682 + /* "PyCafe.pyx":1681 * cdef unsigned int _ghandle = 0 * _ghandle = self.hh.getGroupHandleFromGroupName(gName) * if _ghandle == 0: # <<<<<<<<<<<<<< @@ -54706,7 +55154,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P __pyx_t_9 = ((__pyx_v__ghandle == 0) != 0); if (__pyx_t_9) { - /* "PyCafe.pyx":1683 + /* "PyCafe.pyx":1682 * _ghandle = self.hh.getGroupHandleFromGroupName(gName) * if _ghandle == 0: * if (force): # <<<<<<<<<<<<<< @@ -54716,7 +55164,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P __pyx_t_9 = (__pyx_v_force != 0); if (__pyx_t_9) { - /* "PyCafe.pyx":1684 + /* "PyCafe.pyx":1683 * if _ghandle == 0: * if (force): * return self.groupOpen(gName) # <<<<<<<<<<<<<< @@ -54724,7 +55172,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P * return 0 */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_groupOpen); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1684, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_groupOpen); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1683, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -54738,14 +55186,14 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_gName) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_gName); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1684, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1683, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1683 + /* "PyCafe.pyx":1682 * _ghandle = self.hh.getGroupHandleFromGroupName(gName) * if _ghandle == 0: * if (force): # <<<<<<<<<<<<<< @@ -54755,7 +55203,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P goto __pyx_L4; } - /* "PyCafe.pyx":1686 + /* "PyCafe.pyx":1685 * return self.groupOpen(gName) * else: * return 0 # <<<<<<<<<<<<<< @@ -54770,7 +55218,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P } __pyx_L4:; - /* "PyCafe.pyx":1682 + /* "PyCafe.pyx":1681 * cdef unsigned int _ghandle = 0 * _ghandle = self.hh.getGroupHandleFromGroupName(gName) * if _ghandle == 0: # <<<<<<<<<<<<<< @@ -54780,7 +55228,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P goto __pyx_L3; } - /* "PyCafe.pyx":1688 + /* "PyCafe.pyx":1687 * return 0 * else: * return _ghandle # <<<<<<<<<<<<<< @@ -54789,7 +55237,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P */ /*else*/ { __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v__ghandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1688, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v__ghandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -54797,7 +55245,7 @@ static PyObject *__pyx_f_6PyCafe_6CyCafe_checkForGroupHandle(struct __pyx_obj_6P } __pyx_L3:; - /* "PyCafe.pyx":1679 + /* "PyCafe.pyx":1678 * * ############################################################################ * cpdef checkForGroupHandle(self, str gName, bint force=True): # <<<<<<<<<<<<<< @@ -54858,7 +55306,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_191checkForGroupHandle(PyObject *__pyx } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "checkForGroupHandle") < 0)) __PYX_ERR(3, 1679, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "checkForGroupHandle") < 0)) __PYX_ERR(3, 1678, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -54871,20 +55319,20 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_191checkForGroupHandle(PyObject *__pyx } __pyx_v_gName = ((PyObject*)values[0]); if (values[1]) { - __pyx_v_force = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_force == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1679, __pyx_L3_error) + __pyx_v_force = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_force == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1678, __pyx_L3_error) } else { __pyx_v_force = ((int)1); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("checkForGroupHandle", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1679, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("checkForGroupHandle", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1678, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.checkForGroupHandle", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gName), (&PyUnicode_Type), 1, "gName", 1))) __PYX_ERR(3, 1679, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gName), (&PyUnicode_Type), 1, "gName", 1))) __PYX_ERR(3, 1678, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_190checkForGroupHandle(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_gName, __pyx_v_force); /* function exit code */ @@ -54905,7 +55353,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_190checkForGroupHandle(struct __pyx_ob __Pyx_XDECREF(__pyx_r); __pyx_t_2.__pyx_n = 1; __pyx_t_2.force = __pyx_v_force; - __pyx_t_1 = __pyx_vtabptr_6PyCafe_CyCafe->checkForGroupHandle(__pyx_v_self, __pyx_v_gName, 1, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1679, __pyx_L1_error) + __pyx_t_1 = __pyx_vtabptr_6PyCafe_CyCafe->checkForGroupHandle(__pyx_v_self, __pyx_v_gName, 1, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -54922,7 +55370,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_190checkForGroupHandle(struct __pyx_ob return __pyx_r; } -/* "PyCafe.pyx":1693 +/* "PyCafe.pyx":1692 * ############################################################################ * * def getPVNameFromHandle(self, int h): # <<<<<<<<<<<<<< @@ -54938,7 +55386,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_193getPVNameFromHandle(PyObject *__pyx __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getPVNameFromHandle (wrapper)", 0); assert(__pyx_arg_h); { - __pyx_v_h = __Pyx_PyInt_As_int(__pyx_arg_h); if (unlikely((__pyx_v_h == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1693, __pyx_L3_error) + __pyx_v_h = __Pyx_PyInt_As_int(__pyx_arg_h); if (unlikely((__pyx_v_h == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1692, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -54959,7 +55407,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_192getPVNameFromHandle(struct __pyx_ob PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("getPVNameFromHandle", 0); - /* "PyCafe.pyx":1694 + /* "PyCafe.pyx":1693 * * def getPVNameFromHandle(self, int h): * return self._c_cafe.getPVFromHandle(h) # <<<<<<<<<<<<<< @@ -54967,13 +55415,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_192getPVNameFromHandle(struct __pyx_ob * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_h)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1694, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_h)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1693, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1693 + /* "PyCafe.pyx":1692 * ############################################################################ * * def getPVNameFromHandle(self, int h): # <<<<<<<<<<<<<< @@ -54994,7 +55442,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_192getPVNameFromHandle(struct __pyx_ob return __pyx_r; } -/* "PyCafe.pyx":1698 +/* "PyCafe.pyx":1697 * * ############################################################################ * def getHandleFromPVName(self, str name): # <<<<<<<<<<<<<< @@ -55008,7 +55456,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_195getHandleFromPVName(PyObject *__pyx PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getHandleFromPVName (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(3, 1698, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(3, 1697, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_194getHandleFromPVName(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), ((PyObject*)__pyx_v_name)); /* function exit code */ @@ -55027,7 +55475,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_194getHandleFromPVName(struct __pyx_ob PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getHandleFromPVName", 0); - /* "PyCafe.pyx":1702 + /* "PyCafe.pyx":1701 * # py_string = (name).encode('UTF-8') * # return self._c_cafe.getHandleFromPV(py_string) * return self._c_cafe.getHandleFromPV(name) # <<<<<<<<<<<<<< @@ -55035,14 +55483,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_194getHandleFromPVName(struct __pyx_ob * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_AsString(__pyx_v_name); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(3, 1702, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_c_cafe->getHandleFromPV(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1702, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_AsString(__pyx_v_name); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(3, 1701, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_c_cafe->getHandleFromPV(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1701, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1698 + /* "PyCafe.pyx":1697 * * ############################################################################ * def getHandleFromPVName(self, str name): # <<<<<<<<<<<<<< @@ -55063,7 +55511,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_194getHandleFromPVName(struct __pyx_ob return __pyx_r; } -/* "PyCafe.pyx":1707 +/* "PyCafe.pyx":1706 * ############################################################################ * * def getPVFromHandle(self, int h): # <<<<<<<<<<<<<< @@ -55079,7 +55527,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_197getPVFromHandle(PyObject *__pyx_v_s __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getPVFromHandle (wrapper)", 0); assert(__pyx_arg_h); { - __pyx_v_h = __Pyx_PyInt_As_int(__pyx_arg_h); if (unlikely((__pyx_v_h == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1707, __pyx_L3_error) + __pyx_v_h = __Pyx_PyInt_As_int(__pyx_arg_h); if (unlikely((__pyx_v_h == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1706, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -55100,7 +55548,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_196getPVFromHandle(struct __pyx_obj_6P PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("getPVFromHandle", 0); - /* "PyCafe.pyx":1708 + /* "PyCafe.pyx":1707 * * def getPVFromHandle(self, int h): * return self._c_cafe.getPVFromHandle(h) # <<<<<<<<<<<<<< @@ -55108,13 +55556,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_196getPVFromHandle(struct __pyx_obj_6P * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_h)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1708, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_h)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1707, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1707 + /* "PyCafe.pyx":1706 * ############################################################################ * * def getPVFromHandle(self, int h): # <<<<<<<<<<<<<< @@ -55135,7 +55583,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_196getPVFromHandle(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":1712 +/* "PyCafe.pyx":1711 * * ############################################################################ * def getHandleFromPV(self, str name): # <<<<<<<<<<<<<< @@ -55149,7 +55597,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_199getHandleFromPV(PyObject *__pyx_v_s PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getHandleFromPV (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(3, 1712, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(3, 1711, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_198getHandleFromPV(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), ((PyObject*)__pyx_v_name)); /* function exit code */ @@ -55168,7 +55616,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_198getHandleFromPV(struct __pyx_obj_6P PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getHandleFromPV", 0); - /* "PyCafe.pyx":1716 + /* "PyCafe.pyx":1715 * # py_string = (name).encode('UTF-8') * # return self._c_cafe.getHandleFromPV(py_string) * return self._c_cafe.getHandleFromPV(name) # <<<<<<<<<<<<<< @@ -55176,14 +55624,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_198getHandleFromPV(struct __pyx_obj_6P * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_AsString(__pyx_v_name); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(3, 1716, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_c_cafe->getHandleFromPV(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1716, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_AsString(__pyx_v_name); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(3, 1715, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_c_cafe->getHandleFromPV(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1712 + /* "PyCafe.pyx":1711 * * ############################################################################ * def getHandleFromPV(self, str name): # <<<<<<<<<<<<<< @@ -55204,7 +55652,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_198getHandleFromPV(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":1719 +/* "PyCafe.pyx":1718 * ############################################################################ * * def getChannelDataStore(self, handlePV): # <<<<<<<<<<<<<< @@ -55247,7 +55695,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob PyObject *__pyx_t_10 = NULL; __Pyx_RefNannySetupContext("getChannelDataStore", 0); - /* "PyCafe.pyx":1720 + /* "PyCafe.pyx":1719 * * def getChannelDataStore(self, handlePV): * cdef str _METHOD = "getChannelDataStore" # <<<<<<<<<<<<<< @@ -55257,7 +55705,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob __Pyx_INCREF(__pyx_n_u_getChannelDataStore); __pyx_v__METHOD = __pyx_n_u_getChannelDataStore; - /* "PyCafe.pyx":1721 + /* "PyCafe.pyx":1720 * def getChannelDataStore(self, handlePV): * cdef str _METHOD = "getChannelDataStore" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -55266,7 +55714,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob */ __pyx_v_handle = 0; - /* "PyCafe.pyx":1722 + /* "PyCafe.pyx":1721 * cdef str _METHOD = "getChannelDataStore" * cdef unsigned int handle = 0 * cdef str pv = "" # <<<<<<<<<<<<<< @@ -55276,7 +55724,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob __Pyx_INCREF(__pyx_kp_u__3); __pyx_v_pv = __pyx_kp_u__3; - /* "PyCafe.pyx":1723 + /* "PyCafe.pyx":1722 * cdef unsigned int handle = 0 * cdef str pv = "" * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -55297,29 +55745,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1724 + /* "PyCafe.pyx":1723 * cdef str pv = "" * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * pv = self._c_cafe.getPVFromHandle(handle) * elif isinstance(handlePV, (str)): */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1724, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1723, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1725 + /* "PyCafe.pyx":1724 * if isinstance(handlePV, (int, long)): * handle = handlePV * pv = self._c_cafe.getPVFromHandle(handle) # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV, force=True) */ - __pyx_t_5 = __Pyx_PyUnicode_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1725, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyUnicode_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1724, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_pv, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":1723 + /* "PyCafe.pyx":1722 * cdef unsigned int handle = 0 * cdef str pv = "" * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -55329,7 +55777,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob goto __pyx_L3; } - /* "PyCafe.pyx":1726 + /* "PyCafe.pyx":1725 * handle = handlePV * pv = self._c_cafe.getPVFromHandle(handle) * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -55340,36 +55788,36 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1727 + /* "PyCafe.pyx":1726 * pv = self._c_cafe.getPVFromHandle(handle) * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV, force=True) # <<<<<<<<<<<<<< * pv = handlePV * else: */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1727, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1726, __pyx_L1_error) __pyx_t_6.__pyx_n = 1; __pyx_t_6.force = 1; - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, &__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1727, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, &__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1726, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1727, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1726, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":1728 + /* "PyCafe.pyx":1727 * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV, force=True) * pv = handlePV # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1728, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 1727, __pyx_L1_error) __pyx_t_5 = __pyx_v_handlePV; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_pv, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":1726 + /* "PyCafe.pyx":1725 * handle = handlePV * pv = self._c_cafe.getPVFromHandle(handle) * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -55379,7 +55827,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob goto __pyx_L3; } - /* "PyCafe.pyx":1730 + /* "PyCafe.pyx":1729 * pv = handlePV * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< @@ -55387,10 +55835,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob * "First input argument should be of type if handle, \ */ /*else*/ { - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1730, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "PyCafe.pyx":1731 + /* "PyCafe.pyx":1730 * else: * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -55412,7 +55860,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_2}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1730, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1729, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -55420,13 +55868,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_2}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1730, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1729, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1730, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -55440,29 +55888,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_2); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_2); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_kp_u_First_input_argument_should_be_o_2); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1730, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":1730 + /* "PyCafe.pyx":1729 * pv = handlePV * else: * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument should be of type if handle, \ */ - __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1730, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(3, 1730, __pyx_L1_error) + __PYX_ERR(3, 1729, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":1735 + /* "PyCafe.pyx":1734 * else if PV")) * * if handle == 0: # <<<<<<<<<<<<<< @@ -55472,7 +55920,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1736 + /* "PyCafe.pyx":1735 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -55482,7 +55930,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1737 + /* "PyCafe.pyx":1736 * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) # <<<<<<<<<<<<<< @@ -55491,7 +55939,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob */ __pyx_v_self->_c_cafe->printStatusMessage(ECAFE_INVALID_HANDLE); - /* "PyCafe.pyx":1736 + /* "PyCafe.pyx":1735 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -55500,20 +55948,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob */ } - /* "PyCafe.pyx":1738 + /* "PyCafe.pyx":1737 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def getChannelDataStore") * */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1738, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(3, 1738, __pyx_L1_error) + __PYX_ERR(3, 1737, __pyx_L1_error) - /* "PyCafe.pyx":1735 + /* "PyCafe.pyx":1734 * else if PV")) * * if handle == 0: # <<<<<<<<<<<<<< @@ -55522,7 +55970,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob */ } - /* "PyCafe.pyx":1742 + /* "PyCafe.pyx":1741 * * cdef ChannelDataStore cds * cdef int status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -55531,14 +55979,44 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":1754 + /* "PyCafe.pyx":1753 * #status=self._c_cafe.getCtrlCache(handle, pvc) * * pvds = self.getPVCache(handle) # <<<<<<<<<<<<<< * pvcs = self.getCtrlCache(handle) * infos = self.getChannelInfo(handle) */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1754, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1753, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1753, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_8, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_10); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1753, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_pvds = __pyx_t_7; + __pyx_t_7 = 0; + + /* "PyCafe.pyx":1754 + * + * pvds = self.getPVCache(handle) + * pvcs = self.getCtrlCache(handle) # <<<<<<<<<<<<<< + * infos = self.getChannelInfo(handle) + * + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCtrlCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); @@ -55558,17 +56036,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_pvds = __pyx_t_7; + __pyx_v_pvcs = __pyx_t_7; __pyx_t_7 = 0; /* "PyCafe.pyx":1755 - * * pvds = self.getPVCache(handle) - * pvcs = self.getCtrlCache(handle) # <<<<<<<<<<<<<< - * infos = self.getChannelInfo(handle) + * pvcs = self.getCtrlCache(handle) + * infos = self.getChannelInfo(handle) # <<<<<<<<<<<<<< * + * ''' */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCtrlCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1755, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getChannelInfo); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); @@ -55588,40 +56066,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_pvcs = __pyx_t_7; - __pyx_t_7 = 0; - - /* "PyCafe.pyx":1756 - * pvds = self.getPVCache(handle) - * pvcs = self.getCtrlCache(handle) - * infos = self.getChannelInfo(handle) # <<<<<<<<<<<<<< - * - * ''' - */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getChannelInfo); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1756, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1756, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_8, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_10); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1756, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_infos = __pyx_t_7; __pyx_t_7 = 0; - /* "PyCafe.pyx":1784 + /* "PyCafe.pyx":1783 * * # return cds.description, channelRegaliaToStruct(cds.info), PVDataHolderToStruct(cds.pvd), PVCtrlHolderToStruct(cds.pvc) * return infos, pvds, pvcs # <<<<<<<<<<<<<< @@ -55629,7 +56077,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1784, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 1783, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_infos); __Pyx_GIVEREF(__pyx_v_infos); @@ -55644,7 +56092,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob __pyx_t_7 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1719 + /* "PyCafe.pyx":1718 * ############################################################################ * * def getChannelDataStore(self, handlePV): # <<<<<<<<<<<<<< @@ -55673,7 +56121,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_200getChannelDataStore(struct __pyx_ob return __pyx_r; } -/* "PyCafe.pyx":1788 +/* "PyCafe.pyx":1787 * ############################################################################ * @verify_handlepv * def getChannelInfo(self, handlePV): # <<<<<<<<<<<<<< @@ -55707,7 +56155,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_202getChannelInfo(struct __pyx_obj_6Py struct __pyx_opt_args_6PyCafe_6CyCafe_prepareCafeException __pyx_t_5; __Pyx_RefNannySetupContext("getChannelInfo", 0); - /* "PyCafe.pyx":1789 + /* "PyCafe.pyx":1788 * @verify_handlepv * def getChannelInfo(self, handlePV): * cdef str _METHOD = "getChannelInfo(handlePV)" # <<<<<<<<<<<<<< @@ -55717,17 +56165,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_202getChannelInfo(struct __pyx_obj_6Py __Pyx_INCREF(__pyx_kp_u_getChannelInfo_handlePV); __pyx_v__METHOD = __pyx_kp_u_getChannelInfo_handlePV; - /* "PyCafe.pyx":1791 + /* "PyCafe.pyx":1790 * cdef str _METHOD = "getChannelInfo(handlePV)" * * status = self._c_cafe.getChannelInfo(handlePV, self.channelInfo) # <<<<<<<<<<<<<< * #print("ln", __FILE__, __LINE__,inspect.currentframe().f_lineno ) * if self._enable_exceptions and status != ICAFE_NORMAL: */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1791, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1790, __pyx_L1_error) __pyx_v_status = __pyx_v_self->_c_cafe->getChannelInfo(__pyx_t_1, __pyx_v_self->channelInfo); - /* "PyCafe.pyx":1793 + /* "PyCafe.pyx":1792 * status = self._c_cafe.getChannelInfo(handlePV, self.channelInfo) * #print("ln", __FILE__, __LINE__,inspect.currentframe().f_lineno ) * if self._enable_exceptions and status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -55745,16 +56193,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_202getChannelInfo(struct __pyx_obj_6Py __pyx_L4_bool_binop_done:; if (__pyx_t_2) { - /* "PyCafe.pyx":1795 + /* "PyCafe.pyx":1794 * if self._enable_exceptions and status != ICAFE_NORMAL: * PyCafeException = self.prepareCafeException( * status, _METHOD, handle=handlePV) # <<<<<<<<<<<<<< * raise PyCafeException * # cdef channelInfo ci=channelRegaliaToStruct(cr) */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1795, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1794, __pyx_L1_error) - /* "PyCafe.pyx":1794 + /* "PyCafe.pyx":1793 * #print("ln", __FILE__, __LINE__,inspect.currentframe().f_lineno ) * if self._enable_exceptions and status != ICAFE_NORMAL: * PyCafeException = self.prepareCafeException( # <<<<<<<<<<<<<< @@ -55763,12 +56211,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_202getChannelInfo(struct __pyx_obj_6Py */ __pyx_t_5.__pyx_n = 1; __pyx_t_5.handle = __pyx_t_1; - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->prepareCafeException(__pyx_v_self, __pyx_v_status, __pyx_v__METHOD, &__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1794, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->prepareCafeException(__pyx_v_self, __pyx_v_status, __pyx_v__METHOD, &__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_PyCafeException = __pyx_t_4; __pyx_t_4 = 0; - /* "PyCafe.pyx":1796 + /* "PyCafe.pyx":1795 * PyCafeException = self.prepareCafeException( * status, _METHOD, handle=handlePV) * raise PyCafeException # <<<<<<<<<<<<<< @@ -55776,9 +56224,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_202getChannelInfo(struct __pyx_obj_6Py * # ci.channelID=self._c_cafe.getChannelIDAsString(cr.getChannelID()) */ __Pyx_Raise(__pyx_v_PyCafeException, 0, 0, 0); - __PYX_ERR(3, 1796, __pyx_L1_error) + __PYX_ERR(3, 1795, __pyx_L1_error) - /* "PyCafe.pyx":1793 + /* "PyCafe.pyx":1792 * status = self._c_cafe.getChannelInfo(handlePV, self.channelInfo) * #print("ln", __FILE__, __LINE__,inspect.currentframe().f_lineno ) * if self._enable_exceptions and status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -55787,7 +56235,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_202getChannelInfo(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":1801 + /* "PyCafe.pyx":1800 * # do hex(cr.getChannelID()) to get channelId in hex form * * return channelRegaliaToStruct(self.channelInfo) # <<<<<<<<<<<<<< @@ -55795,13 +56243,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_202getChannelInfo(struct __pyx_obj_6Py * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = ((PyObject *)__pyx_f_6PyCafe_channelRegaliaToStruct(__pyx_v_self->channelInfo)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1801, __pyx_L1_error) + __pyx_t_4 = ((PyObject *)__pyx_f_6PyCafe_channelRegaliaToStruct(__pyx_v_self->channelInfo)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1788 + /* "PyCafe.pyx":1787 * ############################################################################ * @verify_handlepv * def getChannelInfo(self, handlePV): # <<<<<<<<<<<<<< @@ -55824,7 +56272,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_202getChannelInfo(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":1805 +/* "PyCafe.pyx":1804 * * * def getChannelList(self, list listStrings): # <<<<<<<<<<<<<< @@ -55838,7 +56286,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_205getChannelList(PyObject *__pyx_v_se PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getChannelList (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_listStrings), (&PyList_Type), 1, "listStrings", 1))) __PYX_ERR(3, 1805, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_listStrings), (&PyList_Type), 1, "listStrings", 1))) __PYX_ERR(3, 1804, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_204getChannelList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), ((PyObject*)__pyx_v_listStrings)); /* function exit code */ @@ -55857,7 +56305,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_204getChannelList(struct __pyx_obj_6Py PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getChannelList", 0); - /* "PyCafe.pyx":1806 + /* "PyCafe.pyx":1805 * * def getChannelList(self, list listStrings): * return self._c_cafe.getFromGlobalChannelList(listStrings) # <<<<<<<<<<<<<< @@ -55865,14 +56313,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_204getChannelList(struct __pyx_obj_6Py * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_v_listStrings); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1806, __pyx_L1_error) - __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_self->_c_cafe->getFromGlobalChannelList(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1806, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_v_listStrings); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1805, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_self->_c_cafe->getFromGlobalChannelList(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1805, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1805 + /* "PyCafe.pyx":1804 * * * def getChannelList(self, list listStrings): # <<<<<<<<<<<<<< @@ -55893,7 +56341,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_204getChannelList(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":1812 +/* "PyCafe.pyx":1811 * ################################################################################## * @verify_handlepv * def getWFAsString(self, handlePV, cache: bool = False): # <<<<<<<<<<<<<< @@ -55937,7 +56385,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_207getWFAsString(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getWFAsString") < 0)) __PYX_ERR(3, 1812, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getWFAsString") < 0)) __PYX_ERR(3, 1811, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -55953,7 +56401,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_207getWFAsString(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getWFAsString", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1812, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getWFAsString", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1811, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getWFAsString", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -55983,7 +56431,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getWFAsString", 0); - /* "PyCafe.pyx":1813 + /* "PyCafe.pyx":1812 * @verify_handlepv * def getWFAsString(self, handlePV, cache: bool = False): * cdef str _METHOD = "getWFAsString" # <<<<<<<<<<<<<< @@ -55993,27 +56441,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_getWFAsString); __pyx_v__METHOD = __pyx_n_u_getWFAsString; - /* "PyCafe.pyx":1817 + /* "PyCafe.pyx":1816 * * cdef bytes bWF * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * if cache: * status = self._c_cafe.getWFAsStringCache(handle, strWF) */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1817, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1816, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":1818 + /* "PyCafe.pyx":1817 * cdef bytes bWF * cdef unsigned int handle = handlePV * if cache: # <<<<<<<<<<<<<< * status = self._c_cafe.getWFAsStringCache(handle, strWF) * else: */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_cache); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 1818, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_cache); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 1817, __pyx_L1_error) if (__pyx_t_2) { - /* "PyCafe.pyx":1819 + /* "PyCafe.pyx":1818 * cdef unsigned int handle = handlePV * if cache: * status = self._c_cafe.getWFAsStringCache(handle, strWF) # <<<<<<<<<<<<<< @@ -56022,7 +56470,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC */ __pyx_v_status = __pyx_v_self->_c_cafe->getWFAsStringCache(__pyx_v_handle, __pyx_v_strWF); - /* "PyCafe.pyx":1818 + /* "PyCafe.pyx":1817 * cdef bytes bWF * cdef unsigned int handle = handlePV * if cache: # <<<<<<<<<<<<<< @@ -56032,7 +56480,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":1821 + /* "PyCafe.pyx":1820 * status = self._c_cafe.getWFAsStringCache(handle, strWF) * else: * with nogil: # <<<<<<<<<<<<<< @@ -56048,7 +56496,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":1822 + /* "PyCafe.pyx":1821 * else: * with nogil: * status = self._c_cafe.getWFAsString(handle, strWF) # <<<<<<<<<<<<<< @@ -56058,7 +56506,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC __pyx_v_status = __pyx_v_self->_c_cafe->getWFAsString(__pyx_v_handle, __pyx_v_strWF); } - /* "PyCafe.pyx":1821 + /* "PyCafe.pyx":1820 * status = self._c_cafe.getWFAsStringCache(handle, strWF) * else: * with nogil: # <<<<<<<<<<<<<< @@ -56079,7 +56527,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC } __pyx_L3:; - /* "PyCafe.pyx":1838 + /* "PyCafe.pyx":1837 * ##FOR TESTINg raise PyCafeException * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -56089,7 +56537,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1840 + /* "PyCafe.pyx":1839 * if status != ICAFE_NORMAL: * * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -56099,7 +56547,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1841 + /* "PyCafe.pyx":1840 * * if self._enable_exceptions: * PyCafeException = self.prepareCafeException( # <<<<<<<<<<<<<< @@ -56108,12 +56556,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC */ __pyx_t_4.__pyx_n = 1; __pyx_t_4.handle = __pyx_v_handle; - __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->prepareCafeException(__pyx_v_self, __pyx_v_status, __pyx_v__METHOD, &__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1841, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->prepareCafeException(__pyx_v_self, __pyx_v_status, __pyx_v__METHOD, &__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1840, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_PyCafeException = __pyx_t_3; __pyx_t_3 = 0; - /* "PyCafe.pyx":1843 + /* "PyCafe.pyx":1842 * PyCafeException = self.prepareCafeException( * status, _METHOD, handle=handle) * raise PyCafeException # <<<<<<<<<<<<<< @@ -56121,9 +56569,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC * elif PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: */ __Pyx_Raise(__pyx_v_PyCafeException, 0, 0, 0); - __PYX_ERR(3, 1843, __pyx_L1_error) + __PYX_ERR(3, 1842, __pyx_L1_error) - /* "PyCafe.pyx":1840 + /* "PyCafe.pyx":1839 * if status != ICAFE_NORMAL: * * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -56133,7 +56581,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC goto __pyx_L8; } - /* "PyCafe.pyx":1845 + /* "PyCafe.pyx":1844 * raise PyCafeException * * elif PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -56143,7 +56591,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1846 + /* "PyCafe.pyx":1845 * * elif PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -56152,7 +56600,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":1845 + /* "PyCafe.pyx":1844 * raise PyCafeException * * elif PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -56162,7 +56610,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC } __pyx_L8:; - /* "PyCafe.pyx":1838 + /* "PyCafe.pyx":1837 * ##FOR TESTINg raise PyCafeException * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -56171,14 +56619,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":1849 + /* "PyCafe.pyx":1848 * * * bWF = strWF # <<<<<<<<<<<<<< * a = (bWF).decode('latin-1') * return a */ - __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_strWF); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1849, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_strWF); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __pyx_t_3; __Pyx_INCREF(__pyx_t_5); @@ -56186,7 +56634,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC __pyx_v_bWF = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":1850 + /* "PyCafe.pyx":1849 * * bWF = strWF * a = (bWF).decode('latin-1') # <<<<<<<<<<<<<< @@ -56195,14 +56643,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bWF == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 1850, __pyx_L1_error) + __PYX_ERR(3, 1849, __pyx_L1_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bWF, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1850, __pyx_L1_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bWF, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_a = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":1851 + /* "PyCafe.pyx":1850 * bWF = strWF * a = (bWF).decode('latin-1') * return a # <<<<<<<<<<<<<< @@ -56214,7 +56662,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC __pyx_r = __pyx_v_a; goto __pyx_L0; - /* "PyCafe.pyx":1812 + /* "PyCafe.pyx":1811 * ################################################################################## * @verify_handlepv * def getWFAsString(self, handlePV, cache: bool = False): # <<<<<<<<<<<<<< @@ -56240,7 +56688,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_206getWFAsString(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":1866 +/* "PyCafe.pyx":1865 * ############################################################################ * * def getWFAsStringCache(self, handlePV): # <<<<<<<<<<<<<< @@ -56270,7 +56718,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_208getWFAsStringCache(struct __pyx_obj PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getWFAsStringCache", 0); - /* "PyCafe.pyx":1867 + /* "PyCafe.pyx":1866 * * def getWFAsStringCache(self, handlePV): * return self.getWFAsString(handlePV, cache=True) # <<<<<<<<<<<<<< @@ -56278,17 +56726,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_208getWFAsStringCache(struct __pyx_obj * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getWFAsString); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1867, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getWFAsString); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1867, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1867, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cache, Py_True) < 0) __PYX_ERR(3, 1867, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1867, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cache, Py_True) < 0) __PYX_ERR(3, 1866, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -56297,7 +56745,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_208getWFAsStringCache(struct __pyx_obj __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1866 + /* "PyCafe.pyx":1865 * ############################################################################ * * def getWFAsStringCache(self, handlePV): # <<<<<<<<<<<<<< @@ -56321,7 +56769,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_208getWFAsStringCache(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":1873 +/* "PyCafe.pyx":1872 * ############################################################################ * @verify_handlepv * def isEnum(self, handlePV): # <<<<<<<<<<<<<< @@ -56349,7 +56797,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_210isEnum(struct __pyx_obj_6PyCafe_CyC PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("isEnum", 0); - /* "PyCafe.pyx":1874 + /* "PyCafe.pyx":1873 * @verify_handlepv * def isEnum(self, handlePV): * return self._c_cafe.isEnum(handlePV) # <<<<<<<<<<<<<< @@ -56357,14 +56805,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_210isEnum(struct __pyx_obj_6PyCafe_CyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1874, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->isEnum(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1874, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1873, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->isEnum(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1873 + /* "PyCafe.pyx":1872 * ############################################################################ * @verify_handlepv * def isEnum(self, handlePV): # <<<<<<<<<<<<<< @@ -56385,7 +56833,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_210isEnum(struct __pyx_obj_6PyCafe_CyC return __pyx_r; } -/* "PyCafe.pyx":1879 +/* "PyCafe.pyx":1878 * ############################################################################ * @verify_handlepv * def getEnumStrings(self, handlePV): # <<<<<<<<<<<<<< @@ -56413,7 +56861,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_212getEnumStrings(struct __pyx_obj_6Py PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getEnumStrings", 0); - /* "PyCafe.pyx":1880 + /* "PyCafe.pyx":1879 * @verify_handlepv * def getEnumStrings(self, handlePV): * return self.hh.getEnumStrings(handlePV) # <<<<<<<<<<<<<< @@ -56421,14 +56869,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_212getEnumStrings(struct __pyx_obj_6Py * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1880, __pyx_L1_error) - __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_self->hh.getEnumStrings(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1880, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1879, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_self->hh.getEnumStrings(__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1879, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1879 + /* "PyCafe.pyx":1878 * ############################################################################ * @verify_handlepv * def getEnumStrings(self, handlePV): # <<<<<<<<<<<<<< @@ -56449,7 +56897,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_212getEnumStrings(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":1884 +/* "PyCafe.pyx":1883 * ############################################################################ * @verify_handlepv * def getEnumFromString(self, handlePV, str enumString): # <<<<<<<<<<<<<< @@ -56488,11 +56936,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_215getEnumFromString(PyObject *__pyx_v case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_enumString)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("getEnumFromString", 1, 2, 2, 1); __PYX_ERR(3, 1884, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getEnumFromString", 1, 2, 2, 1); __PYX_ERR(3, 1883, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getEnumFromString") < 0)) __PYX_ERR(3, 1884, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getEnumFromString") < 0)) __PYX_ERR(3, 1883, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -56505,13 +56953,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_215getEnumFromString(PyObject *__pyx_v } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getEnumFromString", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1884, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getEnumFromString", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1883, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getEnumFromString", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_enumString), (&PyUnicode_Type), 1, "enumString", 1))) __PYX_ERR(3, 1884, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_enumString), (&PyUnicode_Type), 1, "enumString", 1))) __PYX_ERR(3, 1883, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_enumString); /* function exit code */ @@ -56538,7 +56986,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(struct __pyx_obj_ PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("getEnumFromString", 0); - /* "PyCafe.pyx":1885 + /* "PyCafe.pyx":1884 * @verify_handlepv * def getEnumFromString(self, handlePV, str enumString): * cdef str _METHOD = "getEnumFromString" # <<<<<<<<<<<<<< @@ -56548,18 +56996,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(struct __pyx_obj_ __Pyx_INCREF(__pyx_n_u_getEnumFromString); __pyx_v__METHOD = __pyx_n_u_getEnumFromString; - /* "PyCafe.pyx":1887 + /* "PyCafe.pyx":1886 * cdef str _METHOD = "getEnumFromString" * cdef short enumValue * enumValue = self.hh.getEnumFromString(handlePV, enumString) # <<<<<<<<<<<<<< * if enumValue == INVALID_ENUM_RETURN_VALUE: * raise ValueError( */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1887, __pyx_L1_error) - __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_v_enumString); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1887, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1886, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_string_from_py_std__in_string(__pyx_v_enumString); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1886, __pyx_L1_error) __pyx_v_enumValue = __pyx_v_self->hh.getEnumFromString(__pyx_t_1, ((std::string)__pyx_t_2)); - /* "PyCafe.pyx":1888 + /* "PyCafe.pyx":1887 * cdef short enumValue * enumValue = self.hh.getEnumFromString(handlePV, enumString) * if enumValue == INVALID_ENUM_RETURN_VALUE: # <<<<<<<<<<<<<< @@ -56569,17 +57017,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(struct __pyx_obj_ __pyx_t_3 = ((__pyx_v_enumValue == INVALID_ENUM_RETURN_VALUE) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":1890 + /* "PyCafe.pyx":1889 * if enumValue == INVALID_ENUM_RETURN_VALUE: * raise ValueError( * "{0} {1} \n{2} {3} {4} \n{5}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "ENUM string value:", enumString, "not recognized! ", */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_0_1_2_3_4_5, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1890, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_0_1_2_3_4_5, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - /* "PyCafe.pyx":1892 + /* "PyCafe.pyx":1891 * "{0} {1} \n{2} {3} {4} \n{5}".format( * self._exception_text, _METHOD, * "ENUM string value:", enumString, "not recognized! ", # <<<<<<<<<<<<<< @@ -56601,7 +57049,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(struct __pyx_obj_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[7] = {__pyx_t_6, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_ENUM_string_value, __pyx_v_enumString, __pyx_kp_u_not_recognized, __pyx_kp_u_Execute_getEnumStrings_handlePV}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1890, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1889, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_4); } else @@ -56609,13 +57057,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(struct __pyx_obj_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[7] = {__pyx_t_6, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_ENUM_string_value, __pyx_v_enumString, __pyx_kp_u_not_recognized, __pyx_kp_u_Execute_getEnumStrings_handlePV}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1890, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1889, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { - __pyx_t_8 = PyTuple_New(6+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1890, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(6+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; @@ -56638,27 +57086,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(struct __pyx_obj_ __Pyx_INCREF(__pyx_kp_u_Execute_getEnumStrings_handlePV); __Pyx_GIVEREF(__pyx_kp_u_Execute_getEnumStrings_handlePV); PyTuple_SET_ITEM(__pyx_t_8, 5+__pyx_t_7, __pyx_kp_u_Execute_getEnumStrings_handlePV); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1890, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":1889 + /* "PyCafe.pyx":1888 * enumValue = self.hh.getEnumFromString(handlePV, enumString) * if enumValue == INVALID_ENUM_RETURN_VALUE: * raise ValueError( # <<<<<<<<<<<<<< * "{0} {1} \n{2} {3} {4} \n{5}".format( * self._exception_text, _METHOD, */ - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1889, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 1889, __pyx_L1_error) + __PYX_ERR(3, 1888, __pyx_L1_error) - /* "PyCafe.pyx":1888 + /* "PyCafe.pyx":1887 * cdef short enumValue * enumValue = self.hh.getEnumFromString(handlePV, enumString) * if enumValue == INVALID_ENUM_RETURN_VALUE: # <<<<<<<<<<<<<< @@ -56667,7 +57115,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(struct __pyx_obj_ */ } - /* "PyCafe.pyx":1894 + /* "PyCafe.pyx":1893 * "ENUM string value:", enumString, "not recognized! ", * "Execute getEnumStrings(handlePV) to view enumerated values")) * return enumValue # <<<<<<<<<<<<<< @@ -56675,13 +57123,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(struct __pyx_obj_ * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_short(__pyx_v_enumValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1894, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_short(__pyx_v_enumValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1884 + /* "PyCafe.pyx":1883 * ############################################################################ * @verify_handlepv * def getEnumFromString(self, handlePV, str enumString): # <<<<<<<<<<<<<< @@ -56706,7 +57154,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_214getEnumFromString(struct __pyx_obj_ return __pyx_r; } -/* "PyCafe.pyx":1898 +/* "PyCafe.pyx":1897 * ############################################################################ * @verify_handlepv * def getStringFromEnum(self, handlePV, unsigned short enumValue = 0): # <<<<<<<<<<<<<< @@ -56749,7 +57197,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_217getStringFromEnum(PyObject *__pyx_v } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getStringFromEnum") < 0)) __PYX_ERR(3, 1898, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getStringFromEnum") < 0)) __PYX_ERR(3, 1897, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -56762,14 +57210,14 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_217getStringFromEnum(PyObject *__pyx_v } __pyx_v_handlePV = values[0]; if (values[1]) { - __pyx_v_enumValue = __Pyx_PyInt_As_unsigned_short(values[1]); if (unlikely((__pyx_v_enumValue == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 1898, __pyx_L3_error) + __pyx_v_enumValue = __Pyx_PyInt_As_unsigned_short(values[1]); if (unlikely((__pyx_v_enumValue == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 1897, __pyx_L3_error) } else { __pyx_v_enumValue = ((unsigned short)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getStringFromEnum", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1898, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getStringFromEnum", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1897, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getStringFromEnum", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -56797,7 +57245,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_216getStringFromEnum(struct __pyx_obj_ PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("getStringFromEnum", 0); - /* "PyCafe.pyx":1899 + /* "PyCafe.pyx":1898 * @verify_handlepv * def getStringFromEnum(self, handlePV, unsigned short enumValue = 0): * cdef str _METHOD = "getStringFromEnum" # <<<<<<<<<<<<<< @@ -56807,17 +57255,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_216getStringFromEnum(struct __pyx_obj_ __Pyx_INCREF(__pyx_n_u_getStringFromEnum); __pyx_v__METHOD = __pyx_n_u_getStringFromEnum; - /* "PyCafe.pyx":1900 + /* "PyCafe.pyx":1899 * def getStringFromEnum(self, handlePV, unsigned short enumValue = 0): * cdef str _METHOD = "getStringFromEnum" * cdef string enumString = self.hh.getStringFromEnum(handlePV, enumValue) # <<<<<<<<<<<<<< * if enumString == INVALID_ENUM_RETURN_STRING: * raise ValueError( */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1900, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1899, __pyx_L1_error) __pyx_v_enumString = __pyx_v_self->hh.getStringFromEnum(__pyx_t_1, __pyx_v_enumValue); - /* "PyCafe.pyx":1901 + /* "PyCafe.pyx":1900 * cdef str _METHOD = "getStringFromEnum" * cdef string enumString = self.hh.getStringFromEnum(handlePV, enumValue) * if enumString == INVALID_ENUM_RETURN_STRING: # <<<<<<<<<<<<<< @@ -56827,24 +57275,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_216getStringFromEnum(struct __pyx_obj_ __pyx_t_2 = ((__pyx_v_enumString == INVALID_ENUM_RETURN_STRING) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":1903 + /* "PyCafe.pyx":1902 * if enumString == INVALID_ENUM_RETURN_STRING: * raise ValueError( * "{} {} \n{} {} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "ENUM value:", enumValue, "is not a valid option. ", */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__44, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1903, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__44, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1902, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "PyCafe.pyx":1905 + /* "PyCafe.pyx":1904 * "{} {} \n{} {} {} \n{}".format( * self._exception_text, _METHOD, * "ENUM value:", enumValue, "is not a valid option. ", # <<<<<<<<<<<<<< * "Execute getEnumStrings(handlePV) to view enumerated values")) * return enumString */ - __pyx_t_5 = __Pyx_PyInt_From_unsigned_short(__pyx_v_enumValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1905, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_short(__pyx_v_enumValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1904, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; @@ -56861,7 +57309,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_216getStringFromEnum(struct __pyx_obj_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[7] = {__pyx_t_6, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_ENUM_value, __pyx_t_5, __pyx_kp_u_is_not_a_valid_option, __pyx_kp_u_Execute_getEnumStrings_handlePV}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1903, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1902, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -56870,14 +57318,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_216getStringFromEnum(struct __pyx_obj_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[7] = {__pyx_t_6, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_ENUM_value, __pyx_t_5, __pyx_kp_u_is_not_a_valid_option, __pyx_kp_u_Execute_getEnumStrings_handlePV}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1903, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1902, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { - __pyx_t_8 = PyTuple_New(6+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1903, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(6+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1902, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; @@ -56900,27 +57348,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_216getStringFromEnum(struct __pyx_obj_ __Pyx_GIVEREF(__pyx_kp_u_Execute_getEnumStrings_handlePV); PyTuple_SET_ITEM(__pyx_t_8, 5+__pyx_t_7, __pyx_kp_u_Execute_getEnumStrings_handlePV); __pyx_t_5 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1903, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1902, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":1902 + /* "PyCafe.pyx":1901 * cdef string enumString = self.hh.getStringFromEnum(handlePV, enumValue) * if enumString == INVALID_ENUM_RETURN_STRING: * raise ValueError( # <<<<<<<<<<<<<< * "{} {} \n{} {} {} \n{}".format( * self._exception_text, _METHOD, */ - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1902, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 1902, __pyx_L1_error) + __PYX_ERR(3, 1901, __pyx_L1_error) - /* "PyCafe.pyx":1901 + /* "PyCafe.pyx":1900 * cdef str _METHOD = "getStringFromEnum" * cdef string enumString = self.hh.getStringFromEnum(handlePV, enumValue) * if enumString == INVALID_ENUM_RETURN_STRING: # <<<<<<<<<<<<<< @@ -56929,7 +57377,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_216getStringFromEnum(struct __pyx_obj_ */ } - /* "PyCafe.pyx":1907 + /* "PyCafe.pyx":1906 * "ENUM value:", enumValue, "is not a valid option. ", * "Execute getEnumStrings(handlePV) to view enumerated values")) * return enumString # <<<<<<<<<<<<<< @@ -56937,13 +57385,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_216getStringFromEnum(struct __pyx_obj_ * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_enumString); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1907, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_enumString); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1906, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1898 + /* "PyCafe.pyx":1897 * ############################################################################ * @verify_handlepv * def getStringFromEnum(self, handlePV, unsigned short enumValue = 0): # <<<<<<<<<<<<<< @@ -56969,7 +57417,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_216getStringFromEnum(struct __pyx_obj_ return __pyx_r; } -/* "PyCafe.pyx":1921 +/* "PyCafe.pyx":1920 * ############################################################################ * @verify_handlepv * def setDbrBase(self, handlePV, DBR_TYPE dbrBase): # <<<<<<<<<<<<<< @@ -57008,11 +57456,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_219setDbrBase(PyObject *__pyx_v_self, case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dbrBase)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setDbrBase", 1, 2, 2, 1); __PYX_ERR(3, 1921, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setDbrBase", 1, 2, 2, 1); __PYX_ERR(3, 1920, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDbrBase") < 0)) __PYX_ERR(3, 1921, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDbrBase") < 0)) __PYX_ERR(3, 1920, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -57021,11 +57469,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_219setDbrBase(PyObject *__pyx_v_self, values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_handlePV = values[0]; - __pyx_v_dbrBase = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1921, __pyx_L3_error) + __pyx_v_dbrBase = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1920, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setDbrBase", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1921, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setDbrBase", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1920, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setDbrBase", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -57047,7 +57495,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_218setDbrBase(struct __pyx_obj_6PyCafe unsigned int __pyx_t_4; __Pyx_RefNannySetupContext("setDbrBase", 0); - /* "PyCafe.pyx":1924 + /* "PyCafe.pyx":1923 * * # Print Warning Message * if dbrBase > DBR_TIME: # <<<<<<<<<<<<<< @@ -57057,49 +57505,49 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_218setDbrBase(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_dbrBase > DBR_TIME) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1925 + /* "PyCafe.pyx":1924 * # Print Warning Message * if dbrBase > DBR_TIME: * print("WARNING: PyCafe def setDbrBase(handle/PV, DBR_TYPE)") # <<<<<<<<<<<<<< * print("Allowed DBR_TYPEs are:") * print("DBR_PLAIN (0), DBR_STS(1), DBR_TIME(2)") */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1925, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1926 + /* "PyCafe.pyx":1925 * if dbrBase > DBR_TIME: * print("WARNING: PyCafe def setDbrBase(handle/PV, DBR_TYPE)") * print("Allowed DBR_TYPEs are:") # <<<<<<<<<<<<<< * print("DBR_PLAIN (0), DBR_STS(1), DBR_TIME(2)") * print("The value entered was", dbrBase, "hence assuming DBR_TIME") */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1926, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1925, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1927 + /* "PyCafe.pyx":1926 * print("WARNING: PyCafe def setDbrBase(handle/PV, DBR_TYPE)") * print("Allowed DBR_TYPEs are:") * print("DBR_PLAIN (0), DBR_STS(1), DBR_TIME(2)") # <<<<<<<<<<<<<< * print("The value entered was", dbrBase, "hence assuming DBR_TIME") * dbrBase = DBR_TIME */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1927, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1926, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1928 + /* "PyCafe.pyx":1927 * print("Allowed DBR_TYPEs are:") * print("DBR_PLAIN (0), DBR_STS(1), DBR_TIME(2)") * print("The value entered was", dbrBase, "hence assuming DBR_TIME") # <<<<<<<<<<<<<< * dbrBase = DBR_TIME * */ - __pyx_t_2 = __Pyx_PyInt_From_DBR_TYPE(__pyx_v_dbrBase); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1928, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_DBR_TYPE(__pyx_v_dbrBase); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1927, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1928, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1927, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_kp_u_The_value_entered_was); __Pyx_GIVEREF(__pyx_kp_u_The_value_entered_was); @@ -57110,12 +57558,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_218setDbrBase(struct __pyx_obj_6PyCafe __Pyx_GIVEREF(__pyx_kp_u_hence_assuming_DBR_TIME); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_hence_assuming_DBR_TIME); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1928, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1927, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1929 + /* "PyCafe.pyx":1928 * print("DBR_PLAIN (0), DBR_STS(1), DBR_TIME(2)") * print("The value entered was", dbrBase, "hence assuming DBR_TIME") * dbrBase = DBR_TIME # <<<<<<<<<<<<<< @@ -57124,7 +57572,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_218setDbrBase(struct __pyx_obj_6PyCafe */ __pyx_v_dbrBase = DBR_TIME; - /* "PyCafe.pyx":1924 + /* "PyCafe.pyx":1923 * * # Print Warning Message * if dbrBase > DBR_TIME: # <<<<<<<<<<<<<< @@ -57133,7 +57581,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_218setDbrBase(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":1931 + /* "PyCafe.pyx":1930 * dbrBase = DBR_TIME * * return self.hh.setCafeDbrType(handlePV, dbrBase) # <<<<<<<<<<<<<< @@ -57141,14 +57589,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_218setDbrBase(struct __pyx_obj_6PyCafe * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1931, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.setCafeDbrType(__pyx_t_4, __pyx_v_dbrBase)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1931, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1930, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.setCafeDbrType(__pyx_t_4, __pyx_v_dbrBase)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1921 + /* "PyCafe.pyx":1920 * ############################################################################ * @verify_handlepv * def setDbrBase(self, handlePV, DBR_TYPE dbrBase): # <<<<<<<<<<<<<< @@ -57170,7 +57618,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_218setDbrBase(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":1936 +/* "PyCafe.pyx":1935 * ############################################################################ * @verify_handlepv * def getDbrBase(self, handlePV): # <<<<<<<<<<<<<< @@ -57200,7 +57648,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_220getDbrBase(struct __pyx_obj_6PyCafe PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getDbrBase", 0); - /* "PyCafe.pyx":1938 + /* "PyCafe.pyx":1937 * def getDbrBase(self, handlePV): * * cdef DBR_TYPE _cafeDbrType = DBR_PLAIN # <<<<<<<<<<<<<< @@ -57209,17 +57657,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_220getDbrBase(struct __pyx_obj_6PyCafe */ __pyx_v__cafeDbrType = DBR_PLAIN; - /* "PyCafe.pyx":1939 + /* "PyCafe.pyx":1938 * * cdef DBR_TYPE _cafeDbrType = DBR_PLAIN * cdef int status = self.hh.getCafeDbrType(handlePV, _cafeDbrType) # <<<<<<<<<<<<<< * * return _cafeDbrType */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1939, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1938, __pyx_L1_error) __pyx_v_status = __pyx_v_self->hh.getCafeDbrType(__pyx_t_1, __pyx_v__cafeDbrType); - /* "PyCafe.pyx":1941 + /* "PyCafe.pyx":1940 * cdef int status = self.hh.getCafeDbrType(handlePV, _cafeDbrType) * * return _cafeDbrType # <<<<<<<<<<<<<< @@ -57227,13 +57675,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_220getDbrBase(struct __pyx_obj_6PyCafe * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_DBR_TYPE(__pyx_v__cafeDbrType); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1941, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_DBR_TYPE(__pyx_v__cafeDbrType); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1936 + /* "PyCafe.pyx":1935 * ############################################################################ * @verify_handlepv * def getDbrBase(self, handlePV): # <<<<<<<<<<<<<< @@ -57254,7 +57702,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_220getDbrBase(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":1947 +/* "PyCafe.pyx":1946 * ############################################################################ * @verify_handlepv * def setGetCacheWaitPolicy( # <<<<<<<<<<<<<< @@ -57293,11 +57741,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_223setGetCacheWaitPolicy(PyObject *__p case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wpk)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setGetCacheWaitPolicy", 1, 2, 2, 1); __PYX_ERR(3, 1947, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setGetCacheWaitPolicy", 1, 2, 2, 1); __PYX_ERR(3, 1946, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGetCacheWaitPolicy") < 0)) __PYX_ERR(3, 1947, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGetCacheWaitPolicy") < 0)) __PYX_ERR(3, 1946, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -57306,11 +57754,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_223setGetCacheWaitPolicy(PyObject *__p values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_handlePV = values[0]; - __pyx_v_wpk = ((ChannelGetCacheWaitPolicyKind)__Pyx_PyInt_As_ChannelGetCacheWaitPolicyKind(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1948, __pyx_L3_error) + __pyx_v_wpk = ((ChannelGetCacheWaitPolicyKind)__Pyx_PyInt_As_ChannelGetCacheWaitPolicyKind(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1947, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setGetCacheWaitPolicy", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1947, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setGetCacheWaitPolicy", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1946, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setGetCacheWaitPolicy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -57333,7 +57781,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_222setGetCacheWaitPolicy(struct __pyx_ unsigned int __pyx_t_4; __Pyx_RefNannySetupContext("setGetCacheWaitPolicy", 0); - /* "PyCafe.pyx":1951 + /* "PyCafe.pyx":1950 * * # Print Warning Message * if wpk > GET_CACHE_WAIT: # <<<<<<<<<<<<<< @@ -57343,57 +57791,57 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_222setGetCacheWaitPolicy(struct __pyx_ __pyx_t_1 = ((__pyx_v_wpk > GET_CACHE_WAIT) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1952 + /* "PyCafe.pyx":1951 * # Print Warning Message * if wpk > GET_CACHE_WAIT: * print( # <<<<<<<<<<<<<< * ("WARNING: PyCafe def setGetCacheWaitPolicy(" * "handle/PV, ChannelGetCacheWaitPolicyKind)")) */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1952, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1951, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1955 + /* "PyCafe.pyx":1954 * ("WARNING: PyCafe def setGetCacheWaitPolicy(" * "handle/PV, ChannelGetCacheWaitPolicyKind)")) * print("Allowed ChannelGetCacheWaitPolicyKind are:") # <<<<<<<<<<<<<< * print( * ("GET_CACHE_NO_CHECK (0), GET_CACHE_NO_WAIT (1)," */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1955, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1954, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1956 + /* "PyCafe.pyx":1955 * "handle/PV, ChannelGetCacheWaitPolicyKind)")) * print("Allowed ChannelGetCacheWaitPolicyKind are:") * print( # <<<<<<<<<<<<<< * ("GET_CACHE_NO_CHECK (0), GET_CACHE_NO_WAIT (1)," * "GET_CACHE_WAIT (2)")) */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1956, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1955, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1960 + /* "PyCafe.pyx":1959 * "GET_CACHE_WAIT (2)")) * print( * "The value entered was", wpk, # <<<<<<<<<<<<<< * "hence assuming default value GET_CACHE_WAIT") * wpk = GET_CACHE_WAIT */ - __pyx_t_2 = __Pyx_PyInt_From_ChannelGetCacheWaitPolicyKind(__pyx_v_wpk); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1960, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_ChannelGetCacheWaitPolicyKind(__pyx_v_wpk); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1959, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1959 + /* "PyCafe.pyx":1958 * ("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") */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1959, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1958, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_kp_u_The_value_entered_was); __Pyx_GIVEREF(__pyx_kp_u_The_value_entered_was); @@ -57404,12 +57852,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_222setGetCacheWaitPolicy(struct __pyx_ __Pyx_GIVEREF(__pyx_kp_u_hence_assuming_default_value_GET); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_hence_assuming_default_value_GET); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1959, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1958, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1962 + /* "PyCafe.pyx":1961 * "The value entered was", wpk, * "hence assuming default value GET_CACHE_WAIT") * wpk = GET_CACHE_WAIT # <<<<<<<<<<<<<< @@ -57418,7 +57866,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_222setGetCacheWaitPolicy(struct __pyx_ */ __pyx_v_wpk = GET_CACHE_WAIT; - /* "PyCafe.pyx":1951 + /* "PyCafe.pyx":1950 * * # Print Warning Message * if wpk > GET_CACHE_WAIT: # <<<<<<<<<<<<<< @@ -57427,7 +57875,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_222setGetCacheWaitPolicy(struct __pyx_ */ } - /* "PyCafe.pyx":1965 + /* "PyCafe.pyx":1964 * * cdef ChannelGetCacheWaitPolicy channelGetCacheWaitPolicy * channelGetCacheWaitPolicy.setWaitKind(wpk) # <<<<<<<<<<<<<< @@ -57436,7 +57884,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_222setGetCacheWaitPolicy(struct __pyx_ */ __pyx_v_channelGetCacheWaitPolicy.setWaitKind(__pyx_v_wpk); - /* "PyCafe.pyx":1967 + /* "PyCafe.pyx":1966 * channelGetCacheWaitPolicy.setWaitKind(wpk) * * return self.ph.setChannelGetCacheWaitPolicy( # <<<<<<<<<<<<<< @@ -57445,29 +57893,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_222setGetCacheWaitPolicy(struct __pyx_ */ __Pyx_XDECREF(__pyx_r); - /* "PyCafe.pyx":1968 + /* "PyCafe.pyx":1967 * * return self.ph.setChannelGetCacheWaitPolicy( * handlePV, channelGetCacheWaitPolicy) # <<<<<<<<<<<<<< * ############################################################################ * */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1968, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 1967, __pyx_L1_error) - /* "PyCafe.pyx":1967 + /* "PyCafe.pyx":1966 * channelGetCacheWaitPolicy.setWaitKind(wpk) * * return self.ph.setChannelGetCacheWaitPolicy( # <<<<<<<<<<<<<< * handlePV, channelGetCacheWaitPolicy) * ############################################################################ */ - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setChannelGetCacheWaitPolicy(__pyx_t_4, __pyx_v_channelGetCacheWaitPolicy)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1967, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setChannelGetCacheWaitPolicy(__pyx_t_4, __pyx_v_channelGetCacheWaitPolicy)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1966, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1947 + /* "PyCafe.pyx":1946 * ############################################################################ * @verify_handlepv * def setGetCacheWaitPolicy( # <<<<<<<<<<<<<< @@ -57489,7 +57937,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_222setGetCacheWaitPolicy(struct __pyx_ return __pyx_r; } -/* "PyCafe.pyx":1972 +/* "PyCafe.pyx":1971 * * ############################################################################ * def setGetCacheWaitPolicyAllHandles( # <<<<<<<<<<<<<< @@ -57505,7 +57953,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_225setGetCacheWaitPolicyAllHandles(PyO __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setGetCacheWaitPolicyAllHandles (wrapper)", 0); assert(__pyx_arg_wpk); { - __pyx_v_wpk = ((ChannelGetCacheWaitPolicyKind)__Pyx_PyInt_As_ChannelGetCacheWaitPolicyKind(__pyx_arg_wpk)); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1973, __pyx_L3_error) + __pyx_v_wpk = ((ChannelGetCacheWaitPolicyKind)__Pyx_PyInt_As_ChannelGetCacheWaitPolicyKind(__pyx_arg_wpk)); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1972, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -57529,7 +57977,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_224setGetCacheWaitPolicyAllHandles(str PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("setGetCacheWaitPolicyAllHandles", 0); - /* "PyCafe.pyx":1976 + /* "PyCafe.pyx":1975 * * # Print Warning Message * if wpk > GET_CACHE_WAIT: # <<<<<<<<<<<<<< @@ -57539,57 +57987,57 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_224setGetCacheWaitPolicyAllHandles(str __pyx_t_1 = ((__pyx_v_wpk > GET_CACHE_WAIT) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":1977 + /* "PyCafe.pyx":1976 * # Print Warning Message * if wpk > GET_CACHE_WAIT: * print( # <<<<<<<<<<<<<< * "WARNING: PyCafe def setGetCacheWaitPolicyAllHandles( \ * ChannelGetCacheWaitPolicyKind)") */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1977, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1980 + /* "PyCafe.pyx":1979 * "WARNING: PyCafe def setGetCacheWaitPolicyAllHandles( \ * ChannelGetCacheWaitPolicyKind)") * print("Allowed ChannelGetCacheWaitPolicyKind are:") # <<<<<<<<<<<<<< * print( * "GET_CACHE_NO_CHECK (0), GET_CACHE_NO_WAIT (1), \ */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1980, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1981 + /* "PyCafe.pyx":1980 * ChannelGetCacheWaitPolicyKind)") * print("Allowed ChannelGetCacheWaitPolicyKind are:") * print( # <<<<<<<<<<<<<< * "GET_CACHE_NO_CHECK (0), GET_CACHE_NO_WAIT (1), \ * GET_CACHE_WAIT (2)") */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1981, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1980, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1985 + /* "PyCafe.pyx":1984 * GET_CACHE_WAIT (2)") * print( * "The value entered was", wpk, # <<<<<<<<<<<<<< * "hence assuming default value GET_CACHE_WAIT") * wpk = GET_CACHE_WAIT */ - __pyx_t_2 = __Pyx_PyInt_From_ChannelGetCacheWaitPolicyKind(__pyx_v_wpk); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1985, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_ChannelGetCacheWaitPolicyKind(__pyx_v_wpk); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1984, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1984 + /* "PyCafe.pyx":1983 * "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") */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1984, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_kp_u_The_value_entered_was); __Pyx_GIVEREF(__pyx_kp_u_The_value_entered_was); @@ -57600,12 +58048,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_224setGetCacheWaitPolicyAllHandles(str __Pyx_GIVEREF(__pyx_kp_u_hence_assuming_default_value_GET); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_hence_assuming_default_value_GET); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1984, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":1987 + /* "PyCafe.pyx":1986 * "The value entered was", wpk, * "hence assuming default value GET_CACHE_WAIT") * wpk = GET_CACHE_WAIT # <<<<<<<<<<<<<< @@ -57614,7 +58062,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_224setGetCacheWaitPolicyAllHandles(str */ __pyx_v_wpk = GET_CACHE_WAIT; - /* "PyCafe.pyx":1976 + /* "PyCafe.pyx":1975 * * # Print Warning Message * if wpk > GET_CACHE_WAIT: # <<<<<<<<<<<<<< @@ -57623,7 +58071,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_224setGetCacheWaitPolicyAllHandles(str */ } - /* "PyCafe.pyx":1990 + /* "PyCafe.pyx":1989 * * cdef ChannelGetCacheWaitPolicy channelGetCacheWaitPolicy * channelGetCacheWaitPolicy.setWaitKind(wpk) # <<<<<<<<<<<<<< @@ -57632,7 +58080,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_224setGetCacheWaitPolicyAllHandles(str */ __pyx_v_channelGetCacheWaitPolicy.setWaitKind(__pyx_v_wpk); - /* "PyCafe.pyx":1992 + /* "PyCafe.pyx":1991 * channelGetCacheWaitPolicy.setWaitKind(wpk) * * return self.ph.setChannelGetCacheWaitPolicyAllHandles( # <<<<<<<<<<<<<< @@ -57641,20 +58089,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_224setGetCacheWaitPolicyAllHandles(str */ __Pyx_XDECREF(__pyx_r); - /* "PyCafe.pyx":1993 + /* "PyCafe.pyx":1992 * * return self.ph.setChannelGetCacheWaitPolicyAllHandles( * channelGetCacheWaitPolicy) # <<<<<<<<<<<<<< * ############################################################################ * */ - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setChannelGetCacheWaitPolicyAllHandles(__pyx_v_channelGetCacheWaitPolicy)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1992, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setChannelGetCacheWaitPolicyAllHandles(__pyx_v_channelGetCacheWaitPolicy)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1991, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1972 + /* "PyCafe.pyx":1971 * * ############################################################################ * def setGetCacheWaitPolicyAllHandles( # <<<<<<<<<<<<<< @@ -57676,7 +58124,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_224setGetCacheWaitPolicyAllHandles(str return __pyx_r; } -/* "PyCafe.pyx":1998 +/* "PyCafe.pyx":1997 * ############################################################################ * @verify_handlepv * def setGetActionWhenMonitorPolicy( # <<<<<<<<<<<<<< @@ -57715,11 +58163,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_227setGetActionWhenMonitorPolicy(PyObj case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wmpk)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setGetActionWhenMonitorPolicy", 1, 2, 2, 1); __PYX_ERR(3, 1998, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setGetActionWhenMonitorPolicy", 1, 2, 2, 1); __PYX_ERR(3, 1997, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGetActionWhenMonitorPolicy") < 0)) __PYX_ERR(3, 1998, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGetActionWhenMonitorPolicy") < 0)) __PYX_ERR(3, 1997, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -57728,11 +58176,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_227setGetActionWhenMonitorPolicy(PyObj values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_handlePV = values[0]; - __pyx_v_wmpk = ((ChannelGetActionWhenMonitorPolicyKind)__Pyx_PyInt_As_ChannelGetActionWhenMonitorPolicyKind(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1999, __pyx_L3_error) + __pyx_v_wmpk = ((ChannelGetActionWhenMonitorPolicyKind)__Pyx_PyInt_As_ChannelGetActionWhenMonitorPolicyKind(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 1998, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setGetActionWhenMonitorPolicy", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1998, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setGetActionWhenMonitorPolicy", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1997, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setGetActionWhenMonitorPolicy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -57755,7 +58203,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_226setGetActionWhenMonitorPolicy(struc unsigned int __pyx_t_4; __Pyx_RefNannySetupContext("setGetActionWhenMonitorPolicy", 0); - /* "PyCafe.pyx":2002 + /* "PyCafe.pyx":2001 * * # Print Warning Message * if wmpk > GET_FROM_IOC: # <<<<<<<<<<<<<< @@ -57765,49 +58213,49 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_226setGetActionWhenMonitorPolicy(struc __pyx_t_1 = ((__pyx_v_wmpk > GET_FROM_IOC) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":2003 + /* "PyCafe.pyx":2002 * # Print Warning Message * if wmpk > GET_FROM_IOC: * print("WARNING: PyCafe def setGetActionWhenMonitorPolicy") # <<<<<<<<<<<<<< * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print("GET_FROM_CACHE (0), GET_FROM_IOC (1)") */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2003, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2002, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":2004 + /* "PyCafe.pyx":2003 * if wmpk > GET_FROM_IOC: * print("WARNING: PyCafe def setGetActionWhenMonitorPolicy") * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") # <<<<<<<<<<<<<< * print("GET_FROM_CACHE (0), GET_FROM_IOC (1)") * print("The value entered was", wmpk, */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2004, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":2005 + /* "PyCafe.pyx":2004 * print("WARNING: PyCafe def setGetActionWhenMonitorPolicy") * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print("GET_FROM_CACHE (0), GET_FROM_IOC (1)") # <<<<<<<<<<<<<< * print("The value entered was", wmpk, * "hence assuming default value GET_FROM_IOC") */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2005, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2004, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":2006 + /* "PyCafe.pyx":2005 * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print("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 */ - __pyx_t_2 = __Pyx_PyInt_From_ChannelGetActionWhenMonitorPolicyKind(__pyx_v_wmpk); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2006, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_ChannelGetActionWhenMonitorPolicyKind(__pyx_v_wmpk); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2006, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_kp_u_The_value_entered_was); __Pyx_GIVEREF(__pyx_kp_u_The_value_entered_was); @@ -57818,12 +58266,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_226setGetActionWhenMonitorPolicy(struc __Pyx_GIVEREF(__pyx_kp_u_hence_assuming_default_value_GET_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_hence_assuming_default_value_GET_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2006, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":2008 + /* "PyCafe.pyx":2007 * print("The value entered was", wmpk, * "hence assuming default value GET_FROM_IOC") * wmpk = GET_FROM_IOC # <<<<<<<<<<<<<< @@ -57832,7 +58280,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_226setGetActionWhenMonitorPolicy(struc */ __pyx_v_wmpk = GET_FROM_IOC; - /* "PyCafe.pyx":2002 + /* "PyCafe.pyx":2001 * * # Print Warning Message * if wmpk > GET_FROM_IOC: # <<<<<<<<<<<<<< @@ -57841,7 +58289,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_226setGetActionWhenMonitorPolicy(struc */ } - /* "PyCafe.pyx":2011 + /* "PyCafe.pyx":2010 * * cdef ChannelGetActionWhenMonitorPolicy channelGetActionWhenMonitorPolicy * channelGetActionWhenMonitorPolicy.setActionKind(wmpk) # <<<<<<<<<<<<<< @@ -57850,7 +58298,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_226setGetActionWhenMonitorPolicy(struc */ __pyx_v_channelGetActionWhenMonitorPolicy.setActionKind(__pyx_v_wmpk); - /* "PyCafe.pyx":2013 + /* "PyCafe.pyx":2012 * channelGetActionWhenMonitorPolicy.setActionKind(wmpk) * * return self.ph.setChannelGetActionWhenMonitorPolicy( # <<<<<<<<<<<<<< @@ -57859,29 +58307,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_226setGetActionWhenMonitorPolicy(struc */ __Pyx_XDECREF(__pyx_r); - /* "PyCafe.pyx":2014 + /* "PyCafe.pyx":2013 * * return self.ph.setChannelGetActionWhenMonitorPolicy( * handlePV, channelGetActionWhenMonitorPolicy) # <<<<<<<<<<<<<< * ############################################################################ * */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2014, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2013, __pyx_L1_error) - /* "PyCafe.pyx":2013 + /* "PyCafe.pyx":2012 * channelGetActionWhenMonitorPolicy.setActionKind(wmpk) * * return self.ph.setChannelGetActionWhenMonitorPolicy( # <<<<<<<<<<<<<< * handlePV, channelGetActionWhenMonitorPolicy) * ############################################################################ */ - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setChannelGetActionWhenMonitorPolicy(__pyx_t_4, __pyx_v_channelGetActionWhenMonitorPolicy)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2013, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setChannelGetActionWhenMonitorPolicy(__pyx_t_4, __pyx_v_channelGetActionWhenMonitorPolicy)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":1998 + /* "PyCafe.pyx":1997 * ############################################################################ * @verify_handlepv * def setGetActionWhenMonitorPolicy( # <<<<<<<<<<<<<< @@ -57903,7 +58351,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_226setGetActionWhenMonitorPolicy(struc return __pyx_r; } -/* "PyCafe.pyx":2018 +/* "PyCafe.pyx":2017 * * ############################################################################ * def setGetActionWhenMonitorPolicyAllHandles( # <<<<<<<<<<<<<< @@ -57919,7 +58367,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_229setGetActionWhenMonitorPolicyAllHan __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setGetActionWhenMonitorPolicyAllHandles (wrapper)", 0); assert(__pyx_arg_wmpk); { - __pyx_v_wmpk = ((ChannelGetActionWhenMonitorPolicyKind)__Pyx_PyInt_As_ChannelGetActionWhenMonitorPolicyKind(__pyx_arg_wmpk)); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2019, __pyx_L3_error) + __pyx_v_wmpk = ((ChannelGetActionWhenMonitorPolicyKind)__Pyx_PyInt_As_ChannelGetActionWhenMonitorPolicyKind(__pyx_arg_wmpk)); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 2018, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -57943,7 +58391,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_228setGetActionWhenMonitorPolicyAllHan PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("setGetActionWhenMonitorPolicyAllHandles", 0); - /* "PyCafe.pyx":2022 + /* "PyCafe.pyx":2021 * * # Print Warning Message * if wmpk > GET_FROM_IOC: # <<<<<<<<<<<<<< @@ -57953,57 +58401,57 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_228setGetActionWhenMonitorPolicyAllHan __pyx_t_1 = ((__pyx_v_wmpk > GET_FROM_IOC) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":2023 + /* "PyCafe.pyx":2022 * # Print Warning Message * if wmpk > GET_FROM_IOC: * print("WARNING: PyCafe def setGetActionWhenMonitorPolicyAllHandles") # <<<<<<<<<<<<<< * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print(" GET_FROM_CACHE (0), GET_FROM_IOC (1)") */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2023, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2022, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":2024 + /* "PyCafe.pyx":2023 * if wmpk > GET_FROM_IOC: * print("WARNING: PyCafe def setGetActionWhenMonitorPolicyAllHandles") * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") # <<<<<<<<<<<<<< * print(" GET_FROM_CACHE (0), GET_FROM_IOC (1)") * print( */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2024, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2023, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":2025 + /* "PyCafe.pyx":2024 * print("WARNING: PyCafe def setGetActionWhenMonitorPolicyAllHandles") * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print(" GET_FROM_CACHE (0), GET_FROM_IOC (1)") # <<<<<<<<<<<<<< * print( * "The value entered was", wmpk, */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2025, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2024, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":2027 + /* "PyCafe.pyx":2026 * print(" 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 */ - __pyx_t_2 = __Pyx_PyInt_From_ChannelGetActionWhenMonitorPolicyKind(__pyx_v_wmpk); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2027, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_ChannelGetActionWhenMonitorPolicyKind(__pyx_v_wmpk); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2026, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":2026 + /* "PyCafe.pyx":2025 * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print(" GET_FROM_CACHE (0), GET_FROM_IOC (1)") * print( # <<<<<<<<<<<<<< * "The value entered was", wmpk, * "hence assuming default value GET_FROM_IOC") */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2026, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2025, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_kp_u_The_value_entered_was); __Pyx_GIVEREF(__pyx_kp_u_The_value_entered_was); @@ -58014,12 +58462,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_228setGetActionWhenMonitorPolicyAllHan __Pyx_GIVEREF(__pyx_kp_u_hence_assuming_default_value_GET_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_hence_assuming_default_value_GET_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2026, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2025, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "PyCafe.pyx":2029 + /* "PyCafe.pyx":2028 * "The value entered was", wmpk, * "hence assuming default value GET_FROM_IOC") * wmpk = GET_FROM_IOC # <<<<<<<<<<<<<< @@ -58028,7 +58476,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_228setGetActionWhenMonitorPolicyAllHan */ __pyx_v_wmpk = GET_FROM_IOC; - /* "PyCafe.pyx":2022 + /* "PyCafe.pyx":2021 * * # Print Warning Message * if wmpk > GET_FROM_IOC: # <<<<<<<<<<<<<< @@ -58037,7 +58485,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_228setGetActionWhenMonitorPolicyAllHan */ } - /* "PyCafe.pyx":2032 + /* "PyCafe.pyx":2031 * * cdef ChannelGetActionWhenMonitorPolicy channelGetActionWhenMonitorPolicy * channelGetActionWhenMonitorPolicy.setActionKind(wmpk) # <<<<<<<<<<<<<< @@ -58046,7 +58494,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_228setGetActionWhenMonitorPolicyAllHan */ __pyx_v_channelGetActionWhenMonitorPolicy.setActionKind(__pyx_v_wmpk); - /* "PyCafe.pyx":2034 + /* "PyCafe.pyx":2033 * channelGetActionWhenMonitorPolicy.setActionKind(wmpk) * * return self.ph.setChannelGetActionWhenMonitorPolicyAllHandles( # <<<<<<<<<<<<<< @@ -58055,20 +58503,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_228setGetActionWhenMonitorPolicyAllHan */ __Pyx_XDECREF(__pyx_r); - /* "PyCafe.pyx":2035 + /* "PyCafe.pyx":2034 * * return self.ph.setChannelGetActionWhenMonitorPolicyAllHandles( * channelGetActionWhenMonitorPolicy) # <<<<<<<<<<<<<< * ############################################################################ * */ - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setChannelGetActionWhenMonitorPolicyAllHandles(__pyx_v_channelGetActionWhenMonitorPolicy)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2034, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->ph.setChannelGetActionWhenMonitorPolicyAllHandles(__pyx_v_channelGetActionWhenMonitorPolicy)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2033, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2018 + /* "PyCafe.pyx":2017 * * ############################################################################ * def setGetActionWhenMonitorPolicyAllHandles( # <<<<<<<<<<<<<< @@ -58090,7 +58538,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_228setGetActionWhenMonitorPolicyAllHan return __pyx_r; } -/* "PyCafe.pyx":2040 +/* "PyCafe.pyx":2039 * ############################################################################ * @verify_handlepv * def getNonBlocking(self, handlePV): # <<<<<<<<<<<<<< @@ -58125,17 +58573,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py PyObject *__pyx_t_6 = NULL; __Pyx_RefNannySetupContext("getNonBlocking", 0); - /* "PyCafe.pyx":2046 + /* "PyCafe.pyx":2045 * at the end. * ''' * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * cdef int status * */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2046, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2045, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":2049 + /* "PyCafe.pyx":2048 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -58150,7 +58598,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py #endif /*try:*/ { - /* "PyCafe.pyx":2050 + /* "PyCafe.pyx":2049 * * with nogil: * status = self._c_cafe.getNonBlocking(handle) # <<<<<<<<<<<<<< @@ -58160,7 +58608,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py __pyx_v_status = __pyx_v_self->_c_cafe->getNonBlocking(__pyx_v_handle); } - /* "PyCafe.pyx":2049 + /* "PyCafe.pyx":2048 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -58179,7 +58627,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py } } - /* "PyCafe.pyx":2052 + /* "PyCafe.pyx":2051 * status = self._c_cafe.getNonBlocking(handle) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -58189,7 +58637,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2053 + /* "PyCafe.pyx":2052 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -58199,7 +58647,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2054 + /* "PyCafe.pyx":2053 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -58209,7 +58657,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py __pyx_t_2 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2055 + /* "PyCafe.pyx":2054 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -58218,7 +58666,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":2054 + /* "PyCafe.pyx":2053 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -58228,7 +58676,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py goto __pyx_L8; } - /* "PyCafe.pyx":2057 + /* "PyCafe.pyx":2056 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -58240,7 +58688,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py } __pyx_L8:; - /* "PyCafe.pyx":2053 + /* "PyCafe.pyx":2052 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -58249,7 +58697,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":2058 + /* "PyCafe.pyx":2057 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -58259,16 +58707,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2061 + /* "PyCafe.pyx":2060 * raise Exception( * "EXCEPTION RAISED in PyCafe def getNonBlocking. \ * Status = {0}".format(status)) # <<<<<<<<<<<<<< * * return status */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_g_2, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2061, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_g_2, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2060, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2061, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2060, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -58283,25 +58731,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2061, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2060, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2059 + /* "PyCafe.pyx":2058 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def getNonBlocking. \ * Status = {0}".format(status)) */ - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2059, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2058, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 2059, __pyx_L1_error) + __PYX_ERR(3, 2058, __pyx_L1_error) - /* "PyCafe.pyx":2058 + /* "PyCafe.pyx":2057 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -58310,7 +58758,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":2052 + /* "PyCafe.pyx":2051 * status = self._c_cafe.getNonBlocking(handle) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -58319,7 +58767,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":2063 + /* "PyCafe.pyx":2062 * Status = {0}".format(status)) * * return status # <<<<<<<<<<<<<< @@ -58327,13 +58775,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2063, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2062, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2040 + /* "PyCafe.pyx":2039 * ############################################################################ * @verify_handlepv * def getNonBlocking(self, handlePV): # <<<<<<<<<<<<<< @@ -58357,7 +58805,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_230getNonBlocking(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":2067 +/* "PyCafe.pyx":2066 * * ############################################################################ * def getStr(self, handlePV, object cb=None): # <<<<<<<<<<<<<< @@ -58401,7 +58849,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_233getStr(PyObject *__pyx_v_self, PyOb } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getStr") < 0)) __PYX_ERR(3, 2067, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getStr") < 0)) __PYX_ERR(3, 2066, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -58417,7 +58865,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_233getStr(PyObject *__pyx_v_self, PyOb } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getStr", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2067, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getStr", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2066, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getStr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -58439,7 +58887,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_232getStr(struct __pyx_obj_6PyCafe_CyC PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getStr", 0); - /* "PyCafe.pyx":2068 + /* "PyCafe.pyx":2067 * ############################################################################ * def getStr(self, handlePV, object cb=None): * return self.get(handlePV, dt='str') # <<<<<<<<<<<<<< @@ -58447,17 +58895,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_232getStr(struct __pyx_obj_6PyCafe_CyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2068, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2067, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2068, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2067, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2068, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2067, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 2068, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2068, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 2067, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2067, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -58466,7 +58914,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_232getStr(struct __pyx_obj_6PyCafe_CyC __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2067 + /* "PyCafe.pyx":2066 * * ############################################################################ * def getStr(self, handlePV, object cb=None): # <<<<<<<<<<<<<< @@ -58490,7 +58938,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_232getStr(struct __pyx_obj_6PyCafe_CyC return __pyx_r; } -/* "PyCafe.pyx":2072 +/* "PyCafe.pyx":2071 * * ############################################################################ * def getInt(self, handlePV, object cb=None): # <<<<<<<<<<<<<< @@ -58534,7 +58982,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_235getInt(PyObject *__pyx_v_self, PyOb } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getInt") < 0)) __PYX_ERR(3, 2072, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getInt") < 0)) __PYX_ERR(3, 2071, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -58550,7 +58998,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_235getInt(PyObject *__pyx_v_self, PyOb } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getInt", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2072, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getInt", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2071, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getInt", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -58572,7 +59020,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_234getInt(struct __pyx_obj_6PyCafe_CyC PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getInt", 0); - /* "PyCafe.pyx":2073 + /* "PyCafe.pyx":2072 * ############################################################################ * def getInt(self, handlePV, object cb=None): * return self.get(handlePV, dt='int') # <<<<<<<<<<<<<< @@ -58580,17 +59028,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_234getInt(struct __pyx_obj_6PyCafe_CyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2073, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2072, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2073, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2072, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2073, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2072, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 2073, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2073, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 2072, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2072, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -58599,7 +59047,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_234getInt(struct __pyx_obj_6PyCafe_CyC __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2072 + /* "PyCafe.pyx":2071 * * ############################################################################ * def getInt(self, handlePV, object cb=None): # <<<<<<<<<<<<<< @@ -58623,7 +59071,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_234getInt(struct __pyx_obj_6PyCafe_CyC return __pyx_r; } -/* "PyCafe.pyx":2077 +/* "PyCafe.pyx":2076 * * ############################################################################ * def getFloat(self, handlePV, object cb=None): # <<<<<<<<<<<<<< @@ -58667,7 +59115,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_237getFloat(PyObject *__pyx_v_self, Py } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getFloat") < 0)) __PYX_ERR(3, 2077, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getFloat") < 0)) __PYX_ERR(3, 2076, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -58683,7 +59131,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_237getFloat(PyObject *__pyx_v_self, Py } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getFloat", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2077, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getFloat", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2076, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getFloat", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -58705,7 +59153,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_236getFloat(struct __pyx_obj_6PyCafe_C PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getFloat", 0); - /* "PyCafe.pyx":2078 + /* "PyCafe.pyx":2077 * ############################################################################ * def getFloat(self, handlePV, object cb=None): * return self.get(handlePV, dt='float') # <<<<<<<<<<<<<< @@ -58713,17 +59161,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_236getFloat(struct __pyx_obj_6PyCafe_C * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2078, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2077, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2078, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2077, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2078, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2077, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 2078, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2078, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 2077, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2077, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -58732,7 +59180,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_236getFloat(struct __pyx_obj_6PyCafe_C __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2077 + /* "PyCafe.pyx":2076 * * ############################################################################ * def getFloat(self, handlePV, object cb=None): # <<<<<<<<<<<<<< @@ -58756,7 +59204,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_236getFloat(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":2081 +/* "PyCafe.pyx":2080 * ############################################################################ * * def caget(self, str pv_name, str dt='native'): # <<<<<<<<<<<<<< @@ -58800,7 +59248,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_239caget(PyObject *__pyx_v_self, PyObj } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "caget") < 0)) __PYX_ERR(3, 2081, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "caget") < 0)) __PYX_ERR(3, 2080, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -58816,14 +59264,14 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_239caget(PyObject *__pyx_v_self, PyObj } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("caget", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2081, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("caget", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2080, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.caget", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pv_name), (&PyUnicode_Type), 1, "pv_name", 1))) __PYX_ERR(3, 2081, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 2081, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pv_name), (&PyUnicode_Type), 1, "pv_name", 1))) __PYX_ERR(3, 2080, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 2080, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_238caget(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_pv_name, __pyx_v_dt); /* function exit code */ @@ -58845,7 +59293,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_238caget(struct __pyx_obj_6PyCafe_CyCa PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("caget", 0); - /* "PyCafe.pyx":2082 + /* "PyCafe.pyx":2081 * * def caget(self, str pv_name, str dt='native'): * return self.get(pv_name, dt) # <<<<<<<<<<<<<< @@ -58853,7 +59301,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_238caget(struct __pyx_obj_6PyCafe_CyCa * def caput(self, str pv_name, pv_value): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2082, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -58870,7 +59318,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_238caget(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_pv_name, __pyx_v_dt}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2082, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2081, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -58878,13 +59326,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_238caget(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_pv_name, __pyx_v_dt}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2082, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2081, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2082, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -58895,7 +59343,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_238caget(struct __pyx_obj_6PyCafe_CyCa __Pyx_INCREF(__pyx_v_dt); __Pyx_GIVEREF(__pyx_v_dt); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_dt); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2082, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -58904,7 +59352,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_238caget(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2081 + /* "PyCafe.pyx":2080 * ############################################################################ * * def caget(self, str pv_name, str dt='native'): # <<<<<<<<<<<<<< @@ -58928,7 +59376,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_238caget(struct __pyx_obj_6PyCafe_CyCa return __pyx_r; } -/* "PyCafe.pyx":2084 +/* "PyCafe.pyx":2083 * return self.get(pv_name, dt) * * def caput(self, str pv_name, pv_value): # <<<<<<<<<<<<<< @@ -58967,11 +59415,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_241caput(PyObject *__pyx_v_self, PyObj case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pv_value)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("caput", 1, 2, 2, 1); __PYX_ERR(3, 2084, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("caput", 1, 2, 2, 1); __PYX_ERR(3, 2083, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "caput") < 0)) __PYX_ERR(3, 2084, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "caput") < 0)) __PYX_ERR(3, 2083, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -58984,13 +59432,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_241caput(PyObject *__pyx_v_self, PyObj } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("caput", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2084, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("caput", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2083, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.caput", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pv_name), (&PyUnicode_Type), 1, "pv_name", 1))) __PYX_ERR(3, 2084, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pv_name), (&PyUnicode_Type), 1, "pv_name", 1))) __PYX_ERR(3, 2083, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_240caput(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_pv_name, __pyx_v_pv_value); /* function exit code */ @@ -59012,7 +59460,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_240caput(struct __pyx_obj_6PyCafe_CyCa PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("caput", 0); - /* "PyCafe.pyx":2085 + /* "PyCafe.pyx":2084 * * def caput(self, str pv_name, pv_value): * return self.set(pv_name, pv_value) # <<<<<<<<<<<<<< @@ -59020,7 +59468,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_240caput(struct __pyx_obj_6PyCafe_CyCa * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2085, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2084, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -59037,7 +59485,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_240caput(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_pv_name, __pyx_v_pv_value}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2085, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2084, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -59045,13 +59493,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_240caput(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_pv_name, __pyx_v_pv_value}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2085, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2084, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2085, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2084, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -59062,7 +59510,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_240caput(struct __pyx_obj_6PyCafe_CyCa __Pyx_INCREF(__pyx_v_pv_value); __Pyx_GIVEREF(__pyx_v_pv_value); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_pv_value); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2085, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2084, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -59071,7 +59519,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_240caput(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2084 + /* "PyCafe.pyx":2083 * return self.get(pv_name, dt) * * def caput(self, str pv_name, pv_value): # <<<<<<<<<<<<<< @@ -59095,7 +59543,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_240caput(struct __pyx_obj_6PyCafe_CyCa return __pyx_r; } -/* "PyCafe.pyx":2089 +/* "PyCafe.pyx":2088 * ############################################################################ * @verify_handlepv * def get(self, handlePV = 0, str dt='native'): # <<<<<<<<<<<<<< @@ -59142,7 +59590,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_243get(PyObject *__pyx_v_self, PyObjec } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get") < 0)) __PYX_ERR(3, 2089, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get") < 0)) __PYX_ERR(3, 2088, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -59159,13 +59607,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_243get(PyObject *__pyx_v_self, PyObjec } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2089, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2088, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 2089, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 2088, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_242get(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_dt); /* function exit code */ @@ -59207,7 +59655,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe std::string __pyx_t_15; __Pyx_RefNannySetupContext("get", 0); - /* "PyCafe.pyx":2090 + /* "PyCafe.pyx":2089 * @verify_handlepv * def get(self, handlePV = 0, str dt='native'): * cdef str _METHOD = "get(handlePV, dt)" # <<<<<<<<<<<<<< @@ -59217,17 +59665,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_kp_u_get_handlePV_dt); __pyx_v__METHOD = __pyx_kp_u_get_handlePV_dt; - /* "PyCafe.pyx":2092 + /* "PyCafe.pyx":2091 * cdef str _METHOD = "get(handlePV, dt)" * * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * cdef int status * cdef long dtr = 0 */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2092, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2091, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":2094 + /* "PyCafe.pyx":2093 * cdef unsigned int handle = handlePV * cdef int status * cdef long dtr = 0 # <<<<<<<<<<<<<< @@ -59236,7 +59684,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_dtr = 0; - /* "PyCafe.pyx":2096 + /* "PyCafe.pyx":2095 * cdef long dtr = 0 * * status = self.hh.getDataTypeNative(handle, dtr) # <<<<<<<<<<<<<< @@ -59245,7 +59693,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_status = __pyx_v_self->hh.getDataTypeNative(__pyx_v_handle, __pyx_v_dtr); - /* "PyCafe.pyx":2098 + /* "PyCafe.pyx":2097 * status = self.hh.getDataTypeNative(handle, dtr) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -59255,7 +59703,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2099 + /* "PyCafe.pyx":2098 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -59265,7 +59713,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2100 + /* "PyCafe.pyx":2099 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -59275,7 +59723,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2101 + /* "PyCafe.pyx":2100 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -59284,7 +59732,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":2100 + /* "PyCafe.pyx":2099 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -59294,7 +59742,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L5; } - /* "PyCafe.pyx":2103 + /* "PyCafe.pyx":2102 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -59306,7 +59754,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L5:; - /* "PyCafe.pyx":2099 + /* "PyCafe.pyx":2098 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -59315,7 +59763,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2104 + /* "PyCafe.pyx":2103 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -59325,68 +59773,68 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2106 + /* "PyCafe.pyx":2105 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), _error_code=status, * _error_text=self.cs.code(status), _error_info=self.cs.info(status)) */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2106, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2106, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2106, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2106, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2105, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2105, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2106, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2105, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2107 + /* "PyCafe.pyx":2106 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), _error_code=status, # <<<<<<<<<<<<<< * _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2107, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2106, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2106, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2105, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2107, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2106, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2106, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2105, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2108 + /* "PyCafe.pyx":2107 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), _error_code=status, * _error_text=self.cs.code(status), _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * return None */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2108, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2106, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2105, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2108, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2106, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2105, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2105 + /* "PyCafe.pyx":2104 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), _error_code=status, */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2105, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2104, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2109 + /* "PyCafe.pyx":2108 * _pv_name=self._c_cafe.getPVFromHandle(handle), _error_code=status, * _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -59394,9 +59842,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 2109, __pyx_L1_error) + __PYX_ERR(3, 2108, __pyx_L1_error) - /* "PyCafe.pyx":2104 + /* "PyCafe.pyx":2103 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -59405,7 +59853,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2110 + /* "PyCafe.pyx":2109 * _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException * return None # <<<<<<<<<<<<<< @@ -59416,7 +59864,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":2098 + /* "PyCafe.pyx":2097 * status = self.hh.getDataTypeNative(handle, dtr) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -59426,7 +59874,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L3; } - /* "PyCafe.pyx":2112 + /* "PyCafe.pyx":2111 * return None * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -59445,7 +59893,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_5 = (__pyx_t_2 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2113 + /* "PyCafe.pyx":2112 * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if not self._c_cafe.isChannelConnected(handle): # <<<<<<<<<<<<<< @@ -59455,7 +59903,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_5 = ((!(__pyx_v_self->_c_cafe->isChannelConnected(__pyx_v_handle) != 0)) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2114 + /* "PyCafe.pyx":2113 * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if not self._c_cafe.isChannelConnected(handle): * self._c_cafe.getChannelInfo(handle, self.channelInfo) # <<<<<<<<<<<<<< @@ -59464,7 +59912,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ (void)(__pyx_v_self->_c_cafe->getChannelInfo(__pyx_v_handle, __pyx_v_self->channelInfo)); - /* "PyCafe.pyx":2115 + /* "PyCafe.pyx":2114 * if not self._c_cafe.isChannelConnected(handle): * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -59474,7 +59922,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_5 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2116 + /* "PyCafe.pyx":2115 * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus( # <<<<<<<<<<<<<< @@ -59483,7 +59931,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, __pyx_v_self->channelInfo.getCafeConnectionState()); - /* "PyCafe.pyx":2115 + /* "PyCafe.pyx":2114 * if not self._c_cafe.isChannelConnected(handle): * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -59492,7 +59940,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2118 + /* "PyCafe.pyx":2117 * self._c_cafe.printStatus( * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -59502,84 +59950,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_5 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2120 + /* "PyCafe.pyx":2119 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2120, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2120, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2120, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2120, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2119, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2119, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_handle, __pyx_t_3) < 0) __PYX_ERR(3, 2120, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_handle, __pyx_t_3) < 0) __PYX_ERR(3, 2119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2121 + /* "PyCafe.pyx":2120 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=self.channelInfo.getCafeConnectionState(), * _error_text=self.cs.code( */ - __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2121, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_pv_name, __pyx_t_3) < 0) __PYX_ERR(3, 2120, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_pv_name, __pyx_t_3) < 0) __PYX_ERR(3, 2119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2122 + /* "PyCafe.pyx":2121 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), # <<<<<<<<<<<<<< * _error_text=self.cs.code( * self.channelInfo.getCafeConnectionState()), */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->channelInfo.getCafeConnectionState()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2122, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->channelInfo.getCafeConnectionState()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_code, __pyx_t_3) < 0) __PYX_ERR(3, 2120, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_code, __pyx_t_3) < 0) __PYX_ERR(3, 2119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2123 + /* "PyCafe.pyx":2122 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), * _error_text=self.cs.code( # <<<<<<<<<<<<<< * self.channelInfo.getCafeConnectionState()), * _error_info=self.cs.info( */ - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2123, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_text, __pyx_t_3) < 0) __PYX_ERR(3, 2120, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_text, __pyx_t_3) < 0) __PYX_ERR(3, 2119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2125 + /* "PyCafe.pyx":2124 * _error_text=self.cs.code( * self.channelInfo.getCafeConnectionState()), * _error_info=self.cs.info( # <<<<<<<<<<<<<< * self.channelInfo.getCafeConnectionState())) * raise _cafeException */ - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2125, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_t_3) < 0) __PYX_ERR(3, 2120, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_t_3) < 0) __PYX_ERR(3, 2119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2119 + /* "PyCafe.pyx":2118 * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2119, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2127 + /* "PyCafe.pyx":2126 * _error_info=self.cs.info( * self.channelInfo.getCafeConnectionState())) * raise _cafeException # <<<<<<<<<<<<<< @@ -59587,9 +60035,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * return None */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 2127, __pyx_L1_error) + __PYX_ERR(3, 2126, __pyx_L1_error) - /* "PyCafe.pyx":2118 + /* "PyCafe.pyx":2117 * self._c_cafe.printStatus( * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -59598,7 +60046,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2129 + /* "PyCafe.pyx":2128 * raise _cafeException * * return None # <<<<<<<<<<<<<< @@ -59609,7 +60057,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":2113 + /* "PyCafe.pyx":2112 * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if not self._c_cafe.isChannelConnected(handle): # <<<<<<<<<<<<<< @@ -59618,7 +60066,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2132 + /* "PyCafe.pyx":2131 * * # Likely to be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -59628,7 +60076,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_5 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2133 + /* "PyCafe.pyx":2132 * # Likely to be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) # <<<<<<<<<<<<<< @@ -59637,7 +60085,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, ICAFE_TYPENOTCONN); - /* "PyCafe.pyx":2132 + /* "PyCafe.pyx":2131 * * # Likely to be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -59646,7 +60094,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2134 + /* "PyCafe.pyx":2133 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -59656,84 +60104,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_5 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2136 + /* "PyCafe.pyx":2135 * if self._enable_exceptions: * _cafeException = CafeException( * type='cafe', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2136, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type_3, __pyx_n_u_cafe) < 0) __PYX_ERR(3, 2136, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2136, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2136, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type_3, __pyx_n_u_cafe) < 0) __PYX_ERR(3, 2135, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2135, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2136, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2137 + /* "PyCafe.pyx":2136 * _cafeException = CafeException( * type='cafe', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), */ - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2137, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2136, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2138 + /* "PyCafe.pyx":2137 * type='cafe', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, # <<<<<<<<<<<<<< * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) */ - __pyx_t_4 = __Pyx_PyInt_From_CAFE_CFT_STATE(ICAFE_TYPENOTCONN); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2138, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_CAFE_CFT_STATE(ICAFE_TYPENOTCONN); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2136, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2139 + /* "PyCafe.pyx":2138 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), # <<<<<<<<<<<<<< * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2139, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2136, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2140 + /* "PyCafe.pyx":2139 * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) # <<<<<<<<<<<<<< * raise _cafeException * return None */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2140, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2136, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2135 + /* "PyCafe.pyx":2134 * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * type='cafe', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2135, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2141 + /* "PyCafe.pyx":2140 * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException # <<<<<<<<<<<<<< @@ -59741,9 +60189,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 2141, __pyx_L1_error) + __PYX_ERR(3, 2140, __pyx_L1_error) - /* "PyCafe.pyx":2134 + /* "PyCafe.pyx":2133 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -59752,7 +60200,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2142 + /* "PyCafe.pyx":2141 * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException * return None # <<<<<<<<<<<<<< @@ -59763,7 +60211,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":2112 + /* "PyCafe.pyx":2111 * return None * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -59773,7 +60221,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L3:; - /* "PyCafe.pyx":2145 + /* "PyCafe.pyx":2144 * * * self._c_cafe.getChannelInfo(handle, self.channelInfo) # <<<<<<<<<<<<<< @@ -59782,19 +60230,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ (void)(__pyx_v_self->_c_cafe->getChannelInfo(__pyx_v_handle, __pyx_v_self->channelInfo)); - /* "PyCafe.pyx":2146 + /* "PyCafe.pyx":2145 * * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if str(self.channelInfo.getClassNameAsString()) in ['waveform'] \ # <<<<<<<<<<<<<< * and dtr in [DBR_CHAR] and dt in ['str']: * return self.getWFAsString(handle) */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->channelInfo.getClassNameAsString()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2146, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->channelInfo.getClassNameAsString()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2146, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_n_u_waveform, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2146, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_n_u_waveform, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2145, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = ((__pyx_t_2 != 0) != 0); if (__pyx_t_6) { @@ -59803,7 +60251,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L13_bool_binop_done; } - /* "PyCafe.pyx":2147 + /* "PyCafe.pyx":2146 * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if str(self.channelInfo.getClassNameAsString()) in ['waveform'] \ * and dtr in [DBR_CHAR] and dt in ['str']: # <<<<<<<<<<<<<< @@ -59819,13 +60267,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } __Pyx_INCREF(__pyx_v_dt); __pyx_t_8 = __pyx_v_dt; - __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_8, __pyx_n_u_str, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(3, 2147, __pyx_L1_error) + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_8, __pyx_n_u_str, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(3, 2146, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_2 = ((__pyx_t_6 != 0) != 0); __pyx_t_5 = __pyx_t_2; __pyx_L13_bool_binop_done:; - /* "PyCafe.pyx":2146 + /* "PyCafe.pyx":2145 * * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if str(self.channelInfo.getClassNameAsString()) in ['waveform'] \ # <<<<<<<<<<<<<< @@ -59834,7 +60282,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ if (__pyx_t_5) { - /* "PyCafe.pyx":2148 + /* "PyCafe.pyx":2147 * if str(self.channelInfo.getClassNameAsString()) in ['waveform'] \ * and dtr in [DBR_CHAR] and dt in ['str']: * return self.getWFAsString(handle) # <<<<<<<<<<<<<< @@ -59842,9 +60290,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * cdef int dtcheck = dtr */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getWFAsString); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2148, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getWFAsString); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2148, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -59859,14 +60307,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_10, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2148, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2146 + /* "PyCafe.pyx":2145 * * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if str(self.channelInfo.getClassNameAsString()) in ['waveform'] \ # <<<<<<<<<<<<<< @@ -59875,7 +60323,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2150 + /* "PyCafe.pyx":2149 * return self.getWFAsString(handle) * * cdef int dtcheck = dtr # <<<<<<<<<<<<<< @@ -59884,23 +60332,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_dtcheck = __pyx_v_dtr; - /* "PyCafe.pyx":2151 + /* "PyCafe.pyx":2150 * * cdef int dtcheck = dtr * dtcheck = getMatchedDataType(dt, dtr) # <<<<<<<<<<<<<< * * cdef bytes bVal */ - __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v_dtr); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2151, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v_dtr); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2150, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2151, __pyx_L1_error) + __pyx_t_4 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2150, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2151, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2150, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_dtcheck = __pyx_t_11; - /* "PyCafe.pyx":2155 + /* "PyCafe.pyx":2154 * cdef bytes bVal * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -59910,7 +60358,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":2156 + /* "PyCafe.pyx":2155 * * if dtcheck in [CAFE_STRING]: * with nogil: # <<<<<<<<<<<<<< @@ -59925,7 +60373,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":2157 + /* "PyCafe.pyx":2156 * if dtcheck in [CAFE_STRING]: * with nogil: * status = self._c_cafe.getString(handle, self.valStr) # <<<<<<<<<<<<<< @@ -59935,7 +60383,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->getString(__pyx_v_handle, __pyx_v_self->valStr); } - /* "PyCafe.pyx":2156 + /* "PyCafe.pyx":2155 * * if dtcheck in [CAFE_STRING]: * with nogil: # <<<<<<<<<<<<<< @@ -59954,7 +60402,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":2159 + /* "PyCafe.pyx":2158 * status = self._c_cafe.getString(handle, self.valStr) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -59964,14 +60412,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_5 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2160 + /* "PyCafe.pyx":2159 * * if status == ICAFE_NORMAL: * bVal = self.valStr # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): */ - __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2160, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_t_4; __Pyx_INCREF(__pyx_t_3); @@ -59979,7 +60427,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_bVal = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2161 + /* "PyCafe.pyx":2160 * if status == ICAFE_NORMAL: * bVal = self.valStr * encoding = False # <<<<<<<<<<<<<< @@ -59988,21 +60436,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":2162 + /* "PyCafe.pyx":2161 * bVal = self.valStr * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): # <<<<<<<<<<<<<< * try: * valStr = (bVal).decode('latin-1') */ - __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2162, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2162, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2161, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = (__pyx_t_5 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2163 + /* "PyCafe.pyx":2162 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -60018,7 +60466,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":2164 + /* "PyCafe.pyx":2163 * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: * valStr = (bVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -60027,14 +60475,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 2164, __pyx_L21_error) + __PYX_ERR(3, 2163, __pyx_L21_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2164, __pyx_L21_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2163, __pyx_L21_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_valStr = __pyx_t_3; __pyx_t_3 = 0; - /* "PyCafe.pyx":2165 + /* "PyCafe.pyx":2164 * try: * valStr = (bVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -60043,7 +60491,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":2163 + /* "PyCafe.pyx":2162 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -60062,7 +60510,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":2166 + /* "PyCafe.pyx":2165 * valStr = (bVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -60077,7 +60525,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L23_except_error; __pyx_L23_except_error:; - /* "PyCafe.pyx":2163 + /* "PyCafe.pyx":2162 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -60097,7 +60545,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_L26_try_end:; } - /* "PyCafe.pyx":2162 + /* "PyCafe.pyx":2161 * bVal = self.valStr * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): # <<<<<<<<<<<<<< @@ -60106,7 +60554,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2168 + /* "PyCafe.pyx":2167 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -60116,7 +60564,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2169 + /* "PyCafe.pyx":2168 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -60132,7 +60580,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "PyCafe.pyx":2170 + /* "PyCafe.pyx":2169 * if not encoding: * try: * valStr = (bVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -60141,14 +60589,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 2170, __pyx_L28_error) + __PYX_ERR(3, 2169, __pyx_L28_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2170, __pyx_L28_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2169, __pyx_L28_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_valStr, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2171 + /* "PyCafe.pyx":2170 * try: * valStr = (bVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -60157,7 +60605,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":2169 + /* "PyCafe.pyx":2168 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -60176,7 +60624,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":2172 + /* "PyCafe.pyx":2171 * valStr = (bVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -60191,7 +60639,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L30_except_error; __pyx_L30_except_error:; - /* "PyCafe.pyx":2169 + /* "PyCafe.pyx":2168 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -60211,7 +60659,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_L33_try_end:; } - /* "PyCafe.pyx":2168 + /* "PyCafe.pyx":2167 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -60220,7 +60668,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2174 + /* "PyCafe.pyx":2173 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -60230,7 +60678,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2175 + /* "PyCafe.pyx":2174 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -60246,7 +60694,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":2176 + /* "PyCafe.pyx":2175 * if not encoding: * try: * valStr = (bVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -60255,14 +60703,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 2176, __pyx_L35_error) + __PYX_ERR(3, 2175, __pyx_L35_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2176, __pyx_L35_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2175, __pyx_L35_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_valStr, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2177 + /* "PyCafe.pyx":2176 * try: * valStr = (bVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -60271,7 +60719,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":2175 + /* "PyCafe.pyx":2174 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -60290,7 +60738,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":2178 + /* "PyCafe.pyx":2177 * valStr = (bVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -60305,7 +60753,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37_except_error; __pyx_L37_except_error:; - /* "PyCafe.pyx":2175 + /* "PyCafe.pyx":2174 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -60325,7 +60773,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_L40_try_end:; } - /* "PyCafe.pyx":2174 + /* "PyCafe.pyx":2173 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -60334,7 +60782,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2180 + /* "PyCafe.pyx":2179 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -60344,7 +60792,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2181 + /* "PyCafe.pyx":2180 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -60360,7 +60808,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "PyCafe.pyx":2182 + /* "PyCafe.pyx":2181 * if not encoding: * try: * valStr = (bVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -60369,14 +60817,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 2182, __pyx_L42_error) + __PYX_ERR(3, 2181, __pyx_L42_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2182, __pyx_L42_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2181, __pyx_L42_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_valStr, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2183 + /* "PyCafe.pyx":2182 * try: * valStr = (bVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -60385,7 +60833,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":2181 + /* "PyCafe.pyx":2180 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -60404,7 +60852,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":2184 + /* "PyCafe.pyx":2183 * valStr = (bVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -60419,7 +60867,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L44_except_error; __pyx_L44_except_error:; - /* "PyCafe.pyx":2181 + /* "PyCafe.pyx":2180 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -60439,7 +60887,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_L47_try_end:; } - /* "PyCafe.pyx":2180 + /* "PyCafe.pyx":2179 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -60448,7 +60896,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2186 + /* "PyCafe.pyx":2185 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -60458,7 +60906,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2187 + /* "PyCafe.pyx":2186 * pass * if not encoding: * valstr =self.valStr # <<<<<<<<<<<<<< @@ -60468,7 +60916,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_15 = __pyx_v_self->valStr; __pyx_v_valstr = __pyx_t_15; - /* "PyCafe.pyx":2186 + /* "PyCafe.pyx":2185 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -60477,7 +60925,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2188 + /* "PyCafe.pyx":2187 * if not encoding: * valstr =self.valStr * return valStr # <<<<<<<<<<<<<< @@ -60485,12 +60933,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: */ __Pyx_XDECREF(__pyx_r); - if (unlikely(!__pyx_v_valStr)) { __Pyx_RaiseUnboundLocalError("valStr"); __PYX_ERR(3, 2188, __pyx_L1_error) } + if (unlikely(!__pyx_v_valStr)) { __Pyx_RaiseUnboundLocalError("valStr"); __PYX_ERR(3, 2187, __pyx_L1_error) } __Pyx_INCREF(__pyx_v_valStr); __pyx_r = __pyx_v_valStr; goto __pyx_L0; - /* "PyCafe.pyx":2159 + /* "PyCafe.pyx":2158 * status = self._c_cafe.getString(handle, self.valStr) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60499,7 +60947,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2155 + /* "PyCafe.pyx":2154 * cdef bytes bVal * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -60509,7 +60957,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe break; case CAFE_SHORT: - /* "PyCafe.pyx":2190 + /* "PyCafe.pyx":2189 * return valStr * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -60519,7 +60967,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe case CAFE_CHAR: case CAFE_LONG: - /* "PyCafe.pyx":2191 + /* "PyCafe.pyx":2190 * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: * with nogil: # <<<<<<<<<<<<<< @@ -60534,7 +60982,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":2192 + /* "PyCafe.pyx":2191 * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: * with nogil: * status = self._c_cafe.getLong(handle, self.valInt) # <<<<<<<<<<<<<< @@ -60544,7 +60992,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->getLong(__pyx_v_handle, __pyx_v_self->valInt); } - /* "PyCafe.pyx":2191 + /* "PyCafe.pyx":2190 * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: * with nogil: # <<<<<<<<<<<<<< @@ -60563,7 +61011,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":2193 + /* "PyCafe.pyx":2192 * with nogil: * status = self._c_cafe.getLong(handle, self.valInt) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60573,7 +61021,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2194 + /* "PyCafe.pyx":2193 * status = self._c_cafe.getLong(handle, self.valInt) * if status == ICAFE_NORMAL: * return self.valInt # <<<<<<<<<<<<<< @@ -60581,13 +61029,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * with nogil: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyInt_From_dbr_long_t(__pyx_v_self->valInt); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2194, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_dbr_long_t(__pyx_v_self->valInt); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2193 + /* "PyCafe.pyx":2192 * with nogil: * status = self._c_cafe.getLong(handle, self.valInt) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60596,7 +61044,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2190 + /* "PyCafe.pyx":2189 * return valStr * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -60606,7 +61054,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe break; case CAFE_FLOAT: - /* "PyCafe.pyx":2195 + /* "PyCafe.pyx":2194 * if status == ICAFE_NORMAL: * return self.valInt * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -60615,7 +61063,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ case CAFE_DOUBLE: - /* "PyCafe.pyx":2196 + /* "PyCafe.pyx":2195 * return self.valInt * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: * with nogil: # <<<<<<<<<<<<<< @@ -60630,7 +61078,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":2197 + /* "PyCafe.pyx":2196 * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: * with nogil: * status = self._c_cafe.getDouble(handle, self.valFloat) # <<<<<<<<<<<<<< @@ -60640,7 +61088,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->getDouble(__pyx_v_handle, __pyx_v_self->valFloat); } - /* "PyCafe.pyx":2196 + /* "PyCafe.pyx":2195 * return self.valInt * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: * with nogil: # <<<<<<<<<<<<<< @@ -60659,7 +61107,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":2199 + /* "PyCafe.pyx":2198 * status = self._c_cafe.getDouble(handle, self.valFloat) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60669,7 +61117,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2200 + /* "PyCafe.pyx":2199 * * if status == ICAFE_NORMAL: * return self.valFloat # <<<<<<<<<<<<<< @@ -60677,13 +61125,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * # if enum, string taken as native */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_self->valFloat); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2200, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_self->valFloat); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2199 + /* "PyCafe.pyx":2198 * status = self._c_cafe.getDouble(handle, self.valFloat) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60692,7 +61140,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2195 + /* "PyCafe.pyx":2194 * if status == ICAFE_NORMAL: * return self.valInt * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -60702,7 +61150,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe break; case CAFE_ENUM: - /* "PyCafe.pyx":2203 + /* "PyCafe.pyx":2202 * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native * if self._c_cafe.isEnum(handle): # <<<<<<<<<<<<<< @@ -60712,7 +61160,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_v_self->_c_cafe->isEnum(__pyx_v_handle) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2204 + /* "PyCafe.pyx":2203 * # if enum, string taken as native * if self._c_cafe.isEnum(handle): * with nogil: # <<<<<<<<<<<<<< @@ -60727,7 +61175,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":2205 + /* "PyCafe.pyx":2204 * if self._c_cafe.isEnum(handle): * with nogil: * status = self._c_cafe.getString(handle, self.valStr) # <<<<<<<<<<<<<< @@ -60737,7 +61185,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->getString(__pyx_v_handle, __pyx_v_self->valStr); } - /* "PyCafe.pyx":2204 + /* "PyCafe.pyx":2203 * # if enum, string taken as native * if self._c_cafe.isEnum(handle): * with nogil: # <<<<<<<<<<<<<< @@ -60756,7 +61204,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":2206 + /* "PyCafe.pyx":2205 * with nogil: * status = self._c_cafe.getString(handle, self.valStr) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60766,7 +61214,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2207 + /* "PyCafe.pyx":2206 * status = self._c_cafe.getString(handle, self.valStr) * if status == ICAFE_NORMAL: * return self.valStr # <<<<<<<<<<<<<< @@ -60774,13 +61222,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * with nogil: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2207, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2206 + /* "PyCafe.pyx":2205 * with nogil: * status = self._c_cafe.getString(handle, self.valStr) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60789,7 +61237,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2203 + /* "PyCafe.pyx":2202 * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native * if self._c_cafe.isEnum(handle): # <<<<<<<<<<<<<< @@ -60799,7 +61247,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L57; } - /* "PyCafe.pyx":2209 + /* "PyCafe.pyx":2208 * return self.valStr * else: * with nogil: # <<<<<<<<<<<<<< @@ -60815,7 +61263,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":2210 + /* "PyCafe.pyx":2209 * else: * with nogil: * status = self._c_cafe.getLong(handle, self.valInt) # <<<<<<<<<<<<<< @@ -60825,7 +61273,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->getLong(__pyx_v_handle, __pyx_v_self->valInt); } - /* "PyCafe.pyx":2209 + /* "PyCafe.pyx":2208 * return self.valStr * else: * with nogil: # <<<<<<<<<<<<<< @@ -60844,7 +61292,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":2211 + /* "PyCafe.pyx":2210 * with nogil: * status = self._c_cafe.getLong(handle, self.valInt) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60854,7 +61302,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2212 + /* "PyCafe.pyx":2211 * status = self._c_cafe.getLong(handle, self.valInt) * if status == ICAFE_NORMAL: * return self.valInt # <<<<<<<<<<<<<< @@ -60862,13 +61310,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * print("This line in PyCafe def get should never appear!") */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyInt_From_dbr_long_t(__pyx_v_self->valInt); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2212, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_dbr_long_t(__pyx_v_self->valInt); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2211 + /* "PyCafe.pyx":2210 * with nogil: * status = self._c_cafe.getLong(handle, self.valInt) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60879,7 +61327,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L57:; - /* "PyCafe.pyx":2201 + /* "PyCafe.pyx":2200 * if status == ICAFE_NORMAL: * return self.valFloat * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -60889,18 +61337,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe break; default: - /* "PyCafe.pyx":2214 + /* "PyCafe.pyx":2213 * return self.valInt * else: * print("This line in PyCafe def get should never appear!") # <<<<<<<<<<<<<< * return None * */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2214, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2215 + /* "PyCafe.pyx":2214 * else: * print("This line in PyCafe def get should never appear!") * return None # <<<<<<<<<<<<<< @@ -60913,7 +61361,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe break; } - /* "PyCafe.pyx":2217 + /* "PyCafe.pyx":2216 * return None * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -60923,7 +61371,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2218 + /* "PyCafe.pyx":2217 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -60933,7 +61381,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2219 + /* "PyCafe.pyx":2218 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -60943,7 +61391,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2220 + /* "PyCafe.pyx":2219 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -60952,7 +61400,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":2219 + /* "PyCafe.pyx":2218 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -60962,7 +61410,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L68; } - /* "PyCafe.pyx":2222 + /* "PyCafe.pyx":2221 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -60974,7 +61422,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L68:; - /* "PyCafe.pyx":2218 + /* "PyCafe.pyx":2217 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -60983,7 +61431,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2223 + /* "PyCafe.pyx":2222 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -60993,76 +61441,76 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2225 + /* "PyCafe.pyx":2224 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2225, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2225, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2225, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2225, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2224, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2224, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2225, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2226 + /* "PyCafe.pyx":2225 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2226, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2225, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2227 + /* "PyCafe.pyx":2226 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2227, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2225, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2227, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2225, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2228 + /* "PyCafe.pyx":2227 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * return None */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2228, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2225, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2224 + /* "PyCafe.pyx":2223 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2224, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2229 + /* "PyCafe.pyx":2228 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -61070,9 +61518,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 2229, __pyx_L1_error) + __PYX_ERR(3, 2228, __pyx_L1_error) - /* "PyCafe.pyx":2223 + /* "PyCafe.pyx":2222 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -61081,7 +61529,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2230 + /* "PyCafe.pyx":2229 * _error_info=self.cs.info(status)) * raise _cafeException * return None # <<<<<<<<<<<<<< @@ -61092,7 +61540,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":2217 + /* "PyCafe.pyx":2216 * return None * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -61101,7 +61549,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":2089 + /* "PyCafe.pyx":2088 * ############################################################################ * @verify_handlepv * def get(self, handlePV = 0, str dt='native'): # <<<<<<<<<<<<<< @@ -61130,7 +61578,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_242get(struct __pyx_obj_6PyCafe_CyCafe return __pyx_r; } -/* "PyCafe.pyx":2237 +/* "PyCafe.pyx":2236 * * ############################################################################ * def getIntList(self, handlePV): # <<<<<<<<<<<<<< @@ -61161,7 +61609,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_244getIntList(struct __pyx_obj_6PyCafe PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getIntList", 0); - /* "PyCafe.pyx":2238 + /* "PyCafe.pyx":2237 * ############################################################################ * def getIntList(self, handlePV): * return self.getList(handlePV, 'int') # <<<<<<<<<<<<<< @@ -61169,7 +61617,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_244getIntList(struct __pyx_obj_6PyCafe * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getList); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2238, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getList); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -61186,7 +61634,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_244getIntList(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2238, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2237, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -61194,13 +61642,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_244getIntList(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2238, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2237, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2238, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -61211,7 +61659,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_244getIntList(struct __pyx_obj_6PyCafe __Pyx_INCREF(__pyx_n_u_int); __Pyx_GIVEREF(__pyx_n_u_int); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_int); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2238, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -61220,7 +61668,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_244getIntList(struct __pyx_obj_6PyCafe __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2237 + /* "PyCafe.pyx":2236 * * ############################################################################ * def getIntList(self, handlePV): # <<<<<<<<<<<<<< @@ -61244,7 +61692,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_244getIntList(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":2241 +/* "PyCafe.pyx":2240 * * ############################################################################ * def getFloatList(self, handlePV): # <<<<<<<<<<<<<< @@ -61275,7 +61723,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_246getFloatList(struct __pyx_obj_6PyCa PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getFloatList", 0); - /* "PyCafe.pyx":2242 + /* "PyCafe.pyx":2241 * ############################################################################ * def getFloatList(self, handlePV): * return self.getList(handlePV, 'float') # <<<<<<<<<<<<<< @@ -61283,7 +61731,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_246getFloatList(struct __pyx_obj_6PyCa * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getList); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2242, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getList); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -61300,7 +61748,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_246getFloatList(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2242, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2241, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -61308,13 +61756,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_246getFloatList(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2242, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2241, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2242, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -61325,7 +61773,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_246getFloatList(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_n_u_float); __Pyx_GIVEREF(__pyx_n_u_float); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_float); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2242, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -61334,7 +61782,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_246getFloatList(struct __pyx_obj_6PyCa __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2241 + /* "PyCafe.pyx":2240 * * ############################################################################ * def getFloatList(self, handlePV): # <<<<<<<<<<<<<< @@ -61358,7 +61806,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_246getFloatList(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":2245 +/* "PyCafe.pyx":2244 * * ############################################################################ * def getStrList(self, handlePV): # <<<<<<<<<<<<<< @@ -61389,7 +61837,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_248getStrList(struct __pyx_obj_6PyCafe PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getStrList", 0); - /* "PyCafe.pyx":2246 + /* "PyCafe.pyx":2245 * ############################################################################ * def getStrList(self, handlePV): * return self.getList(handlePV, 'str') # <<<<<<<<<<<<<< @@ -61397,7 +61845,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_248getStrList(struct __pyx_obj_6PyCafe * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getList); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2246, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getList); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -61414,7 +61862,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_248getStrList(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2246, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2245, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -61422,13 +61870,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_248getStrList(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2246, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2245, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2246, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 2245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -61439,7 +61887,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_248getStrList(struct __pyx_obj_6PyCafe __Pyx_INCREF(__pyx_n_u_str); __Pyx_GIVEREF(__pyx_n_u_str); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_str); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2246, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -61448,7 +61896,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_248getStrList(struct __pyx_obj_6PyCafe __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2245 + /* "PyCafe.pyx":2244 * * ############################################################################ * def getStrList(self, handlePV): # <<<<<<<<<<<<<< @@ -61472,7 +61920,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_248getStrList(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":2250 +/* "PyCafe.pyx":2249 * ############################################################################ * @verify_handlepv * def getList(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -61516,7 +61964,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_251getList(PyObject *__pyx_v_self, PyO } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getList") < 0)) __PYX_ERR(3, 2250, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getList") < 0)) __PYX_ERR(3, 2249, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -61532,13 +61980,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_251getList(PyObject *__pyx_v_self, PyO } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getList", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2250, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getList", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2249, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getList", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 2250, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 2249, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_250getList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_dt); /* function exit code */ @@ -61589,7 +62037,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy int __pyx_t_12; __Pyx_RefNannySetupContext("getList", 0); - /* "PyCafe.pyx":2251 + /* "PyCafe.pyx":2250 * @verify_handlepv * def getList(self, handlePV, str dt='native'): * cdef str _METHOD = "getList" # <<<<<<<<<<<<<< @@ -61599,17 +62047,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __Pyx_INCREF(__pyx_n_u_getList); __pyx_v__METHOD = __pyx_n_u_getList; - /* "PyCafe.pyx":2252 + /* "PyCafe.pyx":2251 * def getList(self, handlePV, str dt='native'): * cdef str _METHOD = "getList" * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * * cdef int status */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2252, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2251, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":2255 + /* "PyCafe.pyx":2254 * * cdef int status * cdef long dtr = 0 # <<<<<<<<<<<<<< @@ -61618,7 +62066,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_dtr = 0; - /* "PyCafe.pyx":2257 + /* "PyCafe.pyx":2256 * cdef long dtr = 0 * * status = self.hh.getDataTypeNative(handle, dtr) # <<<<<<<<<<<<<< @@ -61627,7 +62075,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_status = __pyx_v_self->hh.getDataTypeNative(__pyx_v_handle, __pyx_v_dtr); - /* "PyCafe.pyx":2259 + /* "PyCafe.pyx":2258 * status = self.hh.getDataTypeNative(handle, dtr) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -61637,7 +62085,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2260 + /* "PyCafe.pyx":2259 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -61647,7 +62095,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2261 + /* "PyCafe.pyx":2260 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -61657,7 +62105,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2262 + /* "PyCafe.pyx":2261 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -61666,7 +62114,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":2261 + /* "PyCafe.pyx":2260 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -61676,7 +62124,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy goto __pyx_L5; } - /* "PyCafe.pyx":2264 + /* "PyCafe.pyx":2263 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -61688,7 +62136,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } __pyx_L5:; - /* "PyCafe.pyx":2260 + /* "PyCafe.pyx":2259 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -61697,7 +62145,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2265 + /* "PyCafe.pyx":2264 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -61707,84 +62155,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2267 + /* "PyCafe.pyx":2266 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2267, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2267, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2267, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2266, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2266, __pyx_L1_error) - /* "PyCafe.pyx":2268 + /* "PyCafe.pyx":2267 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, * _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2268, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2267, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2266, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2269 + /* "PyCafe.pyx":2268 * _type='CafeError', _source=_METHOD, * _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2269, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2267, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2266, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2270 + /* "PyCafe.pyx":2269 * _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2270, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2267, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2266, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2270, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2267, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2266, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2271 + /* "PyCafe.pyx":2270 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2271, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2267, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2266, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2266 + /* "PyCafe.pyx":2265 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _handle=handle, */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2266, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2272 + /* "PyCafe.pyx":2271 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -61792,9 +62240,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy * return [None] */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 2272, __pyx_L1_error) + __PYX_ERR(3, 2271, __pyx_L1_error) - /* "PyCafe.pyx":2265 + /* "PyCafe.pyx":2264 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -61803,7 +62251,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2274 + /* "PyCafe.pyx":2273 * raise _cafeException * * return [None] # <<<<<<<<<<<<<< @@ -61811,7 +62259,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2274, __pyx_L1_error) + __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); @@ -61820,7 +62268,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2259 + /* "PyCafe.pyx":2258 * status = self.hh.getDataTypeNative(handle, dtr) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -61830,7 +62278,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy goto __pyx_L3; } - /* "PyCafe.pyx":2276 + /* "PyCafe.pyx":2275 * return [None] * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -61849,7 +62297,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_5 = (__pyx_t_2 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2277 + /* "PyCafe.pyx":2276 * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if not self._c_cafe.isChannelConnected(handle): # <<<<<<<<<<<<<< @@ -61859,7 +62307,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_5 = ((!(__pyx_v_self->_c_cafe->isChannelConnected(__pyx_v_handle) != 0)) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2278 + /* "PyCafe.pyx":2277 * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if not self._c_cafe.isChannelConnected(handle): * self._c_cafe.getChannelInfo(handle, self.channelInfo) # <<<<<<<<<<<<<< @@ -61868,7 +62316,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ (void)(__pyx_v_self->_c_cafe->getChannelInfo(__pyx_v_handle, __pyx_v_self->channelInfo)); - /* "PyCafe.pyx":2279 + /* "PyCafe.pyx":2278 * if not self._c_cafe.isChannelConnected(handle): * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -61878,7 +62326,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_5 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2280 + /* "PyCafe.pyx":2279 * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus( # <<<<<<<<<<<<<< @@ -61887,7 +62335,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, __pyx_v_self->channelInfo.getCafeConnectionState()); - /* "PyCafe.pyx":2279 + /* "PyCafe.pyx":2278 * if not self._c_cafe.isChannelConnected(handle): * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -61896,7 +62344,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2282 + /* "PyCafe.pyx":2281 * self._c_cafe.printStatus( * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -61906,84 +62354,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_5 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2284 + /* "PyCafe.pyx":2283 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2284, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2283, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2284, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2284, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2284, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2283, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2283, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2283, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_handle, __pyx_t_3) < 0) __PYX_ERR(3, 2284, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_handle, __pyx_t_3) < 0) __PYX_ERR(3, 2283, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2285 + /* "PyCafe.pyx":2284 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=self.channelInfo.getCafeConnectionState(), * _error_text=self.cs.code( */ - __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2285, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_pv_name, __pyx_t_3) < 0) __PYX_ERR(3, 2284, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_pv_name, __pyx_t_3) < 0) __PYX_ERR(3, 2283, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2286 + /* "PyCafe.pyx":2285 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), # <<<<<<<<<<<<<< * _error_text=self.cs.code( * self.channelInfo.getCafeConnectionState()), */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->channelInfo.getCafeConnectionState()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2286, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->channelInfo.getCafeConnectionState()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_code, __pyx_t_3) < 0) __PYX_ERR(3, 2284, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_code, __pyx_t_3) < 0) __PYX_ERR(3, 2283, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2287 + /* "PyCafe.pyx":2286 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), * _error_text=self.cs.code( # <<<<<<<<<<<<<< * self.channelInfo.getCafeConnectionState()), * _error_info=self.cs.info( */ - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2287, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_text, __pyx_t_3) < 0) __PYX_ERR(3, 2284, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_text, __pyx_t_3) < 0) __PYX_ERR(3, 2283, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2289 + /* "PyCafe.pyx":2288 * _error_text=self.cs.code( * self.channelInfo.getCafeConnectionState()), * _error_info=self.cs.info( # <<<<<<<<<<<<<< * self.channelInfo.getCafeConnectionState())) * raise _cafeException */ - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2289, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_t_3) < 0) __PYX_ERR(3, 2284, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_t_3) < 0) __PYX_ERR(3, 2283, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2283 + /* "PyCafe.pyx":2282 * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2283, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2291 + /* "PyCafe.pyx":2290 * _error_info=self.cs.info( * self.channelInfo.getCafeConnectionState())) * raise _cafeException # <<<<<<<<<<<<<< @@ -61991,9 +62439,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 2291, __pyx_L1_error) + __PYX_ERR(3, 2290, __pyx_L1_error) - /* "PyCafe.pyx":2282 + /* "PyCafe.pyx":2281 * self._c_cafe.printStatus( * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -62002,7 +62450,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2292 + /* "PyCafe.pyx":2291 * self.channelInfo.getCafeConnectionState())) * raise _cafeException * return [None] # <<<<<<<<<<<<<< @@ -62010,7 +62458,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy * # This paragraph should be superfluous */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2292, __pyx_L1_error) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); @@ -62019,7 +62467,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2277 + /* "PyCafe.pyx":2276 * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if not self._c_cafe.isChannelConnected(handle): # <<<<<<<<<<<<<< @@ -62028,7 +62476,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2295 + /* "PyCafe.pyx":2294 * * # This paragraph should be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -62038,7 +62486,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_5 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2296 + /* "PyCafe.pyx":2295 * # This paragraph should be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) # <<<<<<<<<<<<<< @@ -62047,7 +62495,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, ICAFE_TYPENOTCONN); - /* "PyCafe.pyx":2295 + /* "PyCafe.pyx":2294 * * # This paragraph should be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -62056,7 +62504,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2297 + /* "PyCafe.pyx":2296 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -62066,84 +62514,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_5 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2299 + /* "PyCafe.pyx":2298 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD,_handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2299, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2299, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2299, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2299, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2298, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2298, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2299, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_handle, __pyx_t_4) < 0) __PYX_ERR(3, 2298, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2300 + /* "PyCafe.pyx":2299 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD,_handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), */ - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2300, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2299, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_pv_name, __pyx_t_4) < 0) __PYX_ERR(3, 2298, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2301 + /* "PyCafe.pyx":2300 * _type='CafeError', _source=_METHOD,_handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, # <<<<<<<<<<<<<< * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) */ - __pyx_t_4 = __Pyx_PyInt_From_CAFE_CFT_STATE(ICAFE_TYPENOTCONN); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2301, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_CAFE_CFT_STATE(ICAFE_TYPENOTCONN); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2299, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_code, __pyx_t_4) < 0) __PYX_ERR(3, 2298, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2302 + /* "PyCafe.pyx":2301 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), # <<<<<<<<<<<<<< * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2302, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2299, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_text, __pyx_t_4) < 0) __PYX_ERR(3, 2298, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2303 + /* "PyCafe.pyx":2302 * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) # <<<<<<<<<<<<<< * raise _cafeException * return [None] */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2303, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2299, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_t_4) < 0) __PYX_ERR(3, 2298, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2298 + /* "PyCafe.pyx":2297 * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD,_handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2298, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2304 + /* "PyCafe.pyx":2303 * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException # <<<<<<<<<<<<<< @@ -62151,9 +62599,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 2304, __pyx_L1_error) + __PYX_ERR(3, 2303, __pyx_L1_error) - /* "PyCafe.pyx":2297 + /* "PyCafe.pyx":2296 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -62162,7 +62610,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2305 + /* "PyCafe.pyx":2304 * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException * return [None] # <<<<<<<<<<<<<< @@ -62170,7 +62618,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy * #JC FEB 2022 must be int as CAFE_TYPENOTCONN is -1 */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2305, __pyx_L1_error) + __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); @@ -62179,7 +62627,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2276 + /* "PyCafe.pyx":2275 * return [None] * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -62189,7 +62637,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } __pyx_L3:; - /* "PyCafe.pyx":2308 + /* "PyCafe.pyx":2307 * * #JC FEB 2022 must be int as CAFE_TYPENOTCONN is -1 * cdef int dtcheck = dtr # <<<<<<<<<<<<<< @@ -62198,23 +62646,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_dtcheck = __pyx_v_dtr; - /* "PyCafe.pyx":2309 + /* "PyCafe.pyx":2308 * #JC FEB 2022 must be int as CAFE_TYPENOTCONN is -1 * cdef int dtcheck = dtr * dtcheck = getMatchedDataType(dt, dtr) # <<<<<<<<<<<<<< * * #print ("dtcheck input/native", dtcheck, dt, dtr) */ - __pyx_t_4 = __Pyx_PyInt_From_long(__pyx_v_dtr); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2309, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_long(__pyx_v_dtr); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2309, __pyx_L1_error) + __pyx_t_3 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2309, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2308, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_dtcheck = __pyx_t_6; - /* "PyCafe.pyx":2313 + /* "PyCafe.pyx":2312 * #print ("dtcheck input/native", dtcheck, dt, dtr) * * cdef unsigned int nelemNative = self.hh.getNelemNative(handle) # <<<<<<<<<<<<<< @@ -62223,7 +62671,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_nelemNative = __pyx_v_self->hh.getNelemNative(__pyx_v_handle); - /* "PyCafe.pyx":2314 + /* "PyCafe.pyx":2313 * * cdef unsigned int nelemNative = self.hh.getNelemNative(handle) * cdef unsigned int nelemClient = self.hh.getNelemClient(handle) # <<<<<<<<<<<<<< @@ -62232,7 +62680,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_nelemClient = __pyx_v_self->hh.getNelemClient(__pyx_v_handle); - /* "PyCafe.pyx":2315 + /* "PyCafe.pyx":2314 * cdef unsigned int nelemNative = self.hh.getNelemNative(handle) * cdef unsigned int nelemClient = self.hh.getNelemClient(handle) * cdef unsigned int nelemRequest = self.hh.getNelemRequest(handle) # <<<<<<<<<<<<<< @@ -62241,7 +62689,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_nelemRequest = __pyx_v_self->hh.getNelemRequest(__pyx_v_handle); - /* "PyCafe.pyx":2317 + /* "PyCafe.pyx":2316 * cdef unsigned int nelemRequest = self.hh.getNelemRequest(handle) * * cdef unsigned int nelemMethod = nelemClient # <<<<<<<<<<<<<< @@ -62250,7 +62698,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_nelemMethod = __pyx_v_nelemClient; - /* "PyCafe.pyx":2331 + /* "PyCafe.pyx":2330 * cdef bytes bytesVal * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -62260,7 +62708,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":2333 + /* "PyCafe.pyx":2332 * if dtcheck in [CAFE_STRING]: * * valStringArray = malloc( # <<<<<<<<<<<<<< @@ -62269,7 +62717,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_valStringArray = ((char (*)[40])malloc((__pyx_v_nelemMethod * (sizeof(dbr_string_t))))); - /* "PyCafe.pyx":2336 + /* "PyCafe.pyx":2335 * nelemMethod * sizeof(dbr_string_t)) * * with nogil: # <<<<<<<<<<<<<< @@ -62284,7 +62732,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":2337 + /* "PyCafe.pyx":2336 * * with nogil: * status = self._c_cafe.getDbrStringArray(handle, valStringArray) # <<<<<<<<<<<<<< @@ -62294,7 +62742,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getDbrStringArray(__pyx_v_handle, __pyx_v_valStringArray); } - /* "PyCafe.pyx":2336 + /* "PyCafe.pyx":2335 * nelemMethod * sizeof(dbr_string_t)) * * with nogil: # <<<<<<<<<<<<<< @@ -62313,19 +62761,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":2339 + /* "PyCafe.pyx":2338 * status = self._c_cafe.getDbrStringArray(handle, valStringArray) * * ll = [] # <<<<<<<<<<<<<< * for i in range(0, nelemMethod): * */ - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2339, __pyx_L1_error) + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_ll = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2340 + /* "PyCafe.pyx":2339 * * ll = [] * for i in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -62337,14 +62785,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":2342 + /* "PyCafe.pyx":2341 * for i in range(0, nelemMethod): * * bytesVal = ( valStringArray[i]) # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): */ - __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_valStringArray[__pyx_v_i]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2342, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_valStringArray[__pyx_v_i]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4); @@ -62352,7 +62800,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; - /* "PyCafe.pyx":2343 + /* "PyCafe.pyx":2342 * * bytesVal = ( valStringArray[i]) * encoding = False # <<<<<<<<<<<<<< @@ -62361,21 +62809,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":2344 + /* "PyCafe.pyx":2343 * bytesVal = ( valStringArray[i]) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2344, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2344, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2343, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = (__pyx_t_5 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2345 + /* "PyCafe.pyx":2344 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -62391,7 +62839,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { - /* "PyCafe.pyx":2346 + /* "PyCafe.pyx":2345 * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -62400,14 +62848,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 2346, __pyx_L18_error) + __PYX_ERR(3, 2345, __pyx_L18_error) } - __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2346, __pyx_L18_error) + __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2345, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2347 + /* "PyCafe.pyx":2346 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -62416,7 +62864,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":2345 + /* "PyCafe.pyx":2344 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -62432,7 +62880,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2348 + /* "PyCafe.pyx":2347 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -62447,7 +62895,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy goto __pyx_L20_except_error; __pyx_L20_except_error:; - /* "PyCafe.pyx":2345 + /* "PyCafe.pyx":2344 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -62467,7 +62915,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_L25_try_end:; } - /* "PyCafe.pyx":2344 + /* "PyCafe.pyx":2343 * bytesVal = ( valStringArray[i]) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): # <<<<<<<<<<<<<< @@ -62476,7 +62924,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2350 + /* "PyCafe.pyx":2349 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -62486,7 +62934,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2351 + /* "PyCafe.pyx":2350 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -62502,7 +62950,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __Pyx_XGOTREF(__pyx_t_9); /*try:*/ { - /* "PyCafe.pyx":2352 + /* "PyCafe.pyx":2351 * if not encoding: * try: * strVal = (bytesVal).decode('utf_8') # <<<<<<<<<<<<<< @@ -62511,14 +62959,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 2352, __pyx_L27_error) + __PYX_ERR(3, 2351, __pyx_L27_error) } - __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2352, __pyx_L27_error) + __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2351, __pyx_L27_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2353 + /* "PyCafe.pyx":2352 * try: * strVal = (bytesVal).decode('utf_8') * encoding = True # <<<<<<<<<<<<<< @@ -62527,7 +62975,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":2351 + /* "PyCafe.pyx":2350 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -62543,7 +62991,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2354 + /* "PyCafe.pyx":2353 * strVal = (bytesVal).decode('utf_8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -62558,7 +63006,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy goto __pyx_L29_except_error; __pyx_L29_except_error:; - /* "PyCafe.pyx":2351 + /* "PyCafe.pyx":2350 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -62578,7 +63026,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_L34_try_end:; } - /* "PyCafe.pyx":2350 + /* "PyCafe.pyx":2349 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -62587,7 +63035,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2356 + /* "PyCafe.pyx":2355 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -62597,7 +63045,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2357 + /* "PyCafe.pyx":2356 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -62613,7 +63061,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { - /* "PyCafe.pyx":2358 + /* "PyCafe.pyx":2357 * if not encoding: * try: * strVal = (bytesVal).decode('utf_16') # <<<<<<<<<<<<<< @@ -62622,14 +63070,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 2358, __pyx_L36_error) + __PYX_ERR(3, 2357, __pyx_L36_error) } - __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2358, __pyx_L36_error) + __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2357, __pyx_L36_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2357 + /* "PyCafe.pyx":2356 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -62645,7 +63093,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2359 + /* "PyCafe.pyx":2358 * try: * strVal = (bytesVal).decode('utf_16') * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -62660,7 +63108,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy goto __pyx_L38_except_error; __pyx_L38_except_error:; - /* "PyCafe.pyx":2357 + /* "PyCafe.pyx":2356 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -62680,7 +63128,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_L43_try_end:; } - /* "PyCafe.pyx":2356 + /* "PyCafe.pyx":2355 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -62689,7 +63137,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2361 + /* "PyCafe.pyx":2360 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -62699,19 +63147,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2362 + /* "PyCafe.pyx":2361 * pass * if not encoding: * strVal = valStringArray[i] # <<<<<<<<<<<<<< * * ll.append(strVal) */ - __pyx_t_4 = __Pyx_PyObject_FromString((__pyx_v_valStringArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2362, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_FromString((__pyx_v_valStringArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2361 + /* "PyCafe.pyx":2360 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -62720,18 +63168,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2364 + /* "PyCafe.pyx":2363 * strVal = valStringArray[i] * * ll.append(strVal) # <<<<<<<<<<<<<< * free(valStringArray) * if status == ICAFE_NORMAL: */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 2364, __pyx_L1_error) } - __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_v_strVal); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2364, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 2363, __pyx_L1_error) } + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_v_strVal); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2363, __pyx_L1_error) } - /* "PyCafe.pyx":2365 + /* "PyCafe.pyx":2364 * * ll.append(strVal) * free(valStringArray) # <<<<<<<<<<<<<< @@ -62740,7 +63188,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ free(__pyx_v_valStringArray); - /* "PyCafe.pyx":2366 + /* "PyCafe.pyx":2365 * ll.append(strVal) * free(valStringArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -62750,7 +63198,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2367 + /* "PyCafe.pyx":2366 * free(valStringArray) * if status == ICAFE_NORMAL: * return ll # <<<<<<<<<<<<<< @@ -62762,7 +63210,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = __pyx_v_ll; goto __pyx_L0; - /* "PyCafe.pyx":2366 + /* "PyCafe.pyx":2365 * ll.append(strVal) * free(valStringArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -62771,7 +63219,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2331 + /* "PyCafe.pyx":2330 * cdef bytes bytesVal * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -62781,7 +63229,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy break; case CAFE_CHAR: - /* "PyCafe.pyx":2371 + /* "PyCafe.pyx":2370 * elif dtcheck in [CAFE_CHAR]: * * valCharArray = malloc( # <<<<<<<<<<<<<< @@ -62790,7 +63238,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_valCharArray = ((dbr_char_t *)malloc((__pyx_v_nelemMethod * (sizeof(dbr_char_t))))); - /* "PyCafe.pyx":2374 + /* "PyCafe.pyx":2373 * nelemMethod * sizeof(dbr_char_t)) * * with nogil: # <<<<<<<<<<<<<< @@ -62805,7 +63253,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":2375 + /* "PyCafe.pyx":2374 * * with nogil: * status = self._c_cafe.getCharArray(handle, valCharArray) # <<<<<<<<<<<<<< @@ -62815,7 +63263,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getCharArray(__pyx_v_handle, __pyx_v_valCharArray); } - /* "PyCafe.pyx":2374 + /* "PyCafe.pyx":2373 * nelemMethod * sizeof(dbr_char_t)) * * with nogil: # <<<<<<<<<<<<<< @@ -62834,19 +63282,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":2377 + /* "PyCafe.pyx":2376 * status = self._c_cafe.getCharArray(handle, valCharArray) * * ll = [] # <<<<<<<<<<<<<< * for i in range(0, nelemMethod): * ll.append(valCharArray[i]) */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2377, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_ll = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2378 + /* "PyCafe.pyx":2377 * * ll = [] * for i in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -62858,20 +63306,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":2379 + /* "PyCafe.pyx":2378 * ll = [] * for i in range(0, nelemMethod): * ll.append(valCharArray[i]) # <<<<<<<<<<<<<< * free(valCharArray) * if status == ICAFE_NORMAL: */ - __pyx_t_4 = __Pyx_PyInt_From_dbr_char_t((__pyx_v_valCharArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2379, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_dbr_char_t((__pyx_v_valCharArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2379, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2378, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":2380 + /* "PyCafe.pyx":2379 * for i in range(0, nelemMethod): * ll.append(valCharArray[i]) * free(valCharArray) # <<<<<<<<<<<<<< @@ -62880,7 +63328,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ free(__pyx_v_valCharArray); - /* "PyCafe.pyx":2381 + /* "PyCafe.pyx":2380 * ll.append(valCharArray[i]) * free(valCharArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -62890,7 +63338,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2382 + /* "PyCafe.pyx":2381 * free(valCharArray) * if status == ICAFE_NORMAL: * return ll # <<<<<<<<<<<<<< @@ -62902,7 +63350,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = __pyx_v_ll; goto __pyx_L0; - /* "PyCafe.pyx":2381 + /* "PyCafe.pyx":2380 * ll.append(valCharArray[i]) * free(valCharArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -62911,7 +63359,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2369 + /* "PyCafe.pyx":2368 * return ll * * elif dtcheck in [CAFE_CHAR]: # <<<<<<<<<<<<<< @@ -62921,7 +63369,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy break; case CAFE_LONG: - /* "PyCafe.pyx":2386 + /* "PyCafe.pyx":2385 * elif dtcheck in [CAFE_LONG]: * * valIntArray = malloc( # <<<<<<<<<<<<<< @@ -62930,7 +63378,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_valIntArray = ((dbr_long_t *)malloc((__pyx_v_nelemMethod * (sizeof(dbr_long_t))))); - /* "PyCafe.pyx":2389 + /* "PyCafe.pyx":2388 * nelemMethod * sizeof(dbr_long_t)) * * with nogil: # <<<<<<<<<<<<<< @@ -62945,7 +63393,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":2390 + /* "PyCafe.pyx":2389 * * with nogil: * status = self._c_cafe.getLongArray(handle, valIntArray) # <<<<<<<<<<<<<< @@ -62955,7 +63403,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getLongArray(__pyx_v_handle, __pyx_v_valIntArray); } - /* "PyCafe.pyx":2389 + /* "PyCafe.pyx":2388 * nelemMethod * sizeof(dbr_long_t)) * * with nogil: # <<<<<<<<<<<<<< @@ -62974,19 +63422,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":2392 + /* "PyCafe.pyx":2391 * status = self._c_cafe.getLongArray(handle, valIntArray) * * ll = [] # <<<<<<<<<<<<<< * for i in range(0, nelemMethod): * ll.append(valIntArray[i]) */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2392, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_ll = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2393 + /* "PyCafe.pyx":2392 * * ll = [] * for i in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -62998,20 +63446,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":2394 + /* "PyCafe.pyx":2393 * ll = [] * for i in range(0, nelemMethod): * ll.append(valIntArray[i]) # <<<<<<<<<<<<<< * free(valIntArray) * if status == ICAFE_NORMAL: */ - __pyx_t_4 = __Pyx_PyInt_From_dbr_long_t((__pyx_v_valIntArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2394, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_dbr_long_t((__pyx_v_valIntArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2394, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2393, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":2395 + /* "PyCafe.pyx":2394 * for i in range(0, nelemMethod): * ll.append(valIntArray[i]) * free(valIntArray) # <<<<<<<<<<<<<< @@ -63020,7 +63468,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ free(__pyx_v_valIntArray); - /* "PyCafe.pyx":2396 + /* "PyCafe.pyx":2395 * ll.append(valIntArray[i]) * free(valIntArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63030,7 +63478,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2397 + /* "PyCafe.pyx":2396 * free(valIntArray) * if status == ICAFE_NORMAL: * return ll # <<<<<<<<<<<<<< @@ -63042,7 +63490,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = __pyx_v_ll; goto __pyx_L0; - /* "PyCafe.pyx":2396 + /* "PyCafe.pyx":2395 * ll.append(valIntArray[i]) * free(valIntArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63051,7 +63499,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2384 + /* "PyCafe.pyx":2383 * return ll * * elif dtcheck in [CAFE_LONG]: # <<<<<<<<<<<<<< @@ -63061,7 +63509,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy break; case CAFE_SHORT: - /* "PyCafe.pyx":2401 + /* "PyCafe.pyx":2400 * elif dtcheck in [CAFE_SHORT]: * * valShortArray = malloc(nelemMethod * sizeof(short)) # <<<<<<<<<<<<<< @@ -63070,7 +63518,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_valShortArray = ((short *)malloc((__pyx_v_nelemMethod * (sizeof(short))))); - /* "PyCafe.pyx":2403 + /* "PyCafe.pyx":2402 * valShortArray = malloc(nelemMethod * sizeof(short)) * * with nogil: # <<<<<<<<<<<<<< @@ -63085,7 +63533,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":2404 + /* "PyCafe.pyx":2403 * * with nogil: * status = self._c_cafe.getShortArray(handle, valShortArray) # <<<<<<<<<<<<<< @@ -63095,7 +63543,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getShortArray(__pyx_v_handle, __pyx_v_valShortArray); } - /* "PyCafe.pyx":2403 + /* "PyCafe.pyx":2402 * valShortArray = malloc(nelemMethod * sizeof(short)) * * with nogil: # <<<<<<<<<<<<<< @@ -63114,19 +63562,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":2406 + /* "PyCafe.pyx":2405 * status = self._c_cafe.getShortArray(handle, valShortArray) * * ll = [] # <<<<<<<<<<<<<< * for i in range(0, nelemMethod): * ll.append(valShortArray[i]) */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2406, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_ll = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2407 + /* "PyCafe.pyx":2406 * * ll = [] * for i in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -63138,20 +63586,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":2408 + /* "PyCafe.pyx":2407 * ll = [] * for i in range(0, nelemMethod): * ll.append(valShortArray[i]) # <<<<<<<<<<<<<< * free(valShortArray) * if status == ICAFE_NORMAL: */ - __pyx_t_4 = __Pyx_PyInt_From_short((__pyx_v_valShortArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2408, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_short((__pyx_v_valShortArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2408, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":2409 + /* "PyCafe.pyx":2408 * for i in range(0, nelemMethod): * ll.append(valShortArray[i]) * free(valShortArray) # <<<<<<<<<<<<<< @@ -63160,7 +63608,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ free(__pyx_v_valShortArray); - /* "PyCafe.pyx":2410 + /* "PyCafe.pyx":2409 * ll.append(valShortArray[i]) * free(valShortArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63170,7 +63618,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2411 + /* "PyCafe.pyx":2410 * free(valShortArray) * if status == ICAFE_NORMAL: * return ll # <<<<<<<<<<<<<< @@ -63182,7 +63630,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = __pyx_v_ll; goto __pyx_L0; - /* "PyCafe.pyx":2410 + /* "PyCafe.pyx":2409 * ll.append(valShortArray[i]) * free(valShortArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63191,7 +63639,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2399 + /* "PyCafe.pyx":2398 * return ll * * elif dtcheck in [CAFE_SHORT]: # <<<<<<<<<<<<<< @@ -63201,7 +63649,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy break; case CAFE_FLOAT: - /* "PyCafe.pyx":2425 + /* "PyCafe.pyx":2424 * * # Speedier than vectors * valFloatArray = malloc(nelemMethod * sizeof(float)) # <<<<<<<<<<<<<< @@ -63210,7 +63658,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_valFloatArray = ((float *)malloc((__pyx_v_nelemMethod * (sizeof(float))))); - /* "PyCafe.pyx":2429 + /* "PyCafe.pyx":2428 * # for i in range (0, 10000): * * with nogil: # <<<<<<<<<<<<<< @@ -63225,7 +63673,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":2430 + /* "PyCafe.pyx":2429 * * with nogil: * status = self._c_cafe.getFloatArray(handle, valFloatArray) # <<<<<<<<<<<<<< @@ -63235,7 +63683,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getFloatArray(__pyx_v_handle, __pyx_v_valFloatArray); } - /* "PyCafe.pyx":2429 + /* "PyCafe.pyx":2428 * # for i in range (0, 10000): * * with nogil: # <<<<<<<<<<<<<< @@ -63254,19 +63702,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":2435 + /* "PyCafe.pyx":2434 * #print ("END TIME FLOAT", end - start) * * ll = [] # <<<<<<<<<<<<<< * for i in range(0, nelemMethod): * ll.append(valFloatArray[i]) */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2435, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_ll = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2436 + /* "PyCafe.pyx":2435 * * ll = [] * for i in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -63278,20 +63726,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":2437 + /* "PyCafe.pyx":2436 * ll = [] * for i in range(0, nelemMethod): * ll.append(valFloatArray[i]) # <<<<<<<<<<<<<< * free(valFloatArray) * if status == ICAFE_NORMAL: */ - __pyx_t_4 = PyFloat_FromDouble((__pyx_v_valFloatArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2437, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_valFloatArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2437, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2436, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":2438 + /* "PyCafe.pyx":2437 * for i in range(0, nelemMethod): * ll.append(valFloatArray[i]) * free(valFloatArray) # <<<<<<<<<<<<<< @@ -63300,7 +63748,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ free(__pyx_v_valFloatArray); - /* "PyCafe.pyx":2439 + /* "PyCafe.pyx":2438 * ll.append(valFloatArray[i]) * free(valFloatArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63310,7 +63758,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2440 + /* "PyCafe.pyx":2439 * free(valFloatArray) * if status == ICAFE_NORMAL: * return ll # <<<<<<<<<<<<<< @@ -63322,7 +63770,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = __pyx_v_ll; goto __pyx_L0; - /* "PyCafe.pyx":2439 + /* "PyCafe.pyx":2438 * ll.append(valFloatArray[i]) * free(valFloatArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63331,7 +63779,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2412 + /* "PyCafe.pyx":2411 * if status == ICAFE_NORMAL: * return ll * elif dtcheck in [CAFE_FLOAT]: # <<<<<<<<<<<<<< @@ -63341,7 +63789,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy break; case CAFE_DOUBLE: - /* "PyCafe.pyx":2444 + /* "PyCafe.pyx":2443 * elif dtcheck in [CAFE_DOUBLE]: * * valDoubleArray = malloc(nelemMethod * sizeof(double)) # <<<<<<<<<<<<<< @@ -63350,7 +63798,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_valDoubleArray = ((double *)malloc((__pyx_v_nelemMethod * (sizeof(double))))); - /* "PyCafe.pyx":2446 + /* "PyCafe.pyx":2445 * valDoubleArray = malloc(nelemMethod * sizeof(double)) * * with nogil: # <<<<<<<<<<<<<< @@ -63365,7 +63813,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":2447 + /* "PyCafe.pyx":2446 * * with nogil: * status = self._c_cafe.getDoubleArray(handle, valDoubleArray) # <<<<<<<<<<<<<< @@ -63375,7 +63823,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getDoubleArray(__pyx_v_handle, __pyx_v_valDoubleArray); } - /* "PyCafe.pyx":2446 + /* "PyCafe.pyx":2445 * valDoubleArray = malloc(nelemMethod * sizeof(double)) * * with nogil: # <<<<<<<<<<<<<< @@ -63394,19 +63842,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":2449 + /* "PyCafe.pyx":2448 * status = self._c_cafe.getDoubleArray(handle, valDoubleArray) * * ll = [] # <<<<<<<<<<<<<< * for i in range(0, nelemMethod): * ll.append(valDoubleArray[i]) */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2449, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_ll = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2450 + /* "PyCafe.pyx":2449 * * ll = [] * for i in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -63418,20 +63866,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":2451 + /* "PyCafe.pyx":2450 * ll = [] * for i in range(0, nelemMethod): * ll.append(valDoubleArray[i]) # <<<<<<<<<<<<<< * free(valDoubleArray) * if status == ICAFE_NORMAL: */ - __pyx_t_4 = PyFloat_FromDouble((__pyx_v_valDoubleArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2451, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_valDoubleArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2451, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2450, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":2452 + /* "PyCafe.pyx":2451 * for i in range(0, nelemMethod): * ll.append(valDoubleArray[i]) * free(valDoubleArray) # <<<<<<<<<<<<<< @@ -63440,7 +63888,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ free(__pyx_v_valDoubleArray); - /* "PyCafe.pyx":2453 + /* "PyCafe.pyx":2452 * ll.append(valDoubleArray[i]) * free(valDoubleArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63450,7 +63898,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2454 + /* "PyCafe.pyx":2453 * free(valDoubleArray) * if status == ICAFE_NORMAL: * return ll # <<<<<<<<<<<<<< @@ -63462,7 +63910,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = __pyx_v_ll; goto __pyx_L0; - /* "PyCafe.pyx":2453 + /* "PyCafe.pyx":2452 * ll.append(valDoubleArray[i]) * free(valDoubleArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63471,7 +63919,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2442 + /* "PyCafe.pyx":2441 * return ll * * elif dtcheck in [CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -63481,7 +63929,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy break; case CAFE_ENUM: - /* "PyCafe.pyx":2459 + /* "PyCafe.pyx":2458 * * # if enum, string taken as native * if self._c_cafe.isEnum(handle): # <<<<<<<<<<<<<< @@ -63491,7 +63939,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = (__pyx_v_self->_c_cafe->isEnum(__pyx_v_handle) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2460 + /* "PyCafe.pyx":2459 * # if enum, string taken as native * if self._c_cafe.isEnum(handle): * valStringArray = malloc( # <<<<<<<<<<<<<< @@ -63500,7 +63948,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_valStringArray = ((char (*)[40])malloc((__pyx_v_nelemMethod * (sizeof(dbr_string_t))))); - /* "PyCafe.pyx":2463 + /* "PyCafe.pyx":2462 * nelemMethod * sizeof(dbr_string_t)) * * with nogil: # <<<<<<<<<<<<<< @@ -63515,7 +63963,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":2464 + /* "PyCafe.pyx":2463 * * with nogil: * status = self._c_cafe.getDbrStringArray( # <<<<<<<<<<<<<< @@ -63525,7 +63973,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getDbrStringArray(__pyx_v_handle, __pyx_v_valStringArray); } - /* "PyCafe.pyx":2463 + /* "PyCafe.pyx":2462 * nelemMethod * sizeof(dbr_string_t)) * * with nogil: # <<<<<<<<<<<<<< @@ -63544,19 +63992,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":2467 + /* "PyCafe.pyx":2466 * handle, valStringArray) * * ll = [] # <<<<<<<<<<<<<< * for i in range(0, nelemMethod): * ll.append(valStringArray[i]) */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2467, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_ll = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2468 + /* "PyCafe.pyx":2467 * * ll = [] * for i in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -63568,20 +64016,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":2469 + /* "PyCafe.pyx":2468 * ll = [] * for i in range(0, nelemMethod): * ll.append(valStringArray[i]) # <<<<<<<<<<<<<< * free(valStringArray) * if status == ICAFE_NORMAL: */ - __pyx_t_4 = __Pyx_PyObject_FromString((__pyx_v_valStringArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2469, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_FromString((__pyx_v_valStringArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2468, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2469, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2468, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":2470 + /* "PyCafe.pyx":2469 * for i in range(0, nelemMethod): * ll.append(valStringArray[i]) * free(valStringArray) # <<<<<<<<<<<<<< @@ -63590,7 +64038,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ free(__pyx_v_valStringArray); - /* "PyCafe.pyx":2471 + /* "PyCafe.pyx":2470 * ll.append(valStringArray[i]) * free(valStringArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63600,7 +64048,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2472 + /* "PyCafe.pyx":2471 * free(valStringArray) * if status == ICAFE_NORMAL: * return ll # <<<<<<<<<<<<<< @@ -63612,7 +64060,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = __pyx_v_ll; goto __pyx_L0; - /* "PyCafe.pyx":2471 + /* "PyCafe.pyx":2470 * ll.append(valStringArray[i]) * free(valStringArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63621,7 +64069,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2459 + /* "PyCafe.pyx":2458 * * # if enum, string taken as native * if self._c_cafe.isEnum(handle): # <<<<<<<<<<<<<< @@ -63631,7 +64079,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy goto __pyx_L76; } - /* "PyCafe.pyx":2474 + /* "PyCafe.pyx":2473 * return ll * else: * valUShortArray = malloc( # <<<<<<<<<<<<<< @@ -63640,7 +64088,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ /*else*/ { - /* "PyCafe.pyx":2475 + /* "PyCafe.pyx":2474 * else: * valUShortArray = malloc( * nelemMethod * sizeof(dbr_enum_t)) # <<<<<<<<<<<<<< @@ -63649,7 +64097,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_valUShortArray = ((dbr_enum_t *)malloc((__pyx_v_nelemMethod * (sizeof(dbr_enum_t))))); - /* "PyCafe.pyx":2476 + /* "PyCafe.pyx":2475 * valUShortArray = malloc( * nelemMethod * sizeof(dbr_enum_t)) * with nogil: # <<<<<<<<<<<<<< @@ -63664,7 +64112,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":2477 + /* "PyCafe.pyx":2476 * nelemMethod * sizeof(dbr_enum_t)) * with nogil: * status = self._c_cafe.getUShortArray( # <<<<<<<<<<<<<< @@ -63674,7 +64122,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getUShortArray(__pyx_v_handle, __pyx_v_valUShortArray); } - /* "PyCafe.pyx":2476 + /* "PyCafe.pyx":2475 * valUShortArray = malloc( * nelemMethod * sizeof(dbr_enum_t)) * with nogil: # <<<<<<<<<<<<<< @@ -63693,19 +64141,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":2480 + /* "PyCafe.pyx":2479 * handle, valUShortArray) * * ll = [] # <<<<<<<<<<<<<< * for i in range(0, nelemMethod): * ll.append(valUShortArray[i]) */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2480, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_ll = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2481 + /* "PyCafe.pyx":2480 * * ll = [] * for i in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -63717,20 +64165,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":2482 + /* "PyCafe.pyx":2481 * ll = [] * for i in range(0, nelemMethod): * ll.append(valUShortArray[i]) # <<<<<<<<<<<<<< * free(valUShortArray) * if status == ICAFE_NORMAL: */ - __pyx_t_4 = __Pyx_PyInt_From_dbr_enum_t((__pyx_v_valUShortArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2482, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_dbr_enum_t((__pyx_v_valUShortArray[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2482, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(3, 2481, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":2483 + /* "PyCafe.pyx":2482 * for i in range(0, nelemMethod): * ll.append(valUShortArray[i]) * free(valUShortArray) # <<<<<<<<<<<<<< @@ -63739,7 +64187,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ free(__pyx_v_valUShortArray); - /* "PyCafe.pyx":2484 + /* "PyCafe.pyx":2483 * ll.append(valUShortArray[i]) * free(valUShortArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63749,7 +64197,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2485 + /* "PyCafe.pyx":2484 * free(valUShortArray) * if status == ICAFE_NORMAL: * return ll # <<<<<<<<<<<<<< @@ -63761,7 +64209,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = __pyx_v_ll; goto __pyx_L0; - /* "PyCafe.pyx":2484 + /* "PyCafe.pyx":2483 * ll.append(valUShortArray[i]) * free(valUShortArray) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63772,7 +64220,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } __pyx_L76:; - /* "PyCafe.pyx":2456 + /* "PyCafe.pyx":2455 * return ll * * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -63782,7 +64230,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy break; case CAFE_NO_ACCESS: - /* "PyCafe.pyx":2487 + /* "PyCafe.pyx":2486 * return ll * # Will not happen; already covered above * elif dtcheck in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -63791,16 +64239,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ case CAFE_TYPENOTCONN: - /* "PyCafe.pyx":2488 + /* "PyCafe.pyx":2487 * # 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 */ - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2488, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2488, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_n_u_Channel); __Pyx_GIVEREF(__pyx_n_u_Channel); @@ -63811,12 +64259,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __Pyx_GIVEREF(__pyx_kp_u_not_connected); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_not_connected); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2488, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2490 + /* "PyCafe.pyx":2489 * print("Channel", self._c_cafe.getPVFromHandle( * handle), " not connected") * return None # <<<<<<<<<<<<<< @@ -63827,7 +64275,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":2487 + /* "PyCafe.pyx":2486 * return ll * # Will not happen; already covered above * elif dtcheck in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -63837,18 +64285,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy break; default: - /* "PyCafe.pyx":2492 + /* "PyCafe.pyx":2491 * return None * else: * print("This line in PyCafe def getAsList should never appear!") # <<<<<<<<<<<<<< * return None * */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2492, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2491, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2493 + /* "PyCafe.pyx":2492 * else: * print("This line in PyCafe def getAsList should never appear!") * return None # <<<<<<<<<<<<<< @@ -63861,7 +64309,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy break; } - /* "PyCafe.pyx":2495 + /* "PyCafe.pyx":2494 * return None * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -63871,7 +64319,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2496 + /* "PyCafe.pyx":2495 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -63881,7 +64329,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2497 + /* "PyCafe.pyx":2496 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -63891,7 +64339,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2498 + /* "PyCafe.pyx":2497 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -63900,7 +64348,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":2497 + /* "PyCafe.pyx":2496 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -63910,7 +64358,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy goto __pyx_L91; } - /* "PyCafe.pyx":2500 + /* "PyCafe.pyx":2499 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -63922,7 +64370,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy } __pyx_L91:; - /* "PyCafe.pyx":2496 + /* "PyCafe.pyx":2495 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -63931,7 +64379,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2501 + /* "PyCafe.pyx":2500 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions is False: # <<<<<<<<<<<<<< @@ -63941,84 +64389,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = ((__pyx_v_self->_enable_exceptions == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2503 + /* "PyCafe.pyx":2502 * if self._enable_exceptions is False: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2503, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2503, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2503, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2503, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 2502, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 2502, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_handle, __pyx_t_3) < 0) __PYX_ERR(3, 2503, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_handle, __pyx_t_3) < 0) __PYX_ERR(3, 2502, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2504 + /* "PyCafe.pyx":2503 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, * _error_text=self.cs.code(status), */ - __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2504, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_pv_name, __pyx_t_3) < 0) __PYX_ERR(3, 2503, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_pv_name, __pyx_t_3) < 0) __PYX_ERR(3, 2502, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2505 + /* "PyCafe.pyx":2504 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, # <<<<<<<<<<<<<< * _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2505, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_code, __pyx_t_3) < 0) __PYX_ERR(3, 2503, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_code, __pyx_t_3) < 0) __PYX_ERR(3, 2502, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2506 + /* "PyCafe.pyx":2505 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, * _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2506, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_text, __pyx_t_3) < 0) __PYX_ERR(3, 2503, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_text, __pyx_t_3) < 0) __PYX_ERR(3, 2502, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2507 + /* "PyCafe.pyx":2506 * _error_code=status, * _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2507, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_t_3) < 0) __PYX_ERR(3, 2503, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_t_3) < 0) __PYX_ERR(3, 2502, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2502 + /* "PyCafe.pyx":2501 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions is False: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2502, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2501, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2508 + /* "PyCafe.pyx":2507 * _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -64026,9 +64474,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy * return None */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 2508, __pyx_L1_error) + __PYX_ERR(3, 2507, __pyx_L1_error) - /* "PyCafe.pyx":2501 + /* "PyCafe.pyx":2500 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions is False: # <<<<<<<<<<<<<< @@ -64037,7 +64485,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2510 + /* "PyCafe.pyx":2509 * raise _cafeException * * return None # <<<<<<<<<<<<<< @@ -64048,7 +64496,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":2495 + /* "PyCafe.pyx":2494 * return None * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -64057,7 +64505,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":2250 + /* "PyCafe.pyx":2249 * ############################################################################ * @verify_handlepv * def getList(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -64084,7 +64532,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_250getList(struct __pyx_obj_6PyCafe_Cy return __pyx_r; } -/* "PyCafe.pyx":2514 +/* "PyCafe.pyx":2513 * ################################################################################## * * def getStrArray(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -64128,7 +64576,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_253getStrArray(PyObject *__pyx_v_self, } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getStrArray") < 0)) __PYX_ERR(3, 2514, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getStrArray") < 0)) __PYX_ERR(3, 2513, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -64144,13 +64592,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_253getStrArray(PyObject *__pyx_v_self, } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getStrArray", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2514, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getStrArray", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2513, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getStrArray", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 2514, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 2513, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_252getStrArray(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_art); /* function exit code */ @@ -64171,7 +64619,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_252getStrArray(struct __pyx_obj_6PyCaf PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getStrArray", 0); - /* "PyCafe.pyx":2515 + /* "PyCafe.pyx":2514 * * def getStrArray(self, handlePV, str art='numpy'): * return self.getArray(handlePV, dt='str', art=art) # <<<<<<<<<<<<<< @@ -64179,18 +64627,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_252getStrArray(struct __pyx_obj_6PyCaf * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArray); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2515, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArray); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2515, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2515, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 2515, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 2515, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2515, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 2514, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 2514, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -64199,7 +64647,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_252getStrArray(struct __pyx_obj_6PyCaf __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2514 + /* "PyCafe.pyx":2513 * ################################################################################## * * def getStrArray(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -64223,7 +64671,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_252getStrArray(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":2519 +/* "PyCafe.pyx":2518 * * ############################################################################ * def getIntArray(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -64267,7 +64715,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_255getIntArray(PyObject *__pyx_v_self, } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getIntArray") < 0)) __PYX_ERR(3, 2519, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getIntArray") < 0)) __PYX_ERR(3, 2518, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -64283,13 +64731,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_255getIntArray(PyObject *__pyx_v_self, } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getIntArray", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2519, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getIntArray", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2518, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getIntArray", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 2519, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 2518, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_254getIntArray(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_art); /* function exit code */ @@ -64310,7 +64758,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_254getIntArray(struct __pyx_obj_6PyCaf PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getIntArray", 0); - /* "PyCafe.pyx":2520 + /* "PyCafe.pyx":2519 * ############################################################################ * def getIntArray(self, handlePV, str art='numpy'): * return self.getArray(handlePV, dt='int', art=art) # <<<<<<<<<<<<<< @@ -64318,18 +64766,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_254getIntArray(struct __pyx_obj_6PyCaf * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArray); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2520, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArray); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2519, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2520, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2519, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2520, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2519, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 2520, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 2520, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2520, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 2519, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 2519, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2519, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -64338,7 +64786,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_254getIntArray(struct __pyx_obj_6PyCaf __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2519 + /* "PyCafe.pyx":2518 * * ############################################################################ * def getIntArray(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -64362,7 +64810,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_254getIntArray(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":2524 +/* "PyCafe.pyx":2523 * * ############################################################################ * def getFloatArray(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -64406,7 +64854,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_257getFloatArray(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getFloatArray") < 0)) __PYX_ERR(3, 2524, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getFloatArray") < 0)) __PYX_ERR(3, 2523, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -64422,13 +64870,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_257getFloatArray(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getFloatArray", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2524, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getFloatArray", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2523, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getFloatArray", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 2524, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 2523, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_256getFloatArray(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_art); /* function exit code */ @@ -64449,7 +64897,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_256getFloatArray(struct __pyx_obj_6PyC PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getFloatArray", 0); - /* "PyCafe.pyx":2525 + /* "PyCafe.pyx":2524 * ############################################################################ * def getFloatArray(self, handlePV, str art='numpy'): * return self.getArray(handlePV, dt='float', art=art) # <<<<<<<<<<<<<< @@ -64457,18 +64905,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_256getFloatArray(struct __pyx_obj_6PyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArray); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2525, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArray); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2525, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2525, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 2525, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 2525, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2525, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 2524, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 2524, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -64477,7 +64925,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_256getFloatArray(struct __pyx_obj_6PyC __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2524 + /* "PyCafe.pyx":2523 * * ############################################################################ * def getFloatArray(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -64501,7 +64949,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_256getFloatArray(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":2530 +/* "PyCafe.pyx":2529 * ############################################################################ * @verify_handlepv * def getArray(self, handlePV, str dt='native', str art='numpy'): # <<<<<<<<<<<<<< @@ -64555,7 +65003,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_259getArray(PyObject *__pyx_v_self, Py } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getArray") < 0)) __PYX_ERR(3, 2530, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getArray") < 0)) __PYX_ERR(3, 2529, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -64574,14 +65022,14 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_259getArray(PyObject *__pyx_v_self, Py } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getArray", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2530, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getArray", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2529, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getArray", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 2530, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 2530, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 2529, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 2529, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_258getArray(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_dt, __pyx_v_art); /* function exit code */ @@ -64597,6 +65045,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C PyObject *__pyx_v__METHOD = 0; unsigned int __pyx_v_handle; short *__pyx_v_i16val; + dbr_char_t *__pyx_v_ui8val; int *__pyx_v_ival; double *__pyx_v_dval; float *__pyx_v_fval; @@ -64627,6 +65076,8 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C int __pyx_v_encoding; PyObject *__pyx_v_arrayArray = NULL; PyObject *__pyx_v_ctypesArray = NULL; + PyObject *__pyx_v_start = NULL; + PyObject *__pyx_v_end = NULL; PyObject *__pyx_v_ctypesArray16 = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations @@ -64647,8 +65098,8 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; - __Pyx_memviewslice __pyx_t_18 = { 0, 0, { 0 }, { 0 }, { 0 } }; - size_t __pyx_t_19; + size_t __pyx_t_18; + __Pyx_memviewslice __pyx_t_19 = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_t_20 = { 0, 0, { 0 }, { 0 }, { 0 } }; size_t __pyx_t_21; __Pyx_memviewslice __pyx_t_22 = { 0, 0, { 0 }, { 0 }, { 0 } }; @@ -64656,25 +65107,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C size_t __pyx_t_24; size_t __pyx_t_25; size_t __pyx_t_26; - __Pyx_memviewslice __pyx_t_27 = { 0, 0, { 0 }, { 0 }, { 0 } }; + size_t __pyx_t_27; size_t __pyx_t_28; - __Pyx_memviewslice __pyx_t_29 = { 0, 0, { 0 }, { 0 }, { 0 } }; + size_t __pyx_t_29; size_t __pyx_t_30; - __Pyx_memviewslice __pyx_t_31 = { 0, 0, { 0 }, { 0 }, { 0 } }; + size_t __pyx_t_31; size_t __pyx_t_32; - size_t __pyx_t_33; + __Pyx_memviewslice __pyx_t_33 = { 0, 0, { 0 }, { 0 }, { 0 } }; size_t __pyx_t_34; __Pyx_memviewslice __pyx_t_35 = { 0, 0, { 0 }, { 0 }, { 0 } }; size_t __pyx_t_36; - size_t __pyx_t_37; + __Pyx_memviewslice __pyx_t_37 = { 0, 0, { 0 }, { 0 }, { 0 } }; size_t __pyx_t_38; - __Pyx_memviewslice __pyx_t_39 = { 0, 0, { 0 }, { 0 }, { 0 } }; + size_t __pyx_t_39; size_t __pyx_t_40; - size_t __pyx_t_41; + __Pyx_memviewslice __pyx_t_41 = { 0, 0, { 0 }, { 0 }, { 0 } }; size_t __pyx_t_42; + size_t __pyx_t_43; + size_t __pyx_t_44; + __Pyx_memviewslice __pyx_t_45 = { 0, 0, { 0 }, { 0 }, { 0 } }; + size_t __pyx_t_46; + size_t __pyx_t_47; + size_t __pyx_t_48; __Pyx_RefNannySetupContext("getArray", 0); - /* "PyCafe.pyx":2549 + /* "PyCafe.pyx":2548 * # hence C contiguous. * * cdef str _METHOD = "getArray" # <<<<<<<<<<<<<< @@ -64684,14 +65141,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_n_u_getArray); __pyx_v__METHOD = __pyx_n_u_getArray; - /* "PyCafe.pyx":2550 + /* "PyCafe.pyx":2549 * * cdef str _METHOD = "getArray" * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * ''' * cdef unsigned int handle = 0 */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2550, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2549, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; /* "PyCafe.pyx":2576 @@ -65340,10 +65797,98 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * # previously nelemNative - has to be at least size of nelemClient * cdef unsigned int nelemMemory = nelemClient # <<<<<<<<<<<<<< * - * #print('native', self.hh.getNelemNative(handle)) + * print('native', self.hh.getNelemNative(handle)) */ __pyx_v_nelemMemory = __pyx_v_nelemClient; + /* "PyCafe.pyx":2660 + * cdef unsigned int nelemMemory = nelemClient + * + * print('native', self.hh.getNelemNative(handle)) # <<<<<<<<<<<<<< + * print('client', self.hh.getNelemClient(handle)) + * print('request',self.hh.getNelemRequest(handle)) + */ + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNelemNative(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_n_u_native); + __Pyx_GIVEREF(__pyx_n_u_native); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_native); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "PyCafe.pyx":2661 + * + * print('native', self.hh.getNelemNative(handle)) + * print('client', self.hh.getNelemClient(handle)) # <<<<<<<<<<<<<< + * print('request',self.hh.getNelemRequest(handle)) + * + */ + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNelemClient(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_n_u_client); + __Pyx_GIVEREF(__pyx_n_u_client); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_client); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "PyCafe.pyx":2662 + * print('native', self.hh.getNelemNative(handle)) + * print('client', self.hh.getNelemClient(handle)) + * print('request',self.hh.getNelemRequest(handle)) # <<<<<<<<<<<<<< + * + * print ('dtcheck', dtcheck) + */ + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNelemRequest(__pyx_v_handle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_n_u_request); + __Pyx_GIVEREF(__pyx_n_u_request); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_request); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "PyCafe.pyx":2664 + * print('request',self.hh.getNelemRequest(handle)) + * + * print ('dtcheck', dtcheck) # <<<<<<<<<<<<<< + * + * # cdef double [::1] cyarr_view + */ + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtcheck); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_n_u_dtcheck); + __Pyx_GIVEREF(__pyx_n_u_dtcheck); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_dtcheck); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + /* "PyCafe.pyx":2672 * cdef bytes bVal * @@ -66343,7 +66888,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __Pyx_DECREF_SET(__pyx_t_4, function); } } - __pyx_t_3 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_8, __pyx_kp_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_utf_8_2); + __pyx_t_3 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_8, __pyx_kp_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_utf_8); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2750, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -66548,7 +67093,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * * return mvStr # <<<<<<<<<<<<<< * - * elif dtcheck in [CAFE_SHORT, CAFE_CHAR]: + * elif dtcheck in [CAFE_CHAR]: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_mvStr); @@ -66574,38 +67119,59 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * with nogil: */ break; - case CAFE_SHORT: - - /* "PyCafe.pyx":2767 - * return mvStr - * - * elif dtcheck in [CAFE_SHORT, CAFE_CHAR]: # <<<<<<<<<<<<<< - * - * i16val = malloc(nelemMemory * sizeof(np.int16)) - */ case CAFE_CHAR: /* "PyCafe.pyx":2769 - * elif dtcheck in [CAFE_SHORT, CAFE_CHAR]: + * elif dtcheck in [CAFE_CHAR]: * - * i16val = malloc(nelemMemory * sizeof(np.int16)) # <<<<<<<<<<<<<< - * # start=time.time() + * ui8val = malloc(nelemMemory * sizeof(np.uint8)) # <<<<<<<<<<<<<< + * start=time.time() * with nogil: */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2769, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_uint8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_i16val = ((short *)malloc((__pyx_v_nelemMemory * (sizeof(__pyx_t_9))))); + __pyx_v_ui8val = ((dbr_char_t *)malloc((__pyx_v_nelemMemory * (sizeof(__pyx_t_9))))); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + /* "PyCafe.pyx":2770 + * + * ui8val = malloc(nelemMemory * sizeof(np.uint8)) + * start=time.time() # <<<<<<<<<<<<<< + * with nogil: + * status = self._c_cafe.getCharArray(handle, ui8val) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2770, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_time); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2770, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_9 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2770, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_start = __pyx_t_9; + __pyx_t_9 = 0; + /* "PyCafe.pyx":2771 - * i16val = malloc(nelemMemory * sizeof(np.int16)) - * # start=time.time() + * ui8val = malloc(nelemMemory * sizeof(np.uint8)) + * start=time.time() * with nogil: # <<<<<<<<<<<<<< - * status = self._c_cafe.getShortArray(handle, i16val) - * # end=time.time() + * status = self._c_cafe.getCharArray(handle, ui8val) + * end=time.time() */ { #ifdef WITH_THREAD @@ -66616,21 +67182,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C /*try:*/ { /* "PyCafe.pyx":2772 - * # start=time.time() + * start=time.time() * with nogil: - * status = self._c_cafe.getShortArray(handle, i16val) # <<<<<<<<<<<<<< - * # end=time.time() - * #print ("END TIME SHORT", end - start) + * status = self._c_cafe.getCharArray(handle, ui8val) # <<<<<<<<<<<<<< + * end=time.time() + * print ("END TIME CHAR", end - start) */ - __pyx_v_status = __pyx_v_self->_c_cafe->getShortArray(__pyx_v_handle, __pyx_v_i16val); + __pyx_v_status = __pyx_v_self->_c_cafe->getCharArray(__pyx_v_handle, __pyx_v_ui8val); } /* "PyCafe.pyx":2771 - * i16val = malloc(nelemMemory * sizeof(np.int16)) - * # start=time.time() + * ui8val = malloc(nelemMemory * sizeof(np.uint8)) + * start=time.time() * with nogil: # <<<<<<<<<<<<<< - * status = self._c_cafe.getShortArray(handle, i16val) - * # end=time.time() + * status = self._c_cafe.getCharArray(handle, ui8val) + * end=time.time() */ /*finally:*/ { /*normal exit:*/{ @@ -66644,9 +67210,150 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C } } + /* "PyCafe.pyx":2773 + * with nogil: + * status = self._c_cafe.getCharArray(handle, ui8val) + * end=time.time() # <<<<<<<<<<<<<< + * print ("END TIME CHAR", end - start) + * print("length of ui8val", len(ui8val)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_time); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_end = __pyx_t_9; + __pyx_t_9 = 0; + + /* "PyCafe.pyx":2774 + * status = self._c_cafe.getCharArray(handle, ui8val) + * end=time.time() + * print ("END TIME CHAR", end - start) # <<<<<<<<<<<<<< + * print("length of ui8val", len(ui8val)) + * + */ + __pyx_t_9 = PyNumber_Subtract(__pyx_v_end, __pyx_v_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_kp_u_END_TIME_CHAR); + __Pyx_GIVEREF(__pyx_kp_u_END_TIME_CHAR); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_END_TIME_CHAR); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + /* "PyCafe.pyx":2775 - * # end=time.time() - * #print ("END TIME SHORT", end - start) + * end=time.time() + * print ("END TIME CHAR", end - start) + * print("length of ui8val", len(ui8val)) # <<<<<<<<<<<<<< + * + * print('native', self.hh.getNelemNative(handle)) + */ + __pyx_t_18 = strlen(((char const *)__pyx_v_ui8val)); + __pyx_t_9 = __Pyx_PyInt_FromSize_t(__pyx_t_18); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_kp_u_length_of_ui8val); + __Pyx_GIVEREF(__pyx_kp_u_length_of_ui8val); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_length_of_ui8val); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "PyCafe.pyx":2777 + * print("length of ui8val", len(ui8val)) + * + * print('native', self.hh.getNelemNative(handle)) # <<<<<<<<<<<<<< + * print('client', self.hh.getNelemClient(handle)) + * print('request',self.hh.getNelemRequest(handle)) + */ + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNelemNative(__pyx_v_handle)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_n_u_native); + __Pyx_GIVEREF(__pyx_n_u_native); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_native); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "PyCafe.pyx":2778 + * + * print('native', self.hh.getNelemNative(handle)) + * print('client', self.hh.getNelemClient(handle)) # <<<<<<<<<<<<<< + * print('request',self.hh.getNelemRequest(handle)) + * + */ + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNelemClient(__pyx_v_handle)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_n_u_client); + __Pyx_GIVEREF(__pyx_n_u_client); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_client); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "PyCafe.pyx":2779 + * print('native', self.hh.getNelemNative(handle)) + * print('client', self.hh.getNelemClient(handle)) + * print('request',self.hh.getNelemRequest(handle)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNelemRequest(__pyx_v_handle)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_n_u_request); + __Pyx_GIVEREF(__pyx_n_u_request); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_request); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "PyCafe.pyx":2783 + * + * #nelemMethod = min(len(ui8val), nelemMemory) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * # np.empty preferred, else mvInt does not get correct value for first couple of array elements * @@ -66654,44 +67361,44 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2778 + /* "PyCafe.pyx":2786 * # np.empty preferred, else mvInt does not get correct value for first couple of array elements * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< * - * # ##mvInt=ival + * if dt in ['np.short', 'np.int16', 'short', 'int16']: */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2778, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2786, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; goto __pyx_L72_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2778, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2786, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L72_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2778, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2786, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; goto __pyx_L72_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2778, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2786, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L72_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2778, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2786, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); __pyx_t_2 = __pyx_t_7; __pyx_L72_bool_binop_done:; @@ -66699,8 +67406,8 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_7 = (__pyx_t_2 != 0); if (__pyx_t_7) { - /* "PyCafe.pyx":2784 - * # ##set_base(arr, ival) + /* "PyCafe.pyx":2788 + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: * * if dt in ['np.short', 'np.int16', 'short', 'int16']: # <<<<<<<<<<<<<< * mvShort = np.empty( @@ -66708,28 +67415,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_6 = __pyx_v_dt; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_short, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2784, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_short, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2788, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_7 = __pyx_t_5; goto __pyx_L78_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_int16, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2784, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_int16, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2788, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 != 0); if (!__pyx_t_2) { } else { __pyx_t_7 = __pyx_t_2; goto __pyx_L78_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_short, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2784, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_short, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2788, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_7 = __pyx_t_5; goto __pyx_L78_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_int16, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2784, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_int16, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2788, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 != 0); __pyx_t_7 = __pyx_t_2; __pyx_L78_bool_binop_done:; @@ -66737,130 +67444,130 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_7 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2785 + /* "PyCafe.pyx":2789 * * if dt in ['np.short', 'np.int16', 'short', 'int16']: * mvShort = np.empty( # <<<<<<<<<<<<<< * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2785, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2785, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":2786 + /* "PyCafe.pyx":2790 * 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] + * mvShort[ij] = ui8val[ij] */ - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2786, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - /* "PyCafe.pyx":2785 + /* "PyCafe.pyx":2789 * * if dt in ['np.short', 'np.int16', 'short', 'int16']: * mvShort = np.empty( # <<<<<<<<<<<<<< * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2785, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":2786 + /* "PyCafe.pyx":2790 * 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] + * mvShort[ij] = ui8val[ij] */ - __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2786, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2786, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int16); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2786, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int16); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(3, 2786, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(3, 2790, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2786, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2790, __pyx_L1_error) - /* "PyCafe.pyx":2785 + /* "PyCafe.pyx":2789 * * if dt in ['np.short', 'np.int16', 'short', 'int16']: * mvShort = np.empty( # <<<<<<<<<<<<<< * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2785, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 2785, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(3, 2789, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_v_mvShort = __pyx_t_18; - __pyx_t_18.memview = NULL; - __pyx_t_18.data = NULL; + __pyx_v_mvShort = __pyx_t_19; + __pyx_t_19.memview = NULL; + __pyx_t_19.data = NULL; - /* "PyCafe.pyx":2787 + /* "PyCafe.pyx":2791 * mvShort = np.empty( * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * mvShort[ij] = i16val[ij] - * free(i16val) + * mvShort[ij] = ui8val[ij] + * free(ui8val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2788 + /* "PyCafe.pyx":2792 * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): - * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< - * free(i16val) + * mvShort[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) * return np.array(mvShort) */ - __pyx_t_19 = __pyx_v_ij; + __pyx_t_18 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_19 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_18 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2788, __pyx_L1_error) + __PYX_ERR(3, 2792, __pyx_L1_error) } - *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_19)) )) = ((__pyx_t_5numpy_int16_t)(__pyx_v_i16val[__pyx_v_ij])); + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_18)) )) = ((__pyx_t_5numpy_int16_t)(__pyx_v_ui8val[__pyx_v_ij])); } - /* "PyCafe.pyx":2789 + /* "PyCafe.pyx":2793 * for ij in range(0, nelemMethod): - * mvShort[ij] = i16val[ij] - * free(i16val) # <<<<<<<<<<<<<< + * mvShort[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< * return np.array(mvShort) * */ - free(__pyx_v_i16val); + free(__pyx_v_ui8val); - /* "PyCafe.pyx":2790 - * mvShort[ij] = i16val[ij] - * free(i16val) + /* "PyCafe.pyx":2794 + * mvShort[ij] = ui8val[ij] + * free(ui8val) * return np.array(mvShort) # <<<<<<<<<<<<<< * * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2790, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2794, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2790, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2794, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2790, __pyx_L1_error) + __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2794, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { @@ -66875,15 +67582,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_10 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_4, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2790, __pyx_L1_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2794, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_r = __pyx_t_10; __pyx_t_10 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2784 - * # ##set_base(arr, ival) + /* "PyCafe.pyx":2788 + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: * * if dt in ['np.short', 'np.int16', 'short', 'int16']: # <<<<<<<<<<<<<< * mvShort = np.empty( @@ -66892,7 +67599,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C goto __pyx_L77; } - /* "PyCafe.pyx":2792 + /* "PyCafe.pyx":2796 * return np.array(mvShort) * * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: # <<<<<<<<<<<<<< @@ -66901,42 +67608,42 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_6 = __pyx_v_dt; - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_int8, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2792, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_int8, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2796, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L84_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_bool, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2792, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_bool, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2796, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; goto __pyx_L84_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_byte, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2792, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_byte, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2796, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L84_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_bool, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2792, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_bool, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2796, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; goto __pyx_L84_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_byte, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2792, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_byte, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2796, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L84_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_int8, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2792, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_int8, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2796, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); __pyx_t_2 = __pyx_t_7; __pyx_L84_bool_binop_done:; @@ -66944,95 +67651,95 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_7 = (__pyx_t_2 != 0); if (__pyx_t_7) { - /* "PyCafe.pyx":2793 + /* "PyCafe.pyx":2797 * * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: * mvInt8 = np.empty( # <<<<<<<<<<<<<< * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): */ - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2793, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2797, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_empty); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2793, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_empty); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2797, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":2794 + /* "PyCafe.pyx":2798 * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: * mvInt8 = np.empty( * nelemMethod, dtype=np.int8, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvInt8[ij] = i16val[ij] + * mvInt8[ij] = ui8val[ij] */ - __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2794, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2798, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - /* "PyCafe.pyx":2793 + /* "PyCafe.pyx":2797 * * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: * mvInt8 = np.empty( # <<<<<<<<<<<<<< * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2793, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2797, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":2794 + /* "PyCafe.pyx":2798 * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: * mvInt8 = np.empty( * nelemMethod, dtype=np.int8, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvInt8[ij] = i16val[ij] + * mvInt8[ij] = ui8val[ij] */ - __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2794, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2798, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2794, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2798, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2794, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2798, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(3, 2794, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(3, 2798, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2794, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2798, __pyx_L1_error) - /* "PyCafe.pyx":2793 + /* "PyCafe.pyx":2797 * * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: * mvInt8 = np.empty( # <<<<<<<<<<<<<< * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2793, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2797, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_20 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int8_t(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_20.memview)) __PYX_ERR(3, 2793, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int8_t(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_20.memview)) __PYX_ERR(3, 2797, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_mvInt8 = __pyx_t_20; __pyx_t_20.memview = NULL; __pyx_t_20.data = NULL; - /* "PyCafe.pyx":2795 + /* "PyCafe.pyx":2799 * mvInt8 = np.empty( * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * mvInt8[ij] = i16val[ij] - * free(i16val) + * mvInt8[ij] = ui8val[ij] + * free(ui8val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2796 + /* "PyCafe.pyx":2800 * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): - * mvInt8[ij] = i16val[ij] # <<<<<<<<<<<<<< - * free(i16val) + * mvInt8[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) * return np.array(mvInt8) */ __pyx_t_21 = __pyx_v_ij; @@ -67040,34 +67747,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C if (unlikely(__pyx_t_21 >= (size_t)__pyx_v_mvInt8.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2796, __pyx_L1_error) + __PYX_ERR(3, 2800, __pyx_L1_error) } - *((__pyx_t_5numpy_int8_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int8_t *) __pyx_v_mvInt8.data) + __pyx_t_21)) )) = ((__pyx_t_5numpy_int8_t)(__pyx_v_i16val[__pyx_v_ij])); + *((__pyx_t_5numpy_int8_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int8_t *) __pyx_v_mvInt8.data) + __pyx_t_21)) )) = ((__pyx_t_5numpy_int8_t)(__pyx_v_ui8val[__pyx_v_ij])); } - /* "PyCafe.pyx":2797 + /* "PyCafe.pyx":2801 * for ij in range(0, nelemMethod): - * mvInt8[ij] = i16val[ij] - * free(i16val) # <<<<<<<<<<<<<< + * mvInt8[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< * return np.array(mvInt8) * */ - free(__pyx_v_i16val); + free(__pyx_v_ui8val); - /* "PyCafe.pyx":2798 - * mvInt8[ij] = i16val[ij] - * free(i16val) + /* "PyCafe.pyx":2802 + * mvInt8[ij] = ui8val[ij] + * free(ui8val) * return np.array(mvInt8) # <<<<<<<<<<<<<< * * elif dt in ['uchar', 'np.uint8', 'uint8']: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2798, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2802, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2798, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2802, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __pyx_memoryview_fromslice(__pyx_v_mvInt8, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int8_t, 0);; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2798, __pyx_L1_error) + __pyx_t_10 = __pyx_memoryview_fromslice(__pyx_v_mvInt8, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int8_t, 0);; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2802, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { @@ -67082,14 +67789,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_3 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_8, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2798, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2802, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2792 + /* "PyCafe.pyx":2796 * return np.array(mvShort) * * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: # <<<<<<<<<<<<<< @@ -67099,7 +67806,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C goto __pyx_L77; } - /* "PyCafe.pyx":2800 + /* "PyCafe.pyx":2804 * return np.array(mvInt8) * * elif dt in ['uchar', 'np.uint8', 'uint8']: # <<<<<<<<<<<<<< @@ -67108,21 +67815,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_6 = __pyx_v_dt; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_uchar, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2800, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_uchar, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2804, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_7 = __pyx_t_5; goto __pyx_L92_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_uint8, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2800, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_uint8, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2804, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 != 0); if (!__pyx_t_2) { } else { __pyx_t_7 = __pyx_t_2; goto __pyx_L92_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_uint8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2800, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_uint8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2804, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); __pyx_t_7 = __pyx_t_5; __pyx_L92_bool_binop_done:; @@ -67130,130 +67837,130 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_5 = (__pyx_t_7 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2801 + /* "PyCafe.pyx":2805 * * elif dt in ['uchar', 'np.uint8', 'uint8']: * mvUInt8 = np.empty( # <<<<<<<<<<<<<< * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2801, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2805, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2801, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2805, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2802 + /* "PyCafe.pyx":2806 * elif dt in ['uchar', 'np.uint8', 'uint8']: * mvUInt8 = np.empty( * nelemMethod, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvUInt8[ij] = i16val[ij] + * mvUInt8[ij] = ui8val[ij] */ - __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2802, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2806, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "PyCafe.pyx":2801 + /* "PyCafe.pyx":2805 * * elif dt in ['uchar', 'np.uint8', 'uint8']: * mvUInt8 = np.empty( # <<<<<<<<<<<<<< * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2801, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2805, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2802 + /* "PyCafe.pyx":2806 * elif dt in ['uchar', 'np.uint8', 'uint8']: * mvUInt8 = np.empty( * nelemMethod, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvUInt8[ij] = i16val[ij] + * mvUInt8[ij] = ui8val[ij] */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2802, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2806, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2802, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2806, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_uint8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2802, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_uint8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2806, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(3, 2802, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(3, 2806, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2802, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2806, __pyx_L1_error) - /* "PyCafe.pyx":2801 + /* "PyCafe.pyx":2805 * * elif dt in ['uchar', 'np.uint8', 'uint8']: * mvUInt8 = np.empty( # <<<<<<<<<<<<<< * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2801, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2805, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_uint8_t(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(3, 2801, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_uint8_t(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(3, 2805, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_mvUInt8 = __pyx_t_22; __pyx_t_22.memview = NULL; __pyx_t_22.data = NULL; - /* "PyCafe.pyx":2803 + /* "PyCafe.pyx":2807 * mvUInt8 = np.empty( * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * mvUInt8[ij] = i16val[ij] - * free(i16val) + * mvUInt8[ij] = ui8val[ij] + * */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2804 + /* "PyCafe.pyx":2808 * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): - * mvUInt8[ij] = i16val[ij] # <<<<<<<<<<<<<< - * free(i16val) - * return np.array(mvUInt8) + * mvUInt8[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * + * free(ui8val) */ __pyx_t_23 = __pyx_v_ij; __pyx_t_16 = -1; if (unlikely(__pyx_t_23 >= (size_t)__pyx_v_mvUInt8.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2804, __pyx_L1_error) + __PYX_ERR(3, 2808, __pyx_L1_error) } - *((__pyx_t_5numpy_uint8_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_uint8_t *) __pyx_v_mvUInt8.data) + __pyx_t_23)) )) = ((__pyx_t_5numpy_uint8_t)(__pyx_v_i16val[__pyx_v_ij])); + *((__pyx_t_5numpy_uint8_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_uint8_t *) __pyx_v_mvUInt8.data) + __pyx_t_23)) )) = ((__pyx_t_5numpy_uint8_t)(__pyx_v_ui8val[__pyx_v_ij])); } - /* "PyCafe.pyx":2805 - * for ij in range(0, nelemMethod): - * mvUInt8[ij] = i16val[ij] - * free(i16val) # <<<<<<<<<<<<<< + /* "PyCafe.pyx":2810 + * mvUInt8[ij] = ui8val[ij] + * + * free(ui8val) # <<<<<<<<<<<<<< * return np.array(mvUInt8) * */ - free(__pyx_v_i16val); + free(__pyx_v_ui8val); - /* "PyCafe.pyx":2806 - * mvUInt8[ij] = i16val[ij] - * free(i16val) + /* "PyCafe.pyx":2811 + * + * free(ui8val) * return np.array(mvUInt8) # <<<<<<<<<<<<<< * * else: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2806, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2811, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2806, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2811, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_mvUInt8, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_uint8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_uint8_t, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2806, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_mvUInt8, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_uint8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_uint8_t, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2811, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { @@ -67268,14 +67975,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_4 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_9, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_3); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2806, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2811, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2800 + /* "PyCafe.pyx":2804 * return np.array(mvInt8) * * elif dt in ['uchar', 'np.uint8', 'uint8']: # <<<<<<<<<<<<<< @@ -67285,131 +67992,131 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C goto __pyx_L77; } - /* "PyCafe.pyx":2810 - * else: + /* "PyCafe.pyx":2814 * - * mvShort = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.int16, order='C') - * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + * else: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.uint8, order='C') + * #mvShortNP = np.ndarray(buffer=np.array(ui8val), dtype=np.uint8, order='C') */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2810, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2810, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2811 - * - * mvShort = np.empty( - * nelemMethod, dtype=np.int16, order='C') # <<<<<<<<<<<<<< - * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + /* "PyCafe.pyx":2815 + * else: + * mvUInt8 = np.empty( + * nelemMethod, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * #mvShortNP = np.ndarray(buffer=np.array(ui8val), dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2811, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "PyCafe.pyx":2810 - * else: + /* "PyCafe.pyx":2814 * - * mvShort = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.int16, order='C') - * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + * else: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.uint8, order='C') + * #mvShortNP = np.ndarray(buffer=np.array(ui8val), dtype=np.uint8, order='C') */ - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2810, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2811 - * - * mvShort = np.empty( - * nelemMethod, dtype=np.int16, order='C') # <<<<<<<<<<<<<< - * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + /* "PyCafe.pyx":2815 + * else: + * mvUInt8 = np.empty( + * nelemMethod, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * #mvShortNP = np.ndarray(buffer=np.array(ui8val), dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2811, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2811, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_int16); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2811, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_uint8); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(3, 2811, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(3, 2815, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2811, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2815, __pyx_L1_error) - /* "PyCafe.pyx":2810 - * else: + /* "PyCafe.pyx":2814 * - * mvShort = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.int16, order='C') - * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + * else: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.uint8, order='C') + * #mvShortNP = np.ndarray(buffer=np.array(ui8val), dtype=np.uint8, order='C') */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2810, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_8, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 2810, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_uint8_t(__pyx_t_8, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(3, 2814, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_mvShort = __pyx_t_18; - __pyx_t_18.memview = NULL; - __pyx_t_18.data = NULL; + __pyx_v_mvUInt8 = __pyx_t_22; + __pyx_t_22.memview = NULL; + __pyx_t_22.data = NULL; - /* "PyCafe.pyx":2813 - * nelemMethod, dtype=np.int16, order='C') - * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + /* "PyCafe.pyx":2817 + * nelemMethod, dtype=np.uint8, order='C') + * #mvShortNP = np.ndarray(buffer=np.array(ui8val), dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * mvShort[ij] = i16val[ij] - * # mvShortNP=cnp.asarray(i16val) + * mvUInt8[ij] = ui8val[ij] + * # mvShortNP=cnp.asarray(ui8val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2814 - * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + /* "PyCafe.pyx":2818 + * #mvShortNP = np.ndarray(buffer=np.array(ui8val), dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): - * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< - * # mvShortNP=cnp.asarray(i16val) + * mvUInt8[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * # mvShortNP=cnp.asarray(ui8val) * */ __pyx_t_24 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_24 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_24 >= (size_t)__pyx_v_mvUInt8.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2814, __pyx_L1_error) + __PYX_ERR(3, 2818, __pyx_L1_error) } - *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_24)) )) = ((__pyx_t_5numpy_int16_t)(__pyx_v_i16val[__pyx_v_ij])); + *((__pyx_t_5numpy_uint8_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_uint8_t *) __pyx_v_mvUInt8.data) + __pyx_t_24)) )) = ((__pyx_t_5numpy_uint8_t)(__pyx_v_ui8val[__pyx_v_ij])); } - /* "PyCafe.pyx":2818 + /* "PyCafe.pyx":2822 * - * # aaa=np.full(nelemMethod,ival + * if dt in ['np.short', 'np.int16', 'short', 'int16']: */ goto __pyx_L71; } - /* "PyCafe.pyx":2822 - * return np.array(mvShort) # arr + /* "PyCafe.pyx":2825 + * return np.array(mvUInt8) # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') @@ -67452,21 +68159,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2822, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2825, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); if (!__pyx_t_2) { } else { __pyx_t_5 = __pyx_t_2; goto __pyx_L99_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2822, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2825, __pyx_L1_error) __pyx_t_7 = (__pyx_t_2 != 0); if (!__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; goto __pyx_L99_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2822, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2825, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); __pyx_t_5 = __pyx_t_2; __pyx_L99_bool_binop_done:; @@ -67474,97 +68181,97 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_5 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2823 + /* "PyCafe.pyx":2826 * * elif art in ['memoryview', 'mv', 'memoryviewslice']: * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvShort[ij] = i16val[ij] + * mvShort[ij] = ui8val[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2823, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2823, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2823, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2823, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2823, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2823, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_int16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2823, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_int16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 2823, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2823, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2823, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2826, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 2823, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(3, 2826, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_mvShort = __pyx_t_18; - __pyx_t_18.memview = NULL; - __pyx_t_18.data = NULL; + __pyx_v_mvShort = __pyx_t_19; + __pyx_t_19.memview = NULL; + __pyx_t_19.data = NULL; - /* "PyCafe.pyx":2824 + /* "PyCafe.pyx":2827 * elif art in ['memoryview', 'mv', 'memoryviewslice']: * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * mvShort[ij] = i16val[ij] - * free(i16val) + * mvShort[ij] = ui8val[ij] + * free(ui8val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2825 + /* "PyCafe.pyx":2828 * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): - * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< - * free(i16val) - * + * mvShort[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) + * return memoryview(mvShort) */ __pyx_t_25 = __pyx_v_ij; __pyx_t_16 = -1; if (unlikely(__pyx_t_25 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2825, __pyx_L1_error) + __PYX_ERR(3, 2828, __pyx_L1_error) } - *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_25)) )) = ((short)(__pyx_v_i16val[__pyx_v_ij])); + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_25)) )) = ((short)(__pyx_v_ui8val[__pyx_v_ij])); } - /* "PyCafe.pyx":2826 + /* "PyCafe.pyx":2829 * for ij in range(0, nelemMethod): - * mvShort[ij] = i16val[ij] - * free(i16val) # <<<<<<<<<<<<<< - * + * mvShort[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< * return memoryview(mvShort) - */ - free(__pyx_v_i16val); - - /* "PyCafe.pyx":2828 - * free(i16val) * + */ + free(__pyx_v_ui8val); + + /* "PyCafe.pyx":2830 + * mvShort[ij] = ui8val[ij] + * free(ui8val) * return memoryview(mvShort) # <<<<<<<<<<<<<< * * elif art in ['array', 'array.array']: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2828, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2828, __pyx_L1_error) + __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2828, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -67572,8 +68279,8 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2822 - * return np.array(mvShort) # arr + /* "PyCafe.pyx":2825 + * return np.array(mvUInt8) # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') @@ -67582,23 +68289,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C goto __pyx_L71; } - /* "PyCafe.pyx":2830 + /* "PyCafe.pyx":2832 * return memoryview(mvShort) * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< - * * a = array.array('h') + * for ij in range(0, nelemMethod): */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2830, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2832, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; goto __pyx_L104_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2830, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2832, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); __pyx_t_2 = __pyx_t_5; __pyx_L104_bool_binop_done:; @@ -67606,55 +68313,55 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_5 = (__pyx_t_2 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2832 - * elif art in ['array', 'array.array']: + /* "PyCafe.pyx":2833 * + * elif art in ['array', 'array.array']: * a = array.array('h') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * a.append( < short > i16val[ij]) + * a.append( < short > ui8val[ij]) */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2832, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2833, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_a = ((arrayobject *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2833 - * + /* "PyCafe.pyx":2834 + * elif art in ['array', 'array.array']: * a = array.array('h') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * a.append( < short > i16val[ij]) - * free(i16val) + * a.append( < short > ui8val[ij]) + * free(ui8val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2834 + /* "PyCafe.pyx":2835 * a = array.array('h') * for ij in range(0, nelemMethod): - * a.append( < short > i16val[ij]) # <<<<<<<<<<<<<< - * free(i16val) + * a.append( < short > ui8val[ij]) # <<<<<<<<<<<<<< + * free(ui8val) * return a */ - __pyx_t_4 = __Pyx_PyInt_From_short(((short)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2834, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_short(((short)(__pyx_v_ui8val[__pyx_v_ij]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2835, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_17 = __Pyx_PyObject_Append(((PyObject *)__pyx_v_a), __pyx_t_4); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 2834, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_Append(((PyObject *)__pyx_v_a), __pyx_t_4); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 2835, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":2835 + /* "PyCafe.pyx":2836 * for ij in range(0, nelemMethod): - * a.append( < short > i16val[ij]) - * free(i16val) # <<<<<<<<<<<<<< + * a.append( < short > ui8val[ij]) + * free(ui8val) # <<<<<<<<<<<<<< * return a * */ - free(__pyx_v_i16val); + free(__pyx_v_ui8val); - /* "PyCafe.pyx":2836 - * a.append( < short > i16val[ij]) - * free(i16val) + /* "PyCafe.pyx":2837 + * a.append( < short > ui8val[ij]) + * free(ui8val) * return a # <<<<<<<<<<<<<< * * elif art in ['ctypes', 'ctype']: @@ -67664,33 +68371,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_r = ((PyObject *)__pyx_v_a); goto __pyx_L0; - /* "PyCafe.pyx":2830 + /* "PyCafe.pyx":2832 * return memoryview(mvShort) * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< - * * a = array.array('h') + * for ij in range(0, nelemMethod): */ goto __pyx_L71; } - /* "PyCafe.pyx":2838 + /* "PyCafe.pyx":2839 * return a * * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< - * * ctypesArray16 = (ctypes.c_int16*nelemMethod)() + * for ij in range(0, nelemMethod): */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2838, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2839, __pyx_L1_error) __pyx_t_7 = (__pyx_t_2 != 0); if (!__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; goto __pyx_L108_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2838, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2839, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); __pyx_t_5 = __pyx_t_2; __pyx_L108_bool_binop_done:; @@ -67699,11 +68406,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C if (__pyx_t_2) { /* "PyCafe.pyx":2840 - * elif art in ['ctypes', 'ctype']: * + * elif art in ['ctypes', 'ctype']: * ctypesArray16 = (ctypes.c_int16*nelemMethod)() # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * ctypesArray16[ij] = i16val[ij] + * ctypesArray16[ij] = ui8val[ij] */ __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2840, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); @@ -67735,11 +68442,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_4 = 0; /* "PyCafe.pyx":2841 - * + * elif art in ['ctypes', 'ctype']: * ctypesArray16 = (ctypes.c_int16*nelemMethod)() * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * ctypesArray16[ij] = i16val[ij] - * free(i16val) + * ctypesArray16[ij] = ui8val[ij] + * free(ui8val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; @@ -67749,11 +68456,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C /* "PyCafe.pyx":2842 * ctypesArray16 = (ctypes.c_int16*nelemMethod)() * for ij in range(0, nelemMethod): - * ctypesArray16[ij] = i16val[ij] # <<<<<<<<<<<<<< - * free(i16val) + * ctypesArray16[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) * return ctypesArray16 */ - __pyx_t_4 = __Pyx_PyInt_From_short(((short)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2842, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_short(((short)(__pyx_v_ui8val[__pyx_v_ij]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2842, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray16, __pyx_v_ij, __pyx_t_4, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 2842, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -67761,16 +68468,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C /* "PyCafe.pyx":2843 * for ij in range(0, nelemMethod): - * ctypesArray16[ij] = i16val[ij] - * free(i16val) # <<<<<<<<<<<<<< + * ctypesArray16[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< * return ctypesArray16 * */ - free(__pyx_v_i16val); + free(__pyx_v_ui8val); /* "PyCafe.pyx":2844 - * ctypesArray16[ij] = i16val[ij] - * free(i16val) + * ctypesArray16[ij] = ui8val[ij] + * free(ui8val) * return ctypesArray16 # <<<<<<<<<<<<<< * * else: @@ -67780,12 +68487,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_r = __pyx_v_ctypesArray16; goto __pyx_L0; - /* "PyCafe.pyx":2838 + /* "PyCafe.pyx":2839 * return a * * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< - * * ctypesArray16 = (ctypes.c_int16*nelemMethod)() + * for ij in range(0, nelemMethod): */ goto __pyx_L71; } @@ -67835,7 +68542,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") # <<<<<<<<<<<<<< * print("Returning memoryview") - * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * mvUInt8 = np.empty(nelemMethod, dtype=np.uint8, order='C') */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -67845,7 +68552,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") # <<<<<<<<<<<<<< - * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * mvUInt8 = np.empty(nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2850, __pyx_L1_error) @@ -67855,9 +68562,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C /* "PyCafe.pyx":2851 * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") - * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * mvUInt8 = np.empty(nelemMethod, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvShort[ij] = i16val[ij] + * mvUInt8[ij] = ui8val[ij] */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -67875,7 +68582,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __Pyx_GOTREF(__pyx_t_3); __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_int16); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2851, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_uint8); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(3, 2851, __pyx_L1_error) @@ -67886,18 +68593,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 2851, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_uint8_t(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(3, 2851, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_v_mvShort = __pyx_t_18; - __pyx_t_18.memview = NULL; - __pyx_t_18.data = NULL; + __pyx_v_mvUInt8 = __pyx_t_22; + __pyx_t_22.memview = NULL; + __pyx_t_22.data = NULL; /* "PyCafe.pyx":2852 * print("Returning memoryview") - * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * mvUInt8 = np.empty(nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * mvShort[ij] = i16val[ij] - * free(i16val) + * mvUInt8[ij] = ui8val[ij] + * free(ui8val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; @@ -67905,40 +68612,40 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_v_ij = __pyx_t_12; /* "PyCafe.pyx":2853 - * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * mvUInt8 = np.empty(nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): - * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< - * free(i16val) - * + * mvUInt8[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) + * return mvUInt8 */ __pyx_t_26 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_26 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_26 >= (size_t)__pyx_v_mvUInt8.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); __PYX_ERR(3, 2853, __pyx_L1_error) } - *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_26)) )) = ((short)(__pyx_v_i16val[__pyx_v_ij])); + *((__pyx_t_5numpy_uint8_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_uint8_t *) __pyx_v_mvUInt8.data) + __pyx_t_26)) )) = ((dbr_char_t)(__pyx_v_ui8val[__pyx_v_ij])); } /* "PyCafe.pyx":2854 * for ij in range(0, nelemMethod): - * mvShort[ij] = i16val[ij] - * free(i16val) # <<<<<<<<<<<<<< + * mvUInt8[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< + * return mvUInt8 * - * return mvShort */ - free(__pyx_v_i16val); + free(__pyx_v_ui8val); - /* "PyCafe.pyx":2856 - * free(i16val) + /* "PyCafe.pyx":2855 + * mvUInt8[ij] = ui8val[ij] + * free(ui8val) + * return mvUInt8 # <<<<<<<<<<<<<< * - * return mvShort # <<<<<<<<<<<<<< - * - * elif dtcheck in [CAFE_LONG]: + * elif dtcheck in [CAFE_SHORT]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_10 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2856, __pyx_L1_error) + __pyx_t_10 = __pyx_memoryview_fromslice(__pyx_v_mvUInt8, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_uint8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_uint8_t, 0);; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_r = __pyx_t_10; __pyx_t_10 = 0; @@ -67946,9 +68653,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C } __pyx_L71:; - /* "PyCafe.pyx":2775 - * # end=time.time() - * #print ("END TIME SHORT", end - start) + /* "PyCafe.pyx":2783 + * + * #nelemMethod = min(len(ui8val), nelemMemory) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * # np.empty preferred, else mvInt does not get correct value for first couple of array elements * @@ -67958,34 +68665,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C /* "PyCafe.pyx":2767 * return mvStr * - * elif dtcheck in [CAFE_SHORT, CAFE_CHAR]: # <<<<<<<<<<<<<< + * elif dtcheck in [CAFE_CHAR]: # <<<<<<<<<<<<<< * - * i16val = malloc(nelemMemory * sizeof(np.int16)) + * ui8val = malloc(nelemMemory * sizeof(np.uint8)) */ break; - case CAFE_LONG: + case CAFE_SHORT: - /* "PyCafe.pyx":2860 - * elif dtcheck in [CAFE_LONG]: + /* "PyCafe.pyx":2859 + * elif dtcheck in [CAFE_SHORT]: * - * ival = malloc(nelemMemory * sizeof(np.int32)) # <<<<<<<<<<<<<< + * i16val = malloc(nelemMemory * sizeof(np.int16)) # <<<<<<<<<<<<<< + * # start=time.time() * with nogil: - * status = self._c_cafe.getLongArray(handle, ival) */ - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2860, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2859, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_int32); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2860, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_int16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2859, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_v_ival = ((int *)malloc((__pyx_v_nelemMemory * (sizeof(__pyx_t_3))))); + __pyx_v_i16val = ((short *)malloc((__pyx_v_nelemMemory * (sizeof(__pyx_t_3))))); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "PyCafe.pyx":2861 - * - * ival = malloc(nelemMemory * sizeof(np.int32)) + * i16val = malloc(nelemMemory * sizeof(np.int16)) + * # start=time.time() * with nogil: # <<<<<<<<<<<<<< - * status = self._c_cafe.getLongArray(handle, ival) - * + * status = self._c_cafe.getShortArray(handle, i16val) + * # end=time.time() */ { #ifdef WITH_THREAD @@ -67996,21 +68703,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C /*try:*/ { /* "PyCafe.pyx":2862 - * ival = malloc(nelemMemory * sizeof(np.int32)) + * # start=time.time() * with nogil: - * status = self._c_cafe.getLongArray(handle, ival) # <<<<<<<<<<<<<< - * - * if status == ICAFE_NORMAL: + * status = self._c_cafe.getShortArray(handle, i16val) # <<<<<<<<<<<<<< + * # end=time.time() + * #print ("END TIME SHORT", end - start) */ - __pyx_v_status = __pyx_v_self->_c_cafe->getLongArray(__pyx_v_handle, __pyx_v_ival); + __pyx_v_status = __pyx_v_self->_c_cafe->getShortArray(__pyx_v_handle, __pyx_v_i16val); } /* "PyCafe.pyx":2861 - * - * ival = malloc(nelemMemory * sizeof(np.int32)) + * i16val = malloc(nelemMemory * sizeof(np.int16)) + * # start=time.time() * with nogil: # <<<<<<<<<<<<<< - * status = self._c_cafe.getLongArray(handle, ival) - * + * status = self._c_cafe.getShortArray(handle, i16val) + * # end=time.time() */ /*finally:*/ { /*normal exit:*/{ @@ -68024,9 +68731,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C } } - /* "PyCafe.pyx":2864 - * status = self._c_cafe.getLongArray(handle, ival) - * + /* "PyCafe.pyx":2865 + * # end=time.time() + * #print ("END TIME SHORT", end - start) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * # np.empty preferred, else mvInt does not get correct value for first couple of array elements * @@ -68034,44 +68741,44 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2869 - * # nelemMethod=self.hh.getnelemMethod(handle) + /* "PyCafe.pyx":2868 + * # np.empty preferred, else mvInt does not get correct value for first couple of array elements * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< * - * # elif dt in ['np.intc','np.int_','np.long','np.ulong','np.ushort','np.int32','np.int64','np.uint32','np.uint64']: + * # ##mvInt=ival */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2869, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2868, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; goto __pyx_L119_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2869, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2868, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L119_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2869, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2868, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; goto __pyx_L119_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2869, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2868, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L119_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2869, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2868, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); __pyx_t_2 = __pyx_t_7; __pyx_L119_bool_binop_done:; @@ -68079,23 +68786,37 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_7 = (__pyx_t_2 != 0); if (__pyx_t_7) { - /* "PyCafe.pyx":2873 - * # elif dt in ['np.intc','np.int_','np.long','np.ulong','np.ushort','np.int32','np.int64','np.uint32','np.uint64']: + /* "PyCafe.pyx":2874 + * # ##set_base(arr, ival) * - * if dt in ['np.int32', 'int32']: # <<<<<<<<<<<<<< - * mvInt32 = np.empty( - * nelemMethod, dtype=np.int32, order='C') + * if dt in ['np.short', 'np.int16', 'short', 'int16']: # <<<<<<<<<<<<<< + * mvShort = np.empty( + * nelemMethod, dtype=np.int16, order='C') */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_6 = __pyx_v_dt; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_int32, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2873, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_short, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2874, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_7 = __pyx_t_5; goto __pyx_L125_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_int32, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2873, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_int16, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2874, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_5 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_7 = __pyx_t_2; + goto __pyx_L125_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_short, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2874, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_2 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_7 = __pyx_t_5; + goto __pyx_L125_bool_binop_done; + } + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_int16, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2874, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 != 0); __pyx_t_7 = __pyx_t_2; __pyx_L125_bool_binop_done:; @@ -68103,130 +68824,130 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_7 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2874 + /* "PyCafe.pyx":2875 * - * if dt in ['np.int32', 'int32']: - * mvInt32 = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.int32, order='C') + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2874, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2874, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2875 - * if dt in ['np.int32', 'int32']: - * mvInt32 = np.empty( - * nelemMethod, dtype=np.int32, order='C') # <<<<<<<<<<<<<< + /* "PyCafe.pyx":2876 + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( + * nelemMethod, dtype=np.int16, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvInt32[ij] = ival[ij] + * mvShort[ij] = i16val[ij] */ - __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2875, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "PyCafe.pyx":2874 + /* "PyCafe.pyx":2875 * - * if dt in ['np.int32', 'int32']: - * mvInt32 = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.int32, order='C') + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2874, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2875 - * if dt in ['np.int32', 'int32']: - * mvInt32 = np.empty( - * nelemMethod, dtype=np.int32, order='C') # <<<<<<<<<<<<<< + /* "PyCafe.pyx":2876 + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( + * nelemMethod, dtype=np.int16, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvInt32[ij] = ival[ij] + * mvShort[ij] = i16val[ij] */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2875, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2875, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int32); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2875, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 2875, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 2876, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2875, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2876, __pyx_L1_error) - /* "PyCafe.pyx":2874 + /* "PyCafe.pyx":2875 * - * if dt in ['np.int32', 'int32']: - * mvInt32 = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.int32, order='C') + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2874, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_27 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int32_t(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_27.memview)) __PYX_ERR(3, 2874, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(3, 2875, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_mvInt32 = __pyx_t_27; - __pyx_t_27.memview = NULL; - __pyx_t_27.data = NULL; + __pyx_v_mvShort = __pyx_t_19; + __pyx_t_19.memview = NULL; + __pyx_t_19.data = NULL; - /* "PyCafe.pyx":2876 - * mvInt32 = np.empty( - * nelemMethod, dtype=np.int32, order='C') + /* "PyCafe.pyx":2877 + * mvShort = np.empty( + * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * mvInt32[ij] = ival[ij] - * free(ival) + * mvShort[ij] = i16val[ij] + * free(i16val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2877 - * nelemMethod, dtype=np.int32, order='C') + /* "PyCafe.pyx":2878 + * nelemMethod, dtype=np.int16, order='C') * for ij in range(0, nelemMethod): - * mvInt32[ij] = ival[ij] # <<<<<<<<<<<<<< - * free(ival) - * return np.array(mvInt32) + * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * return np.array(mvShort) */ - __pyx_t_28 = __pyx_v_ij; + __pyx_t_27 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_28 >= (size_t)__pyx_v_mvInt32.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_27 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2877, __pyx_L1_error) + __PYX_ERR(3, 2878, __pyx_L1_error) } - *((__pyx_t_5numpy_int32_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int32_t *) __pyx_v_mvInt32.data) + __pyx_t_28)) )) = ((__pyx_t_5numpy_int32_t)(__pyx_v_ival[__pyx_v_ij])); + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_27)) )) = ((__pyx_t_5numpy_int16_t)(__pyx_v_i16val[__pyx_v_ij])); } - /* "PyCafe.pyx":2878 - * for ij in range(0, nelemMethod): - * mvInt32[ij] = ival[ij] - * free(ival) # <<<<<<<<<<<<<< - * return np.array(mvInt32) - * elif dt in ['np.uint32', 'uint32']: - */ - free(__pyx_v_ival); - /* "PyCafe.pyx":2879 - * mvInt32[ij] = ival[ij] - * free(ival) - * return np.array(mvInt32) # <<<<<<<<<<<<<< - * elif dt in ['np.uint32', 'uint32']: - * mvUInt32 = np.empty( + * for ij in range(0, nelemMethod): + * mvShort[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * return np.array(mvShort) + * + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":2880 + * mvShort[ij] = i16val[ij] + * free(i16val) + * return np.array(mvShort) # <<<<<<<<<<<<<< + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2879, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2879, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_mvInt32, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int32_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int32_t, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2879, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { @@ -68241,171 +68962,199 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_9 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_10, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_3); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2879, __pyx_L1_error) + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_r = __pyx_t_9; __pyx_t_9 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2873 - * # elif dt in ['np.intc','np.int_','np.long','np.ulong','np.ushort','np.int32','np.int64','np.uint32','np.uint64']: + /* "PyCafe.pyx":2874 + * # ##set_base(arr, ival) * - * if dt in ['np.int32', 'int32']: # <<<<<<<<<<<<<< - * mvInt32 = np.empty( - * nelemMethod, dtype=np.int32, order='C') + * if dt in ['np.short', 'np.int16', 'short', 'int16']: # <<<<<<<<<<<<<< + * mvShort = np.empty( + * nelemMethod, dtype=np.int16, order='C') */ goto __pyx_L124; } - /* "PyCafe.pyx":2880 - * free(ival) - * return np.array(mvInt32) - * elif dt in ['np.uint32', 'uint32']: # <<<<<<<<<<<<<< - * mvUInt32 = np.empty( - * nelemMethod, dtype=np.uint32, order='C') + /* "PyCafe.pyx":2882 + * return np.array(mvShort) + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: # <<<<<<<<<<<<<< + * mvInt8 = np.empty( + * nelemMethod, dtype=np.int8, order='C') */ __Pyx_INCREF(__pyx_v_dt); __pyx_t_6 = __pyx_v_dt; - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_uint32, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2880, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_int8, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2882, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; - goto __pyx_L129_bool_binop_done; + goto __pyx_L131_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_uint32, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2880, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_bool, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2882, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_5 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_2 = __pyx_t_7; + goto __pyx_L131_bool_binop_done; + } + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_byte, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2882, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_7 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_2 = __pyx_t_5; + goto __pyx_L131_bool_binop_done; + } + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_bool, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2882, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_5 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_2 = __pyx_t_7; + goto __pyx_L131_bool_binop_done; + } + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_byte, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2882, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_7 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_2 = __pyx_t_5; + goto __pyx_L131_bool_binop_done; + } + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_int8, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2882, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); __pyx_t_2 = __pyx_t_7; - __pyx_L129_bool_binop_done:; + __pyx_L131_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = (__pyx_t_2 != 0); if (__pyx_t_7) { - /* "PyCafe.pyx":2881 - * return np.array(mvInt32) - * elif dt in ['np.uint32', 'uint32']: - * mvUInt32 = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.uint32, order='C') + /* "PyCafe.pyx":2883 + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2881, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2881, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":2882 - * elif dt in ['np.uint32', 'uint32']: - * mvUInt32 = np.empty( - * nelemMethod, dtype=np.uint32, order='C') # <<<<<<<<<<<<<< + /* "PyCafe.pyx":2884 + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( + * nelemMethod, dtype=np.int8, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvUInt32[ij] = ival[ij] + * mvInt8[ij] = i16val[ij] */ - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2882, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - /* "PyCafe.pyx":2881 - * return np.array(mvInt32) - * elif dt in ['np.uint32', 'uint32']: - * mvUInt32 = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.uint32, order='C') + /* "PyCafe.pyx":2883 + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2881, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":2882 - * elif dt in ['np.uint32', 'uint32']: - * mvUInt32 = np.empty( - * nelemMethod, dtype=np.uint32, order='C') # <<<<<<<<<<<<<< + /* "PyCafe.pyx":2884 + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( + * nelemMethod, dtype=np.int8, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvUInt32[ij] = ival[ij] + * mvInt8[ij] = i16val[ij] */ - __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2882, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2882, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_uint32); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2882, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_int8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(3, 2882, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(3, 2884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2882, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2884, __pyx_L1_error) - /* "PyCafe.pyx":2881 - * return np.array(mvInt32) - * elif dt in ['np.uint32', 'uint32']: - * mvUInt32 = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.uint32, order='C') + /* "PyCafe.pyx":2883 + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2881, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_29 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_uint32_t(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_29.memview)) __PYX_ERR(3, 2881, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int8_t(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_20.memview)) __PYX_ERR(3, 2883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_mvUInt32 = __pyx_t_29; - __pyx_t_29.memview = NULL; - __pyx_t_29.data = NULL; + __pyx_v_mvInt8 = __pyx_t_20; + __pyx_t_20.memview = NULL; + __pyx_t_20.data = NULL; - /* "PyCafe.pyx":2883 - * mvUInt32 = np.empty( - * nelemMethod, dtype=np.uint32, order='C') + /* "PyCafe.pyx":2885 + * mvInt8 = np.empty( + * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * mvUInt32[ij] = ival[ij] - * free(ival) + * mvInt8[ij] = i16val[ij] + * free(i16val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2884 - * nelemMethod, dtype=np.uint32, order='C') + /* "PyCafe.pyx":2886 + * nelemMethod, dtype=np.int8, order='C') * for ij in range(0, nelemMethod): - * mvUInt32[ij] = ival[ij] # <<<<<<<<<<<<<< - * free(ival) - * return np.array(mvUInt32) + * mvInt8[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * return np.array(mvInt8) */ - __pyx_t_30 = __pyx_v_ij; + __pyx_t_28 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_30 >= (size_t)__pyx_v_mvUInt32.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_28 >= (size_t)__pyx_v_mvInt8.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2884, __pyx_L1_error) + __PYX_ERR(3, 2886, __pyx_L1_error) } - *((__pyx_t_5numpy_uint32_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_uint32_t *) __pyx_v_mvUInt32.data) + __pyx_t_30)) )) = ((__pyx_t_5numpy_uint32_t)(__pyx_v_ival[__pyx_v_ij])); + *((__pyx_t_5numpy_int8_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int8_t *) __pyx_v_mvInt8.data) + __pyx_t_28)) )) = ((__pyx_t_5numpy_int8_t)(__pyx_v_i16val[__pyx_v_ij])); } - /* "PyCafe.pyx":2885 + /* "PyCafe.pyx":2887 * for ij in range(0, nelemMethod): - * mvUInt32[ij] = ival[ij] - * free(ival) # <<<<<<<<<<<<<< - * return np.array(mvUInt32) + * mvInt8[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * return np.array(mvInt8) * */ - free(__pyx_v_ival); + free(__pyx_v_i16val); - /* "PyCafe.pyx":2886 - * mvUInt32[ij] = ival[ij] - * free(ival) - * return np.array(mvUInt32) # <<<<<<<<<<<<<< + /* "PyCafe.pyx":2888 + * mvInt8[ij] = i16val[ij] + * free(i16val) + * return np.array(mvInt8) # <<<<<<<<<<<<<< * - * # elif dt in ['np.int64','int64']: + * elif dt in ['uchar', 'np.uint8', 'uint8']: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2886, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2886, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_mvUInt32, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_uint32_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_uint32_t, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2886, __pyx_L1_error) + __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_mvInt8, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int8_t, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { @@ -68420,148 +69169,178 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_4 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_9); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2886, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2880 - * free(ival) - * return np.array(mvInt32) - * elif dt in ['np.uint32', 'uint32']: # <<<<<<<<<<<<<< - * mvUInt32 = np.empty( - * nelemMethod, dtype=np.uint32, order='C') + /* "PyCafe.pyx":2882 + * return np.array(mvShort) + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: # <<<<<<<<<<<<<< + * mvInt8 = np.empty( + * nelemMethod, dtype=np.int8, order='C') */ goto __pyx_L124; } - /* "PyCafe.pyx":2902 + /* "PyCafe.pyx":2890 + * return np.array(mvInt8) * - * else: - * mvInt = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.int32, order='C') + * elif dt in ['uchar', 'np.uint8', 'uint8']: # <<<<<<<<<<<<<< + * mvUInt8 = np.empty( + * nelemMethod, dtype=np.uint8, order='C') + */ + __Pyx_INCREF(__pyx_v_dt); + __pyx_t_6 = __pyx_v_dt; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_uchar, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2890, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_2 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_7 = __pyx_t_5; + goto __pyx_L139_bool_binop_done; + } + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_uint8, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2890, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_5 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_7 = __pyx_t_2; + goto __pyx_L139_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_uint8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2890, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_2 != 0); + __pyx_t_7 = __pyx_t_5; + __pyx_L139_bool_binop_done:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = (__pyx_t_7 != 0); + if (__pyx_t_5) { + + /* "PyCafe.pyx":2891 + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): */ - /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2902, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2902, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2903 - * else: - * mvInt = np.empty( - * nelemMethod, dtype=np.int32, order='C') # <<<<<<<<<<<<<< + /* "PyCafe.pyx":2892 + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( + * nelemMethod, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvInt[ij] = ival[ij] + * mvUInt8[ij] = i16val[ij] */ - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2903, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "PyCafe.pyx":2902 + /* "PyCafe.pyx":2891 * - * else: - * mvInt = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.int32, order='C') + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2902, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":2903 - * else: - * mvInt = np.empty( - * nelemMethod, dtype=np.int32, order='C') # <<<<<<<<<<<<<< + /* "PyCafe.pyx":2892 + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( + * nelemMethod, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * mvInt[ij] = ival[ij] + * mvUInt8[ij] = i16val[ij] */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2903, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2903, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_int32); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2903, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_uint8); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(3, 2903, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(3, 2892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2903, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2892, __pyx_L1_error) - /* "PyCafe.pyx":2902 + /* "PyCafe.pyx":2891 * - * else: - * mvInt = np.empty( # <<<<<<<<<<<<<< - * nelemMethod, dtype=np.int32, order='C') + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2902, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_31 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_31.memview)) __PYX_ERR(3, 2902, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_uint8_t(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(3, 2891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_v_mvInt = __pyx_t_31; - __pyx_t_31.memview = NULL; - __pyx_t_31.data = NULL; + __pyx_v_mvUInt8 = __pyx_t_22; + __pyx_t_22.memview = NULL; + __pyx_t_22.data = NULL; - /* "PyCafe.pyx":2904 - * mvInt = np.empty( - * nelemMethod, dtype=np.int32, order='C') + /* "PyCafe.pyx":2893 + * mvUInt8 = np.empty( + * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< - * mvInt[ij] = ival[ij] - * free(ival) + * mvUInt8[ij] = i16val[ij] + * free(i16val) */ __pyx_t_1 = __pyx_v_nelemMethod; __pyx_t_11 = __pyx_t_1; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2905 - * nelemMethod, dtype=np.int32, order='C') + /* "PyCafe.pyx":2894 + * nelemMethod, dtype=np.uint8, order='C') * for ij in range(0, nelemMethod): - * mvInt[ij] = ival[ij] # <<<<<<<<<<<<<< - * free(ival) - * return np.array(mvInt) # arr + * mvUInt8[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * return np.array(mvUInt8) */ - __pyx_t_32 = __pyx_v_ij; + __pyx_t_29 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_32 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_29 >= (size_t)__pyx_v_mvUInt8.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2905, __pyx_L1_error) + __PYX_ERR(3, 2894, __pyx_L1_error) } - *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_32)) )) = ((__pyx_t_5numpy_int32_t)(__pyx_v_ival[__pyx_v_ij])); + *((__pyx_t_5numpy_uint8_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_uint8_t *) __pyx_v_mvUInt8.data) + __pyx_t_29)) )) = ((__pyx_t_5numpy_uint8_t)(__pyx_v_i16val[__pyx_v_ij])); } - /* "PyCafe.pyx":2906 + /* "PyCafe.pyx":2895 * for ij in range(0, nelemMethod): - * mvInt[ij] = ival[ij] - * free(ival) # <<<<<<<<<<<<<< - * return np.array(mvInt) # arr + * mvUInt8[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * return np.array(mvUInt8) * */ - free(__pyx_v_ival); + free(__pyx_v_i16val); - /* "PyCafe.pyx":2907 - * mvInt[ij] = ival[ij] - * free(ival) - * return np.array(mvInt) # arr # <<<<<<<<<<<<<< + /* "PyCafe.pyx":2896 + * mvUInt8[ij] = i16val[ij] + * free(i16val) + * return np.array(mvUInt8) # <<<<<<<<<<<<<< * - * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * else: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2907, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2907, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2907, __pyx_L1_error) + __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_mvUInt8, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_uint8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_uint8_t, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { @@ -68576,26 +69355,1334 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_10 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2907, __pyx_L1_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_r = __pyx_t_10; __pyx_t_10 = 0; goto __pyx_L0; + + /* "PyCafe.pyx":2890 + * return np.array(mvInt8) + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: # <<<<<<<<<<<<<< + * mvUInt8 = np.empty( + * nelemMethod, dtype=np.uint8, order='C') + */ + goto __pyx_L124; + } + + /* "PyCafe.pyx":2900 + * else: + * + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int16, order='C') + * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2900, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2900, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "PyCafe.pyx":2901 + * + * 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): + */ + __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "PyCafe.pyx":2900 + * else: + * + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int16, order='C') + * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2900, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_10); + __pyx_t_10 = 0; + + /* "PyCafe.pyx":2901 + * + * 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): + */ + __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int16); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(3, 2901, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2901, __pyx_L1_error) + + /* "PyCafe.pyx":2900 + * else: + * + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int16, order='C') + * #mvShortNP = np.ndarray(buffer=np.array(i16val), dtype=np.int16, order='C') + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_4, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2900, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_8, PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(3, 2900, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_mvShort = __pyx_t_19; + __pyx_t_19.memview = NULL; + __pyx_t_19.data = NULL; + + /* "PyCafe.pyx":2903 + * 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) + */ + __pyx_t_1 = __pyx_v_nelemMethod; + __pyx_t_11 = __pyx_t_1; + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_ij = __pyx_t_12; + + /* "PyCafe.pyx":2904 + * #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) + * + */ + __pyx_t_30 = __pyx_v_ij; + __pyx_t_16 = -1; + if (unlikely(__pyx_t_30 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_16 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_16); + __PYX_ERR(3, 2904, __pyx_L1_error) + } + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_30)) )) = ((__pyx_t_5numpy_int16_t)(__pyx_v_i16val[__pyx_v_ij])); + } + + /* "PyCafe.pyx":2908 + * + * # aaa=np.full(nelemMethod,ival + */ + goto __pyx_L118; + } + + /* "PyCafe.pyx":2912 + * return np.array(mvShort) # arr + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< + * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * for ij in range(0, nelemMethod): + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_6 = __pyx_v_art; + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2912, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_7 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_5 = __pyx_t_2; + goto __pyx_L146_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2912, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_2 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_5 = __pyx_t_7; + goto __pyx_L146_bool_binop_done; + } + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2912, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_7 != 0); + __pyx_t_5 = __pyx_t_2; + __pyx_L146_bool_binop_done:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_2 = (__pyx_t_5 != 0); + if (__pyx_t_2) { + + /* "PyCafe.pyx":2913 + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemMethod): + * mvShort[ij] = i16val[ij] + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_int16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2913, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(3, 2913, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_mvShort = __pyx_t_19; + __pyx_t_19.memview = NULL; + __pyx_t_19.data = NULL; + + /* "PyCafe.pyx":2914 + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< + * mvShort[ij] = i16val[ij] + * free(i16val) + */ + __pyx_t_1 = __pyx_v_nelemMethod; + __pyx_t_11 = __pyx_t_1; + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_ij = __pyx_t_12; + + /* "PyCafe.pyx":2915 + * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * for ij in range(0, nelemMethod): + * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * + */ + __pyx_t_31 = __pyx_v_ij; + __pyx_t_16 = -1; + if (unlikely(__pyx_t_31 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_16 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_16); + __PYX_ERR(3, 2915, __pyx_L1_error) + } + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_31)) )) = ((short)(__pyx_v_i16val[__pyx_v_ij])); + } + + /* "PyCafe.pyx":2916 + * for ij in range(0, nelemMethod): + * mvShort[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * + * return memoryview(mvShort) + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":2918 + * free(i16val) + * + * return memoryview(mvShort) # <<<<<<<<<<<<<< + * + * elif art in ['array', 'array.array']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_r = __pyx_t_10; + __pyx_t_10 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":2912 + * return np.array(mvShort) # arr + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< + * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * for ij in range(0, nelemMethod): + */ + goto __pyx_L118; + } + + /* "PyCafe.pyx":2920 + * return memoryview(mvShort) + * + * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< + * + * a = array.array('h') + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_6 = __pyx_v_art; + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2920, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_5 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_2 = __pyx_t_7; + goto __pyx_L151_bool_binop_done; + } + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2920, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_7 != 0); + __pyx_t_2 = __pyx_t_5; + __pyx_L151_bool_binop_done:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = (__pyx_t_2 != 0); + if (__pyx_t_5) { + + /* "PyCafe.pyx":2922 + * elif art in ['array', 'array.array']: + * + * a = array.array('h') # <<<<<<<<<<<<<< + * for ij in range(0, nelemMethod): + * a.append( < short > i16val[ij]) + */ + __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_v_a = ((arrayobject *)__pyx_t_10); + __pyx_t_10 = 0; + + /* "PyCafe.pyx":2923 + * + * a = array.array('h') + * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< + * a.append( < short > i16val[ij]) + * free(i16val) + */ + __pyx_t_1 = __pyx_v_nelemMethod; + __pyx_t_11 = __pyx_t_1; + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_ij = __pyx_t_12; + + /* "PyCafe.pyx":2924 + * a = array.array('h') + * for ij in range(0, nelemMethod): + * a.append( < short > i16val[ij]) # <<<<<<<<<<<<<< + * free(i16val) + * return a + */ + __pyx_t_10 = __Pyx_PyInt_From_short(((short)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_17 = __Pyx_PyObject_Append(((PyObject *)__pyx_v_a), __pyx_t_10); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 2924, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + + /* "PyCafe.pyx":2925 + * for ij in range(0, nelemMethod): + * a.append( < short > i16val[ij]) + * free(i16val) # <<<<<<<<<<<<<< + * return a + * + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":2926 + * a.append( < short > i16val[ij]) + * free(i16val) + * return a # <<<<<<<<<<<<<< + * + * elif art in ['ctypes', 'ctype']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_a)); + __pyx_r = ((PyObject *)__pyx_v_a); + goto __pyx_L0; + + /* "PyCafe.pyx":2920 + * return memoryview(mvShort) + * + * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< + * + * a = array.array('h') + */ + goto __pyx_L118; + } + + /* "PyCafe.pyx":2928 + * return a + * + * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< + * + * ctypesArray16 = (ctypes.c_int16*nelemMethod)() + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_6 = __pyx_v_art; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2928, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_2 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_5 = __pyx_t_7; + goto __pyx_L155_bool_binop_done; + } + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2928, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_7 != 0); + __pyx_t_5 = __pyx_t_2; + __pyx_L155_bool_binop_done:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_2 = (__pyx_t_5 != 0); + if (__pyx_t_2) { + + /* "PyCafe.pyx":2930 + * elif art in ['ctypes', 'ctype']: + * + * ctypesArray16 = (ctypes.c_int16*nelemMethod)() # <<<<<<<<<<<<<< + * for ij in range(0, nelemMethod): + * ctypesArray16[ij] = i16val[ij] + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_c_int16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_ctypesArray16 = __pyx_t_10; + __pyx_t_10 = 0; + + /* "PyCafe.pyx":2931 + * + * ctypesArray16 = (ctypes.c_int16*nelemMethod)() + * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< + * ctypesArray16[ij] = i16val[ij] + * free(i16val) + */ + __pyx_t_1 = __pyx_v_nelemMethod; + __pyx_t_11 = __pyx_t_1; + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_ij = __pyx_t_12; + + /* "PyCafe.pyx":2932 + * ctypesArray16 = (ctypes.c_int16*nelemMethod)() + * for ij in range(0, nelemMethod): + * ctypesArray16[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * return ctypesArray16 + */ + __pyx_t_10 = __Pyx_PyInt_From_short(((short)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2932, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray16, __pyx_v_ij, __pyx_t_10, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 2932, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + + /* "PyCafe.pyx":2933 + * for ij in range(0, nelemMethod): + * ctypesArray16[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * return ctypesArray16 + * + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":2934 + * ctypesArray16[ij] = i16val[ij] + * free(i16val) + * return ctypesArray16 # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_ctypesArray16); + __pyx_r = __pyx_v_ctypesArray16; + goto __pyx_L0; + + /* "PyCafe.pyx":2928 + * return a + * + * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< + * + * ctypesArray16 = (ctypes.c_int16*nelemMethod)() + */ + goto __pyx_L118; + } + + /* "PyCafe.pyx":2937 + * + * else: + * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") + */ + /*else*/ { + + /* "PyCafe.pyx":2938 + * else: + * print("Unknow array type in user request for art='", + * art, "'. Possible types are:") # <<<<<<<<<<<<<< + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") + */ + __pyx_t_10 = PyTuple_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2937, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); + __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); + __Pyx_INCREF(__pyx_v_art); + __Pyx_GIVEREF(__pyx_v_art); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_v_art); + __Pyx_INCREF(__pyx_kp_u_Possible_types_are); + __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); + PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_kp_u_Possible_types_are); + + /* "PyCafe.pyx":2937 + * + * else: + * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2937, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "PyCafe.pyx":2939 + * 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') + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "PyCafe.pyx":2940 + * 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): + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2940, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "PyCafe.pyx":2941 + * 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] + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2941, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(3, 2941, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_mvShort = __pyx_t_19; + __pyx_t_19.memview = NULL; + __pyx_t_19.data = NULL; + + /* "PyCafe.pyx":2942 + * print("Returning memoryview") + * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< + * mvShort[ij] = i16val[ij] + * free(i16val) + */ + __pyx_t_1 = __pyx_v_nelemMethod; + __pyx_t_11 = __pyx_t_1; + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_ij = __pyx_t_12; + + /* "PyCafe.pyx":2943 + * mvShort = np.empty(nelemMethod, dtype=np.int16, order='C') + * for ij in range(0, nelemMethod): + * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * + */ + __pyx_t_32 = __pyx_v_ij; + __pyx_t_16 = -1; + if (unlikely(__pyx_t_32 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_16 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_16); + __PYX_ERR(3, 2943, __pyx_L1_error) + } + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_32)) )) = ((short)(__pyx_v_i16val[__pyx_v_ij])); + } + + /* "PyCafe.pyx":2944 + * for ij in range(0, nelemMethod): + * mvShort[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * + * return mvShort + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":2946 + * free(i16val) + * + * return mvShort # <<<<<<<<<<<<<< + * + * elif dtcheck in [CAFE_LONG]: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2946, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; + goto __pyx_L0; + } + __pyx_L118:; + + /* "PyCafe.pyx":2865 + * # end=time.time() + * #print ("END TIME SHORT", end - start) + * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< + * # np.empty preferred, else mvInt does not get correct value for first couple of array elements + * + */ + } + + /* "PyCafe.pyx":2857 + * return mvUInt8 + * + * elif dtcheck in [CAFE_SHORT]: # <<<<<<<<<<<<<< + * + * i16val = malloc(nelemMemory * sizeof(np.int16)) + */ + break; + case CAFE_LONG: + + /* "PyCafe.pyx":2950 + * elif dtcheck in [CAFE_LONG]: + * + * ival = malloc(nelemMemory * sizeof(np.int32)) # <<<<<<<<<<<<<< + * with nogil: + * status = self._c_cafe.getLongArray(handle, ival) + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2950, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_int32); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2950, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_ival = ((int *)malloc((__pyx_v_nelemMemory * (sizeof(__pyx_t_4))))); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "PyCafe.pyx":2951 + * + * ival = malloc(nelemMemory * sizeof(np.int32)) + * with nogil: # <<<<<<<<<<<<<< + * status = self._c_cafe.getLongArray(handle, ival) + * + */ + { + #ifdef WITH_THREAD + PyThreadState *_save; + Py_UNBLOCK_THREADS + __Pyx_FastGIL_Remember(); + #endif + /*try:*/ { + + /* "PyCafe.pyx":2952 + * ival = malloc(nelemMemory * sizeof(np.int32)) + * with nogil: + * status = self._c_cafe.getLongArray(handle, ival) # <<<<<<<<<<<<<< + * + * if status == ICAFE_NORMAL: + */ + __pyx_v_status = __pyx_v_self->_c_cafe->getLongArray(__pyx_v_handle, __pyx_v_ival); + } + + /* "PyCafe.pyx":2951 + * + * ival = malloc(nelemMemory * sizeof(np.int32)) + * with nogil: # <<<<<<<<<<<<<< + * status = self._c_cafe.getLongArray(handle, ival) + * + */ + /*finally:*/ { + /*normal exit:*/{ + #ifdef WITH_THREAD + __Pyx_FastGIL_Forget(); + Py_BLOCK_THREADS + #endif + goto __pyx_L163; + } + __pyx_L163:; + } + } + + /* "PyCafe.pyx":2954 + * 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 + * + */ + __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); + if (__pyx_t_2) { + + /* "PyCafe.pyx":2959 * # nelemMethod=self.hh.getnelemMethod(handle) * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< * * # elif dt in ['np.intc','np.int_','np.long','np.ulong','np.ushort','np.int32','np.int64','np.uint32','np.uint64']: */ - goto __pyx_L118; + __Pyx_INCREF(__pyx_v_art); + __pyx_t_6 = __pyx_v_art; + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2959, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_5 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_2 = __pyx_t_7; + goto __pyx_L166_bool_binop_done; + } + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2959, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_7 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_2 = __pyx_t_5; + goto __pyx_L166_bool_binop_done; + } + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2959, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_5 != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_2 = __pyx_t_7; + goto __pyx_L166_bool_binop_done; + } + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2959, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_7 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_2 = __pyx_t_5; + goto __pyx_L166_bool_binop_done; + } + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2959, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_5 != 0); + __pyx_t_2 = __pyx_t_7; + __pyx_L166_bool_binop_done:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = (__pyx_t_2 != 0); + if (__pyx_t_7) { + + /* "PyCafe.pyx":2963 + * # 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') + */ + __Pyx_INCREF(__pyx_v_dt); + __pyx_t_6 = __pyx_v_dt; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_int32, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2963, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_2 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_7 = __pyx_t_5; + goto __pyx_L172_bool_binop_done; + } + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_int32, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2963, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_5 != 0); + __pyx_t_7 = __pyx_t_2; + __pyx_L172_bool_binop_done:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_2 = (__pyx_t_7 != 0); + if (__pyx_t_2) { + + /* "PyCafe.pyx":2964 + * + * if dt in ['np.int32', 'int32']: + * mvInt32 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "PyCafe.pyx":2965 + * 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] + */ + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "PyCafe.pyx":2964 + * + * if dt in ['np.int32', 'int32']: + * mvInt32 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): + */ + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); + __pyx_t_4 = 0; + + /* "PyCafe.pyx":2965 + * 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] + */ + __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_int32); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(3, 2965, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2965, __pyx_L1_error) + + /* "PyCafe.pyx":2964 + * + * if dt in ['np.int32', 'int32']: + * mvInt32 = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_33 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int32_t(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_33.memview)) __PYX_ERR(3, 2964, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_mvInt32 = __pyx_t_33; + __pyx_t_33.memview = NULL; + __pyx_t_33.data = NULL; + + /* "PyCafe.pyx":2966 + * mvInt32 = np.empty( + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< + * mvInt32[ij] = ival[ij] + * free(ival) + */ + __pyx_t_1 = __pyx_v_nelemMethod; + __pyx_t_11 = __pyx_t_1; + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_ij = __pyx_t_12; + + /* "PyCafe.pyx":2967 + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): + * mvInt32[ij] = ival[ij] # <<<<<<<<<<<<<< + * free(ival) + * return np.array(mvInt32) + */ + __pyx_t_34 = __pyx_v_ij; + __pyx_t_16 = -1; + if (unlikely(__pyx_t_34 >= (size_t)__pyx_v_mvInt32.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_16 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_16); + __PYX_ERR(3, 2967, __pyx_L1_error) + } + *((__pyx_t_5numpy_int32_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int32_t *) __pyx_v_mvInt32.data) + __pyx_t_34)) )) = ((__pyx_t_5numpy_int32_t)(__pyx_v_ival[__pyx_v_ij])); + } + + /* "PyCafe.pyx":2968 + * for ij in range(0, nelemMethod): + * mvInt32[ij] = ival[ij] + * free(ival) # <<<<<<<<<<<<<< + * return np.array(mvInt32) + * elif dt in ['np.uint32', 'uint32']: + */ + free(__pyx_v_ival); + + /* "PyCafe.pyx":2969 + * mvInt32[ij] = ival[ij] + * free(ival) + * return np.array(mvInt32) # <<<<<<<<<<<<<< + * elif dt in ['np.uint32', 'uint32']: + * mvUInt32 = np.empty( + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_mvInt32, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int32_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int32_t, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_3 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":2963 + * # 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') + */ + goto __pyx_L171; + } + + /* "PyCafe.pyx":2970 + * free(ival) + * return np.array(mvInt32) + * elif dt in ['np.uint32', 'uint32']: # <<<<<<<<<<<<<< + * mvUInt32 = np.empty( + * nelemMethod, dtype=np.uint32, order='C') + */ + __Pyx_INCREF(__pyx_v_dt); + __pyx_t_6 = __pyx_v_dt; + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_uint32, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2970, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_7 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_2 = __pyx_t_5; + goto __pyx_L176_bool_binop_done; + } + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_uint32, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2970, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_5 != 0); + __pyx_t_2 = __pyx_t_7; + __pyx_L176_bool_binop_done:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = (__pyx_t_2 != 0); + if (__pyx_t_7) { + + /* "PyCafe.pyx":2971 + * 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): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "PyCafe.pyx":2972 + * 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] + */ + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "PyCafe.pyx":2971 + * 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): + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + + /* "PyCafe.pyx":2972 + * 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] + */ + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_uint32); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(3, 2972, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2972, __pyx_L1_error) + + /* "PyCafe.pyx":2971 + * 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): + */ + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_35 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_uint32_t(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_35.memview)) __PYX_ERR(3, 2971, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_mvUInt32 = __pyx_t_35; + __pyx_t_35.memview = NULL; + __pyx_t_35.data = NULL; + + /* "PyCafe.pyx":2973 + * mvUInt32 = np.empty( + * nelemMethod, dtype=np.uint32, order='C') + * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< + * mvUInt32[ij] = ival[ij] + * free(ival) + */ + __pyx_t_1 = __pyx_v_nelemMethod; + __pyx_t_11 = __pyx_t_1; + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_ij = __pyx_t_12; + + /* "PyCafe.pyx":2974 + * nelemMethod, dtype=np.uint32, order='C') + * for ij in range(0, nelemMethod): + * mvUInt32[ij] = ival[ij] # <<<<<<<<<<<<<< + * free(ival) + * return np.array(mvUInt32) + */ + __pyx_t_36 = __pyx_v_ij; + __pyx_t_16 = -1; + if (unlikely(__pyx_t_36 >= (size_t)__pyx_v_mvUInt32.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_16 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_16); + __PYX_ERR(3, 2974, __pyx_L1_error) + } + *((__pyx_t_5numpy_uint32_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_uint32_t *) __pyx_v_mvUInt32.data) + __pyx_t_36)) )) = ((__pyx_t_5numpy_uint32_t)(__pyx_v_ival[__pyx_v_ij])); + } + + /* "PyCafe.pyx":2975 + * for ij in range(0, nelemMethod): + * mvUInt32[ij] = ival[ij] + * free(ival) # <<<<<<<<<<<<<< + * return np.array(mvUInt32) + * + */ + free(__pyx_v_ival); + + /* "PyCafe.pyx":2976 + * mvUInt32[ij] = ival[ij] + * free(ival) + * return np.array(mvUInt32) # <<<<<<<<<<<<<< + * + * # elif dt in ['np.int64','int64']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_mvUInt32, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_uint32_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_uint32_t, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_10; + __pyx_t_10 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":2970 + * free(ival) + * return np.array(mvInt32) + * elif dt in ['np.uint32', 'uint32']: # <<<<<<<<<<<<<< + * mvUInt32 = np.empty( + * nelemMethod, dtype=np.uint32, order='C') + */ + goto __pyx_L171; + } + + /* "PyCafe.pyx":2992 + * + * else: + * mvInt = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2992, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2992, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "PyCafe.pyx":2993 + * else: + * mvInt = np.empty( + * nelemMethod, dtype=np.int32, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemMethod): + * mvInt[ij] = ival[ij] + */ + __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2993, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "PyCafe.pyx":2992 + * + * else: + * mvInt = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2992, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_10); + __pyx_t_10 = 0; + + /* "PyCafe.pyx":2993 + * else: + * mvInt = np.empty( + * nelemMethod, dtype=np.int32, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemMethod): + * mvInt[ij] = ival[ij] + */ + __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2993, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2993, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_int32); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2993, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 2993, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2993, __pyx_L1_error) + + /* "PyCafe.pyx":2992 + * + * else: + * mvInt = np.empty( # <<<<<<<<<<<<<< + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): + */ + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2992, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_37 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_37.memview)) __PYX_ERR(3, 2992, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_mvInt = __pyx_t_37; + __pyx_t_37.memview = NULL; + __pyx_t_37.data = NULL; + + /* "PyCafe.pyx":2994 + * mvInt = np.empty( + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< + * mvInt[ij] = ival[ij] + * free(ival) + */ + __pyx_t_1 = __pyx_v_nelemMethod; + __pyx_t_11 = __pyx_t_1; + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_ij = __pyx_t_12; + + /* "PyCafe.pyx":2995 + * nelemMethod, dtype=np.int32, order='C') + * for ij in range(0, nelemMethod): + * mvInt[ij] = ival[ij] # <<<<<<<<<<<<<< + * free(ival) + * return np.array(mvInt) # arr + */ + __pyx_t_38 = __pyx_v_ij; + __pyx_t_16 = -1; + if (unlikely(__pyx_t_38 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_16 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_16); + __PYX_ERR(3, 2995, __pyx_L1_error) + } + *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_38)) )) = ((__pyx_t_5numpy_int32_t)(__pyx_v_ival[__pyx_v_ij])); + } + + /* "PyCafe.pyx":2996 + * for ij in range(0, nelemMethod): + * mvInt[ij] = ival[ij] + * free(ival) # <<<<<<<<<<<<<< + * return np.array(mvInt) # arr + * + */ + free(__pyx_v_ival); + + /* "PyCafe.pyx":2997 + * mvInt[ij] = ival[ij] + * free(ival) + * return np.array(mvInt) # arr # <<<<<<<<<<<<<< + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_9 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_10); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; + goto __pyx_L0; + } + __pyx_L171:; + + /* "PyCafe.pyx":2959 + * # nelemMethod=self.hh.getnelemMethod(handle) + * + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< + * + * # elif dt in ['np.intc','np.int_','np.long','np.ulong','np.ushort','np.int32','np.int64','np.uint32','np.uint64']: + */ + goto __pyx_L165; } - /* "PyCafe.pyx":2909 + /* "PyCafe.pyx":2999 * return np.array(mvInt) # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< @@ -68604,69 +70691,69 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2909, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2999, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_7 = __pyx_t_5; - goto __pyx_L135_bool_binop_done; + goto __pyx_L182_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2909, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2999, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 != 0); if (!__pyx_t_2) { } else { __pyx_t_7 = __pyx_t_2; - goto __pyx_L135_bool_binop_done; + goto __pyx_L182_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2909, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2999, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); __pyx_t_7 = __pyx_t_5; - __pyx_L135_bool_binop_done:; + __pyx_L182_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = (__pyx_t_7 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2910 + /* "PyCafe.pyx":3000 * * 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] */ - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2910, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2910, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2910, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2910, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_10); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_10); - __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2910, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2910, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int32); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2910, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int32); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(3, 3000, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 3000, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(3, 2910, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2910, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_4, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2910, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_31 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_8, PyBUF_WRITABLE); if (unlikely(!__pyx_t_31.memview)) __PYX_ERR(3, 2910, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_37 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_8, PyBUF_WRITABLE); if (unlikely(!__pyx_t_37.memview)) __PYX_ERR(3, 3000, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_mvInt = __pyx_t_31; - __pyx_t_31.memview = NULL; - __pyx_t_31.data = NULL; + __pyx_v_mvInt = __pyx_t_37; + __pyx_t_37.memview = NULL; + __pyx_t_37.data = NULL; - /* "PyCafe.pyx":2911 + /* "PyCafe.pyx":3001 * elif art in ['memoryview', 'mv', 'memoryviewslice']: * mvInt = np.empty(nelemMethod, dtype=np.int32, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -68678,24 +70765,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2912 + /* "PyCafe.pyx":3002 * mvInt = np.empty(nelemMethod, dtype=np.int32, order='C') * for ij in range(0, nelemMethod): * mvInt[ij] = ival[ij] # <<<<<<<<<<<<<< * free(ival) * return memoryview(mvInt) */ - __pyx_t_33 = __pyx_v_ij; + __pyx_t_39 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_33 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_39 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2912, __pyx_L1_error) + __PYX_ERR(3, 3002, __pyx_L1_error) } - *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_33)) )) = ((int)(__pyx_v_ival[__pyx_v_ij])); + *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_39)) )) = ((int)(__pyx_v_ival[__pyx_v_ij])); } - /* "PyCafe.pyx":2913 + /* "PyCafe.pyx":3003 * for ij in range(0, nelemMethod): * mvInt[ij] = ival[ij] * free(ival) # <<<<<<<<<<<<<< @@ -68704,7 +70791,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_ival); - /* "PyCafe.pyx":2914 + /* "PyCafe.pyx":3004 * mvInt[ij] = ival[ij] * free(ival) * return memoryview(mvInt) # <<<<<<<<<<<<<< @@ -68712,29 +70799,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * elif art in ['array', 'array.array']: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2914, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3004, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2914, __pyx_L1_error) + __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3004, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3004, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2914, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_r = __pyx_t_10; + __pyx_t_10 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2909 + /* "PyCafe.pyx":2999 * 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): */ - goto __pyx_L118; + goto __pyx_L165; } - /* "PyCafe.pyx":2916 + /* "PyCafe.pyx":3006 * return memoryview(mvInt) * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< @@ -68743,34 +70830,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2916, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3006, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); if (!__pyx_t_2) { } else { __pyx_t_5 = __pyx_t_2; - goto __pyx_L140_bool_binop_done; + goto __pyx_L187_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2916, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3006, __pyx_L1_error) __pyx_t_7 = (__pyx_t_2 != 0); __pyx_t_5 = __pyx_t_7; - __pyx_L140_bool_binop_done:; + __pyx_L187_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = (__pyx_t_5 != 0); if (__pyx_t_7) { - /* "PyCafe.pyx":2917 + /* "PyCafe.pyx":3007 * * elif art in ['array', 'array.array']: * a = array.array('h') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): * a.append( < int > ival[ij]) */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2917, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_v_a = ((arrayobject *)__pyx_t_4); - __pyx_t_4 = 0; + __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_v_a = ((arrayobject *)__pyx_t_10); + __pyx_t_10 = 0; - /* "PyCafe.pyx":2918 + /* "PyCafe.pyx":3008 * elif art in ['array', 'array.array']: * a = array.array('h') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -68782,20 +70869,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2919 + /* "PyCafe.pyx":3009 * a = array.array('h') * for ij in range(0, nelemMethod): * a.append( < int > ival[ij]) # <<<<<<<<<<<<<< * free(ival) * return a */ - __pyx_t_4 = __Pyx_PyInt_From_int(((int)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2919, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_17 = __Pyx_PyObject_Append(((PyObject *)__pyx_v_a), __pyx_t_4); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 2919, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_10 = __Pyx_PyInt_From_int(((int)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_17 = __Pyx_PyObject_Append(((PyObject *)__pyx_v_a), __pyx_t_10); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 3009, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } - /* "PyCafe.pyx":2920 + /* "PyCafe.pyx":3010 * for ij in range(0, nelemMethod): * a.append( < int > ival[ij]) * free(ival) # <<<<<<<<<<<<<< @@ -68804,7 +70891,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_ival); - /* "PyCafe.pyx":2921 + /* "PyCafe.pyx":3011 * a.append( < int > ival[ij]) * free(ival) * return a # <<<<<<<<<<<<<< @@ -68816,17 +70903,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_r = ((PyObject *)__pyx_v_a); goto __pyx_L0; - /* "PyCafe.pyx":2916 + /* "PyCafe.pyx":3006 * return memoryview(mvInt) * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< * a = array.array('h') * for ij in range(0, nelemMethod): */ - goto __pyx_L118; + goto __pyx_L165; } - /* "PyCafe.pyx":2923 + /* "PyCafe.pyx":3013 * return a * * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< @@ -68835,58 +70922,58 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2923, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3013, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 != 0); if (!__pyx_t_2) { } else { __pyx_t_7 = __pyx_t_2; - goto __pyx_L144_bool_binop_done; + goto __pyx_L191_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2923, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3013, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); __pyx_t_7 = __pyx_t_5; - __pyx_L144_bool_binop_done:; + __pyx_L191_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = (__pyx_t_7 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2924 + /* "PyCafe.pyx":3014 * * elif art in ['ctypes', 'ctype']: * ctypesArray = (ctypes.c_int32*nelemMethod)() # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): * ctypesArray[ij] = ival[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2924, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_c_int32); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2924, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2924, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_9 = PyNumber_Multiply(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2924, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3014, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_c_int32); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3014, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3014, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = PyNumber_Multiply(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3014, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); - if (likely(__pyx_t_10)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); - __Pyx_INCREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_9, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - __pyx_t_4 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2924, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_ctypesArray = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_t_10 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3014, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_ctypesArray = __pyx_t_10; + __pyx_t_10 = 0; - /* "PyCafe.pyx":2925 + /* "PyCafe.pyx":3015 * elif art in ['ctypes', 'ctype']: * ctypesArray = (ctypes.c_int32*nelemMethod)() * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -68898,20 +70985,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2926 + /* "PyCafe.pyx":3016 * ctypesArray = (ctypes.c_int32*nelemMethod)() * for ij in range(0, nelemMethod): * ctypesArray[ij] = ival[ij] # <<<<<<<<<<<<<< * free(ival) * return ctypesArray */ - __pyx_t_4 = __Pyx_PyInt_From_int(((int)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2926, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_4, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 2926, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_10 = __Pyx_PyInt_From_int(((int)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_10, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 3016, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } - /* "PyCafe.pyx":2927 + /* "PyCafe.pyx":3017 * for ij in range(0, nelemMethod): * ctypesArray[ij] = ival[ij] * free(ival) # <<<<<<<<<<<<<< @@ -68920,7 +71007,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_ival); - /* "PyCafe.pyx":2928 + /* "PyCafe.pyx":3018 * ctypesArray[ij] = ival[ij] * free(ival) * return ctypesArray # <<<<<<<<<<<<<< @@ -68932,17 +71019,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_r = __pyx_v_ctypesArray; goto __pyx_L0; - /* "PyCafe.pyx":2923 + /* "PyCafe.pyx":3013 * return a * * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< * ctypesArray = (ctypes.c_int32*nelemMethod)() * for ij in range(0, nelemMethod): */ - goto __pyx_L118; + goto __pyx_L165; } - /* "PyCafe.pyx":2931 + /* "PyCafe.pyx":3021 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< @@ -68951,100 +71038,100 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ /*else*/ { - /* "PyCafe.pyx":2932 + /* "PyCafe.pyx":3022 * else: * print("Unknow array type in user request for art='", * art, "'. Possible types are:") # <<<<<<<<<<<<<< * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") */ - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2931, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = PyTuple_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); __Pyx_INCREF(__pyx_v_art); __Pyx_GIVEREF(__pyx_v_art); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_art); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_v_art); __Pyx_INCREF(__pyx_kp_u_Possible_types_are); __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_Possible_types_are); + PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_kp_u_Possible_types_are); - /* "PyCafe.pyx":2931 + /* "PyCafe.pyx":3021 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") */ - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2931, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2933 + /* "PyCafe.pyx":3023 * 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') */ - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2933, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3023, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2934 + /* "PyCafe.pyx":3024 * 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): */ - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2934, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":2935 + /* "PyCafe.pyx":3025 * 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] */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2935, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2935, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2935, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2935, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3025, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); - __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2935, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2935, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_int32); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2935, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(3, 2935, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 2935, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2935, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3025, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_int32); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(3, 3025, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 3025, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_9, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_31 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_31.memview)) __PYX_ERR(3, 2935, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_mvInt = __pyx_t_31; - __pyx_t_31.memview = NULL; - __pyx_t_31.data = NULL; + __pyx_t_37 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_37.memview)) __PYX_ERR(3, 3025, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_mvInt = __pyx_t_37; + __pyx_t_37.memview = NULL; + __pyx_t_37.data = NULL; - /* "PyCafe.pyx":2936 + /* "PyCafe.pyx":3026 * print("Returning memoryview") * mvInt = np.empty(nelemMethod, dtype=np.int32, order='C') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -69056,24 +71143,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2937 + /* "PyCafe.pyx":3027 * mvInt = np.empty(nelemMethod, dtype=np.int32, order='C') * for ij in range(0, nelemMethod): * mvInt[ij] = ival[ij] # <<<<<<<<<<<<<< * free(ival) * return mvInt */ - __pyx_t_34 = __pyx_v_ij; + __pyx_t_40 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_34 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_40 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2937, __pyx_L1_error) + __PYX_ERR(3, 3027, __pyx_L1_error) } - *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_34)) )) = ((int)(__pyx_v_ival[__pyx_v_ij])); + *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_40)) )) = ((int)(__pyx_v_ival[__pyx_v_ij])); } - /* "PyCafe.pyx":2938 + /* "PyCafe.pyx":3028 * for ij in range(0, nelemMethod): * mvInt[ij] = ival[ij] * free(ival) # <<<<<<<<<<<<<< @@ -69082,7 +71169,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_ival); - /* "PyCafe.pyx":2939 + /* "PyCafe.pyx":3029 * mvInt[ij] = ival[ij] * free(ival) * return mvInt # <<<<<<<<<<<<<< @@ -69090,15 +71177,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * elif dtcheck in [CAFE_FLOAT]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2939, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3029, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; } - __pyx_L118:; + __pyx_L165:; - /* "PyCafe.pyx":2864 + /* "PyCafe.pyx":2954 * status = self._c_cafe.getLongArray(handle, ival) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -69107,7 +71194,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":2858 + /* "PyCafe.pyx":2948 * return mvShort * * elif dtcheck in [CAFE_LONG]: # <<<<<<<<<<<<<< @@ -69117,7 +71204,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C break; case CAFE_FLOAT: - /* "PyCafe.pyx":2943 + /* "PyCafe.pyx":3033 * elif dtcheck in [CAFE_FLOAT]: * * fval = malloc(nelemMemory * sizeof(float)) # <<<<<<<<<<<<<< @@ -69126,7 +71213,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __pyx_v_fval = ((float *)malloc((__pyx_v_nelemMemory * (sizeof(float))))); - /* "PyCafe.pyx":2945 + /* "PyCafe.pyx":3035 * fval = malloc(nelemMemory * sizeof(float)) * # start=time.time() * with nogil: # <<<<<<<<<<<<<< @@ -69141,7 +71228,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C #endif /*try:*/ { - /* "PyCafe.pyx":2946 + /* "PyCafe.pyx":3036 * # start=time.time() * with nogil: * status = self._c_cafe.getFloatArray(handle, fval) # <<<<<<<<<<<<<< @@ -69151,7 +71238,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_v_status = __pyx_v_self->_c_cafe->getFloatArray(__pyx_v_handle, __pyx_v_fval); } - /* "PyCafe.pyx":2945 + /* "PyCafe.pyx":3035 * fval = malloc(nelemMemory * sizeof(float)) * # start=time.time() * with nogil: # <<<<<<<<<<<<<< @@ -69164,13 +71251,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif - goto __pyx_L152; + goto __pyx_L199; } - __pyx_L152:; + __pyx_L199:; } } - /* "PyCafe.pyx":2953 + /* "PyCafe.pyx":3043 * # status=self._c_cafe.get(handle, pvd) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -69180,7 +71267,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_5 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":2956 + /* "PyCafe.pyx":3046 * # nelemMethod=self.hh.getnelemMethod(handle) * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< @@ -69189,82 +71276,82 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2956, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3046, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); if (!__pyx_t_2) { } else { __pyx_t_5 = __pyx_t_2; - goto __pyx_L155_bool_binop_done; + goto __pyx_L202_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2956, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3046, __pyx_L1_error) __pyx_t_7 = (__pyx_t_2 != 0); if (!__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; - goto __pyx_L155_bool_binop_done; + goto __pyx_L202_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2956, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3046, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); if (!__pyx_t_2) { } else { __pyx_t_5 = __pyx_t_2; - goto __pyx_L155_bool_binop_done; + goto __pyx_L202_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2956, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3046, __pyx_L1_error) __pyx_t_7 = (__pyx_t_2 != 0); if (!__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; - goto __pyx_L155_bool_binop_done; + goto __pyx_L202_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2956, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3046, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); __pyx_t_5 = __pyx_t_2; - __pyx_L155_bool_binop_done:; + __pyx_L202_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_5 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2960 + /* "PyCafe.pyx":3050 * # 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2960, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2960, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2960, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2960, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2960, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2960, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3050, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2960, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(3, 2960, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2960, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_float32); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3050, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_35 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_8, PyBUF_WRITABLE); if (unlikely(!__pyx_t_35.memview)) __PYX_ERR(3, 2960, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(3, 3050, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_mvFloat = __pyx_t_35; - __pyx_t_35.memview = NULL; - __pyx_t_35.data = NULL; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_41 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_8, PyBUF_WRITABLE); if (unlikely(!__pyx_t_41.memview)) __PYX_ERR(3, 3050, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_mvFloat = __pyx_t_41; + __pyx_t_41.memview = NULL; + __pyx_t_41.data = NULL; - /* "PyCafe.pyx":2961 + /* "PyCafe.pyx":3051 * * mvFloat = np.empty(nelemMethod, dtype=np.float32) * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -69276,24 +71363,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2962 + /* "PyCafe.pyx":3052 * mvFloat = np.empty(nelemMethod, dtype=np.float32) * for ij in range(0, nelemMethod): * mvFloat[ij] = fval[ij] # pvd.getAsFloat(ij) # <<<<<<<<<<<<<< * # arr=np.asarray(mvFloat) * */ - __pyx_t_36 = __pyx_v_ij; + __pyx_t_42 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_36 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_42 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2962, __pyx_L1_error) + __PYX_ERR(3, 3052, __pyx_L1_error) } - *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_36)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); + *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_42)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); } - /* "PyCafe.pyx":2965 + /* "PyCafe.pyx":3055 * # arr=np.asarray(mvFloat) * * free(fval) # <<<<<<<<<<<<<< @@ -69302,7 +71389,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_fval); - /* "PyCafe.pyx":2970 + /* "PyCafe.pyx":3060 * #set_base(arr, dval) * * return np.array(mvFloat) # arr # <<<<<<<<<<<<<< @@ -69310,44 +71397,44 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * elif art in ['memoryview', 'mv', 'memoryviewslice']: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2970, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2970, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2970, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); - __Pyx_INCREF(__pyx_t_9); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3060, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3060, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3060, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_10, function); + __Pyx_DECREF_SET(__pyx_t_9, function); } } - __pyx_t_8 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_9, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2970, __pyx_L1_error) + __pyx_t_8 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3060, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_r = __pyx_t_8; __pyx_t_8 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2956 + /* "PyCafe.pyx":3046 * # nelemMethod=self.hh.getnelemMethod(handle) * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< * * # elif dt in ['np.float16','np.float32']: */ - goto __pyx_L154; + goto __pyx_L201; } - /* "PyCafe.pyx":2972 + /* "PyCafe.pyx":3062 * return np.array(mvFloat) # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< @@ -69356,68 +71443,68 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2972, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3062, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; - goto __pyx_L162_bool_binop_done; + goto __pyx_L209_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 2972, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3062, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; - goto __pyx_L162_bool_binop_done; + goto __pyx_L209_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2972, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3062, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); __pyx_t_2 = __pyx_t_7; - __pyx_L162_bool_binop_done:; + __pyx_L209_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = (__pyx_t_2 != 0); if (__pyx_t_7) { - /* "PyCafe.pyx":2975 + /* "PyCafe.pyx":3065 * * # Method A to return memory view * mvFloat = np.empty(nelemMethod, dtype=np.float32) # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): * mvFloat[ij] = fval[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2975, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3065, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 2975, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2975, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2975, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2975, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 2975, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3065, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2975, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(3, 2975, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2975, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_35 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_35.memview)) __PYX_ERR(3, 2975, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3065, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3065, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3065, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3065, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float32); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3065, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(3, 3065, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3065, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_mvFloat = __pyx_t_35; - __pyx_t_35.memview = NULL; - __pyx_t_35.data = NULL; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_41 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_41.memview)) __PYX_ERR(3, 3065, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_mvFloat = __pyx_t_41; + __pyx_t_41.memview = NULL; + __pyx_t_41.data = NULL; - /* "PyCafe.pyx":2976 + /* "PyCafe.pyx":3066 * # Method A to return memory view * mvFloat = np.empty(nelemMethod, dtype=np.float32) * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -69429,24 +71516,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":2977 + /* "PyCafe.pyx":3067 * mvFloat = np.empty(nelemMethod, dtype=np.float32) * for ij in range(0, nelemMethod): * mvFloat[ij] = fval[ij] # <<<<<<<<<<<<<< * * free(fval) */ - __pyx_t_37 = __pyx_v_ij; + __pyx_t_43 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_37 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_43 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 2977, __pyx_L1_error) + __PYX_ERR(3, 3067, __pyx_L1_error) } - *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_37)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); + *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_43)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); } - /* "PyCafe.pyx":2979 + /* "PyCafe.pyx":3069 * mvFloat[ij] = fval[ij] * * free(fval) # <<<<<<<<<<<<<< @@ -69455,7 +71542,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_fval); - /* "PyCafe.pyx":2982 + /* "PyCafe.pyx":3072 * # memoryview(mvFloat).tolist() #tolist() only supports byte views * * return memoryview(mvFloat) # <<<<<<<<<<<<<< @@ -69463,29 +71550,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * # Method B to return memory view */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 2982, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 2982, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3072, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3072, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2982, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3072, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":2972 + /* "PyCafe.pyx":3062 * return np.array(mvFloat) # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< * * # Method A to return memory view */ - goto __pyx_L154; + goto __pyx_L201; } - /* "PyCafe.pyx":2996 + /* "PyCafe.pyx":3086 * ''' * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< @@ -69494,34 +71581,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 2996, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3086, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_7 = __pyx_t_5; - goto __pyx_L167_bool_binop_done; + goto __pyx_L214_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 2996, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3086, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 != 0); __pyx_t_7 = __pyx_t_2; - __pyx_L167_bool_binop_done:; + __pyx_L214_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_7 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":2998 + /* "PyCafe.pyx":3088 * elif art in ['array', 'array.array']: * * a = array.array('f') # <<<<<<<<<<<<<< * * for ij in range(0, nelemMethod): */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2998, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_a = ((arrayobject *)__pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_a = ((arrayobject *)__pyx_t_4); + __pyx_t_4 = 0; - /* "PyCafe.pyx":3000 + /* "PyCafe.pyx":3090 * a = array.array('f') * * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -69533,20 +71620,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":3001 + /* "PyCafe.pyx":3091 * * for ij in range(0, nelemMethod): * a.append(fval[ij]) # <<<<<<<<<<<<<< * free(fval) * */ - __pyx_t_3 = PyFloat_FromDouble((__pyx_v_fval[__pyx_v_ij])); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3001, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_17 = __Pyx_PyObject_Append(((PyObject *)__pyx_v_a), __pyx_t_3); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 3001, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_fval[__pyx_v_ij])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3091, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_17 = __Pyx_PyObject_Append(((PyObject *)__pyx_v_a), __pyx_t_4); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 3091, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":3002 + /* "PyCafe.pyx":3092 * for ij in range(0, nelemMethod): * a.append(fval[ij]) * free(fval) # <<<<<<<<<<<<<< @@ -69555,7 +71642,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_fval); - /* "PyCafe.pyx":3004 + /* "PyCafe.pyx":3094 * free(fval) * * return a # <<<<<<<<<<<<<< @@ -69567,17 +71654,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_r = ((PyObject *)__pyx_v_a); goto __pyx_L0; - /* "PyCafe.pyx":2996 + /* "PyCafe.pyx":3086 * ''' * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< * * a = array.array('f') */ - goto __pyx_L154; + goto __pyx_L201; } - /* "PyCafe.pyx":3024 + /* "PyCafe.pyx":3114 * ''' * * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< @@ -69586,58 +71673,58 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3024, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3114, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; - goto __pyx_L171_bool_binop_done; + goto __pyx_L218_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3024, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3114, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); __pyx_t_2 = __pyx_t_7; - __pyx_L171_bool_binop_done:; + __pyx_L218_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = (__pyx_t_2 != 0); if (__pyx_t_7) { - /* "PyCafe.pyx":3025 + /* "PyCafe.pyx":3115 * * elif art in ['ctypes', 'ctype']: * ctypesArray = (ctypes.c_float*nelemMethod)() # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): * ctypesArray[ij] = fval[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3025, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_c_float); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3025, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3025, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = PyNumber_Multiply(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3025, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_c_float); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = PyNumber_Multiply(__pyx_t_10, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_10, function); + __Pyx_DECREF_SET(__pyx_t_9, function); } } - __pyx_t_3 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_10); + __pyx_t_4 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_9); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3025, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_v_ctypesArray = __pyx_t_3; - __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_ctypesArray = __pyx_t_4; + __pyx_t_4 = 0; - /* "PyCafe.pyx":3026 + /* "PyCafe.pyx":3116 * elif art in ['ctypes', 'ctype']: * ctypesArray = (ctypes.c_float*nelemMethod)() * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -69649,20 +71736,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":3027 + /* "PyCafe.pyx":3117 * ctypesArray = (ctypes.c_float*nelemMethod)() * for ij in range(0, nelemMethod): * ctypesArray[ij] = fval[ij] # <<<<<<<<<<<<<< * free(fval) * return ctypesArray */ - __pyx_t_3 = PyFloat_FromDouble((__pyx_v_fval[__pyx_v_ij])); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3027, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_3, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 3027, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_fval[__pyx_v_ij])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_4, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 3117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":3028 + /* "PyCafe.pyx":3118 * for ij in range(0, nelemMethod): * ctypesArray[ij] = fval[ij] * free(fval) # <<<<<<<<<<<<<< @@ -69671,7 +71758,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_fval); - /* "PyCafe.pyx":3029 + /* "PyCafe.pyx":3119 * ctypesArray[ij] = fval[ij] * free(fval) * return ctypesArray # <<<<<<<<<<<<<< @@ -69683,17 +71770,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_r = __pyx_v_ctypesArray; goto __pyx_L0; - /* "PyCafe.pyx":3024 + /* "PyCafe.pyx":3114 * ''' * * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< * ctypesArray = (ctypes.c_float*nelemMethod)() * for ij in range(0, nelemMethod): */ - goto __pyx_L154; + goto __pyx_L201; } - /* "PyCafe.pyx":3032 + /* "PyCafe.pyx":3122 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< @@ -69702,99 +71789,99 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ /*else*/ { - /* "PyCafe.pyx":3033 + /* "PyCafe.pyx":3123 * else: * print("Unknow array type in user request for art='", * art, "'. Possible types are:") # <<<<<<<<<<<<<< * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3032, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); __Pyx_INCREF(__pyx_v_art); __Pyx_GIVEREF(__pyx_v_art); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_art); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_art); __Pyx_INCREF(__pyx_kp_u_Possible_types_are); __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_Possible_types_are); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_Possible_types_are); - /* "PyCafe.pyx":3032 + /* "PyCafe.pyx":3122 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3032, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3034 + /* "PyCafe.pyx":3124 * 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) */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3034, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3035 + /* "PyCafe.pyx":3125 * 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): */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3035, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3036 + /* "PyCafe.pyx":3126 * 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] */ - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3036, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3036, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_float32); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3036, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3036, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_10); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_10); - __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3036, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3036, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3036, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 3036, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3036, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(3, 3126, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_35 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_35.memview)) __PYX_ERR(3, 3036, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_mvFloat = __pyx_t_35; - __pyx_t_35.memview = NULL; - __pyx_t_35.data = NULL; + __pyx_t_41 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_41.memview)) __PYX_ERR(3, 3126, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_mvFloat = __pyx_t_41; + __pyx_t_41.memview = NULL; + __pyx_t_41.data = NULL; - /* "PyCafe.pyx":3037 + /* "PyCafe.pyx":3127 * print("Returning memoryview") * mvFloat = np.empty(nelemMethod, dtype=np.float32) * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -69806,24 +71893,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":3038 + /* "PyCafe.pyx":3128 * mvFloat = np.empty(nelemMethod, dtype=np.float32) * for ij in range(0, nelemMethod): * mvFloat[ij] = fval[ij] # <<<<<<<<<<<<<< * free(fval) * return mvFloat */ - __pyx_t_38 = __pyx_v_ij; + __pyx_t_44 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_38 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_44 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 3038, __pyx_L1_error) + __PYX_ERR(3, 3128, __pyx_L1_error) } - *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_38)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); + *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_44)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); } - /* "PyCafe.pyx":3039 + /* "PyCafe.pyx":3129 * for ij in range(0, nelemMethod): * mvFloat[ij] = fval[ij] * free(fval) # <<<<<<<<<<<<<< @@ -69832,7 +71919,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_fval); - /* "PyCafe.pyx":3040 + /* "PyCafe.pyx":3130 * mvFloat[ij] = fval[ij] * free(fval) * return mvFloat # <<<<<<<<<<<<<< @@ -69840,15 +71927,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * elif dtcheck in [CAFE_DOUBLE]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3040, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_r = __pyx_t_9; - __pyx_t_9 = 0; + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; } - __pyx_L154:; + __pyx_L201:; - /* "PyCafe.pyx":2953 + /* "PyCafe.pyx":3043 * # status=self._c_cafe.get(handle, pvd) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -69857,7 +71944,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":2941 + /* "PyCafe.pyx":3031 * return mvInt * * elif dtcheck in [CAFE_FLOAT]: # <<<<<<<<<<<<<< @@ -69867,7 +71954,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C break; case CAFE_DOUBLE: - /* "PyCafe.pyx":3045 + /* "PyCafe.pyx":3135 * * # start=time.time() * dval = malloc(nelemMemory * sizeof(double)) # <<<<<<<<<<<<<< @@ -69876,7 +71963,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __pyx_v_dval = ((double *)malloc((__pyx_v_nelemMemory * (sizeof(double))))); - /* "PyCafe.pyx":3047 + /* "PyCafe.pyx":3137 * dval = malloc(nelemMemory * sizeof(double)) * * with nogil: # <<<<<<<<<<<<<< @@ -69891,7 +71978,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C #endif /*try:*/ { - /* "PyCafe.pyx":3049 + /* "PyCafe.pyx":3139 * with nogil: * # for ij in range(0, 10000): * status = self._c_cafe.getDoubleArray(handle, dval) # <<<<<<<<<<<<<< @@ -69901,7 +71988,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_v_status = __pyx_v_self->_c_cafe->getDoubleArray(__pyx_v_handle, __pyx_v_dval); } - /* "PyCafe.pyx":3047 + /* "PyCafe.pyx":3137 * dval = malloc(nelemMemory * sizeof(double)) * * with nogil: # <<<<<<<<<<<<<< @@ -69914,13 +72001,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif - goto __pyx_L179; + goto __pyx_L226; } - __pyx_L179:; + __pyx_L226:; } } - /* "PyCafe.pyx":3051 + /* "PyCafe.pyx":3141 * status = self._c_cafe.getDoubleArray(handle, dval) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -69930,7 +72017,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_7 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_7) { - /* "PyCafe.pyx":3054 + /* "PyCafe.pyx":3144 * # nelemMethod=self.hh.getnelemMethod(handle) * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< @@ -69939,82 +72026,82 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3054, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3144, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_7 = __pyx_t_5; - goto __pyx_L182_bool_binop_done; + goto __pyx_L229_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3054, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3144, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 != 0); if (!__pyx_t_2) { } else { __pyx_t_7 = __pyx_t_2; - goto __pyx_L182_bool_binop_done; + goto __pyx_L229_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3054, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3144, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_7 = __pyx_t_5; - goto __pyx_L182_bool_binop_done; + goto __pyx_L229_bool_binop_done; } - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3054, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3144, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 != 0); if (!__pyx_t_2) { } else { __pyx_t_7 = __pyx_t_2; - goto __pyx_L182_bool_binop_done; + goto __pyx_L229_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3054, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3144, __pyx_L1_error) __pyx_t_5 = (__pyx_t_2 != 0); __pyx_t_7 = __pyx_t_5; - __pyx_L182_bool_binop_done:; + __pyx_L229_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = (__pyx_t_7 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":3059 + /* "PyCafe.pyx":3149 * * # mvDouble=dval * mvDouble = np.empty(nelemMethod, dtype=np.float64) # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): * mvDouble[ij] = dval[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3059, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3059, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float64); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(3, 3149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_9); - __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float64); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(3, 3059, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_39 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_39.memview)) __PYX_ERR(3, 3059, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_mvDouble = __pyx_t_39; - __pyx_t_39.memview = NULL; - __pyx_t_39.data = NULL; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_45 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_45.memview)) __PYX_ERR(3, 3149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_mvDouble = __pyx_t_45; + __pyx_t_45.memview = NULL; + __pyx_t_45.data = NULL; - /* "PyCafe.pyx":3060 + /* "PyCafe.pyx":3150 * # mvDouble=dval * mvDouble = np.empty(nelemMethod, dtype=np.float64) * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -70026,24 +72113,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":3061 + /* "PyCafe.pyx":3151 * mvDouble = np.empty(nelemMethod, dtype=np.float64) * for ij in range(0, nelemMethod): * mvDouble[ij] = dval[ij] # <<<<<<<<<<<<<< * # arr=np.asarray(mvDouble) * free(dval) */ - __pyx_t_40 = __pyx_v_ij; + __pyx_t_46 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_40 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_46 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 3061, __pyx_L1_error) + __PYX_ERR(3, 3151, __pyx_L1_error) } - *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_40)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); + *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_46)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); } - /* "PyCafe.pyx":3063 + /* "PyCafe.pyx":3153 * mvDouble[ij] = dval[ij] * # arr=np.asarray(mvDouble) * free(dval) # <<<<<<<<<<<<<< @@ -70052,7 +72139,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_dval); - /* "PyCafe.pyx":3066 + /* "PyCafe.pyx":3156 * # end=time.time() * #print (end - start) * return np.array(mvDouble) # arr # <<<<<<<<<<<<<< @@ -70060,44 +72147,44 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * elif art in ['memoryview', 'mv', 'memoryviewslice']: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3066, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3066, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3066, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_10)) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_4 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_10, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); - __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3066, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_r = __pyx_t_10; + __pyx_t_10 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3054 + /* "PyCafe.pyx":3144 * # nelemMethod=self.hh.getnelemMethod(handle) * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< * * # elif dt in ['double', 'np.float_','np.float64']: */ - goto __pyx_L181; + goto __pyx_L228; } - /* "PyCafe.pyx":3068 + /* "PyCafe.pyx":3158 * return np.array(mvDouble) # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< @@ -70106,68 +72193,68 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3068, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3158, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); if (!__pyx_t_2) { } else { __pyx_t_5 = __pyx_t_2; - goto __pyx_L189_bool_binop_done; + goto __pyx_L236_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3068, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3158, __pyx_L1_error) __pyx_t_7 = (__pyx_t_2 != 0); if (!__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; - goto __pyx_L189_bool_binop_done; + goto __pyx_L236_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3068, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3158, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); __pyx_t_5 = __pyx_t_2; - __pyx_L189_bool_binop_done:; + __pyx_L236_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_5 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3071 + /* "PyCafe.pyx":3161 * * # Method A to return memory view * mvDouble = np.empty(nelemMethod, dtype=np.float64) # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): * mvDouble[ij] = dval[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3071, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3071, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3071, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3071, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_4); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3071, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3071, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_float64); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3071, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_empty); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(3, 3071, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3071, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_10); + __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_float64); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(3, 3161, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_39 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_39.memview)) __PYX_ERR(3, 3071, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_3, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_mvDouble = __pyx_t_39; - __pyx_t_39.memview = NULL; - __pyx_t_39.data = NULL; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_45 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_45.memview)) __PYX_ERR(3, 3161, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_mvDouble = __pyx_t_45; + __pyx_t_45.memview = NULL; + __pyx_t_45.data = NULL; - /* "PyCafe.pyx":3072 + /* "PyCafe.pyx":3162 * # Method A to return memory view * mvDouble = np.empty(nelemMethod, dtype=np.float64) * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -70179,24 +72266,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":3073 + /* "PyCafe.pyx":3163 * mvDouble = np.empty(nelemMethod, dtype=np.float64) * for ij in range(0, nelemMethod): * mvDouble[ij] = dval[ij] # <<<<<<<<<<<<<< * free(dval) * # end=time.time() */ - __pyx_t_41 = __pyx_v_ij; + __pyx_t_47 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_41 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_47 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 3073, __pyx_L1_error) + __PYX_ERR(3, 3163, __pyx_L1_error) } - *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_41)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); + *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_47)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); } - /* "PyCafe.pyx":3074 + /* "PyCafe.pyx":3164 * for ij in range(0, nelemMethod): * mvDouble[ij] = dval[ij] * free(dval) # <<<<<<<<<<<<<< @@ -70205,7 +72292,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_dval); - /* "PyCafe.pyx":3077 + /* "PyCafe.pyx":3167 * # end=time.time() * #print (end - start) * return memoryview(mvDouble) # <<<<<<<<<<<<<< @@ -70213,29 +72300,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * elif art in ['array', 'array.array']: */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3077, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3077, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3077, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_10 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_r = __pyx_t_9; - __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3068 + /* "PyCafe.pyx":3158 * return np.array(mvDouble) # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< * * # Method A to return memory view */ - goto __pyx_L181; + goto __pyx_L228; } - /* "PyCafe.pyx":3079 + /* "PyCafe.pyx":3169 * return memoryview(mvDouble) * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< @@ -70244,34 +72331,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3079, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(3, 3169, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; - goto __pyx_L194_bool_binop_done; + goto __pyx_L241_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3079, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3169, __pyx_L1_error) __pyx_t_5 = (__pyx_t_7 != 0); __pyx_t_2 = __pyx_t_5; - __pyx_L194_bool_binop_done:; + __pyx_L241_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = (__pyx_t_2 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":3080 + /* "PyCafe.pyx":3170 * * elif art in ['array', 'array.array']: * a = array.array('d') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): * a.append(dval[ij]) */ - __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3080, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_v_a = ((arrayobject *)__pyx_t_9); - __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_a = ((arrayobject *)__pyx_t_3); + __pyx_t_3 = 0; - /* "PyCafe.pyx":3081 + /* "PyCafe.pyx":3171 * elif art in ['array', 'array.array']: * a = array.array('d') * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -70283,20 +72370,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":3082 + /* "PyCafe.pyx":3172 * a = array.array('d') * for ij in range(0, nelemMethod): * a.append(dval[ij]) # <<<<<<<<<<<<<< * free(dval) * # end=time.time() */ - __pyx_t_9 = PyFloat_FromDouble((__pyx_v_dval[__pyx_v_ij])); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3082, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_17 = __Pyx_PyObject_Append(((PyObject *)__pyx_v_a), __pyx_t_9); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 3082, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_dval[__pyx_v_ij])); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_17 = __Pyx_PyObject_Append(((PyObject *)__pyx_v_a), __pyx_t_3); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 3172, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - /* "PyCafe.pyx":3083 + /* "PyCafe.pyx":3173 * for ij in range(0, nelemMethod): * a.append(dval[ij]) * free(dval) # <<<<<<<<<<<<<< @@ -70305,7 +72392,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_dval); - /* "PyCafe.pyx":3086 + /* "PyCafe.pyx":3176 * # end=time.time() * #print (end - start) * return a # <<<<<<<<<<<<<< @@ -70317,17 +72404,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_r = ((PyObject *)__pyx_v_a); goto __pyx_L0; - /* "PyCafe.pyx":3079 + /* "PyCafe.pyx":3169 * return memoryview(mvDouble) * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< * a = array.array('d') * for ij in range(0, nelemMethod): */ - goto __pyx_L181; + goto __pyx_L228; } - /* "PyCafe.pyx":3088 + /* "PyCafe.pyx":3178 * return a * * elif art in ['ctypes', "ctype"]: # <<<<<<<<<<<<<< @@ -70336,58 +72423,58 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __Pyx_INCREF(__pyx_v_art); __pyx_t_6 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3088, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3178, __pyx_L1_error) __pyx_t_7 = (__pyx_t_2 != 0); if (!__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; - goto __pyx_L198_bool_binop_done; + goto __pyx_L245_bool_binop_done; } - __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3088, __pyx_L1_error) + __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 3178, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 != 0); __pyx_t_5 = __pyx_t_2; - __pyx_L198_bool_binop_done:; + __pyx_L245_bool_binop_done:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_5 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3089 + /* "PyCafe.pyx":3179 * * elif art in ['ctypes', "ctype"]: * ctypesArray = (ctypes.c_double*nelemMethod)() # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): * ctypesArray[ij] = dval[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3089, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_c_double); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_c_double); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3089, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3089, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = PyNumber_Multiply(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3089, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_8 = PyNumber_Multiply(__pyx_t_4, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_4)) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_9 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3089, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_ctypesArray = __pyx_t_9; - __pyx_t_9 = 0; + __pyx_v_ctypesArray = __pyx_t_3; + __pyx_t_3 = 0; - /* "PyCafe.pyx":3090 + /* "PyCafe.pyx":3180 * elif art in ['ctypes', "ctype"]: * ctypesArray = (ctypes.c_double*nelemMethod)() * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -70399,20 +72486,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":3091 + /* "PyCafe.pyx":3181 * ctypesArray = (ctypes.c_double*nelemMethod)() * for ij in range(0, nelemMethod): * ctypesArray[ij] = dval[ij] # <<<<<<<<<<<<<< * free(dval) * return ctypesArray */ - __pyx_t_9 = PyFloat_FromDouble((__pyx_v_dval[__pyx_v_ij])); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3091, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_9, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 3091, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_dval[__pyx_v_ij])); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_3, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 3181, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - /* "PyCafe.pyx":3092 + /* "PyCafe.pyx":3182 * for ij in range(0, nelemMethod): * ctypesArray[ij] = dval[ij] * free(dval) # <<<<<<<<<<<<<< @@ -70421,7 +72508,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_dval); - /* "PyCafe.pyx":3093 + /* "PyCafe.pyx":3183 * ctypesArray[ij] = dval[ij] * free(dval) * return ctypesArray # <<<<<<<<<<<<<< @@ -70433,17 +72520,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_r = __pyx_v_ctypesArray; goto __pyx_L0; - /* "PyCafe.pyx":3088 + /* "PyCafe.pyx":3178 * return a * * elif art in ['ctypes', "ctype"]: # <<<<<<<<<<<<<< * ctypesArray = (ctypes.c_double*nelemMethod)() * for ij in range(0, nelemMethod): */ - goto __pyx_L181; + goto __pyx_L228; } - /* "PyCafe.pyx":3096 + /* "PyCafe.pyx":3186 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< @@ -70452,99 +72539,99 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ /*else*/ { - /* "PyCafe.pyx":3097 + /* "PyCafe.pyx":3187 * else: * print("Unknow array type in user request for art='", * art, "'. Possible types are:") # <<<<<<<<<<<<<< * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") */ - __pyx_t_9 = PyTuple_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3096, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); __Pyx_INCREF(__pyx_v_art); __Pyx_GIVEREF(__pyx_v_art); - PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_v_art); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_art); __Pyx_INCREF(__pyx_kp_u_Possible_types_are); __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); - PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_kp_u_Possible_types_are); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_Possible_types_are); - /* "PyCafe.pyx":3096 + /* "PyCafe.pyx":3186 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3096, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":3098 + /* "PyCafe.pyx":3188 * 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) */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3098, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":3099 + /* "PyCafe.pyx":3189 * 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): */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3099, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":3100 + /* "PyCafe.pyx":3190 * 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] */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3100, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3100, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float64); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(3, 3100, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_39 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_39.memview)) __PYX_ERR(3, 3100, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemMethod); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float64); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 3190, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_v_mvDouble = __pyx_t_39; - __pyx_t_39.memview = NULL; - __pyx_t_39.data = NULL; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_45 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_45.memview)) __PYX_ERR(3, 3190, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_mvDouble = __pyx_t_45; + __pyx_t_45.memview = NULL; + __pyx_t_45.data = NULL; - /* "PyCafe.pyx":3101 + /* "PyCafe.pyx":3191 * print("Returning memoryview") * mvDouble = np.empty(nelemMethod, dtype=np.float64) * for ij in range(0, nelemMethod): # <<<<<<<<<<<<<< @@ -70556,24 +72643,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_ij = __pyx_t_12; - /* "PyCafe.pyx":3102 + /* "PyCafe.pyx":3192 * mvDouble = np.empty(nelemMethod, dtype=np.float64) * for ij in range(0, nelemMethod): * mvDouble[ij] = dval[ij] # <<<<<<<<<<<<<< * free(dval) * return mvDouble */ - __pyx_t_42 = __pyx_v_ij; + __pyx_t_48 = __pyx_v_ij; __pyx_t_16 = -1; - if (unlikely(__pyx_t_42 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_16 = 0; + if (unlikely(__pyx_t_48 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_16 = 0; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); - __PYX_ERR(3, 3102, __pyx_L1_error) + __PYX_ERR(3, 3192, __pyx_L1_error) } - *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_42)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); + *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_48)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); } - /* "PyCafe.pyx":3103 + /* "PyCafe.pyx":3193 * for ij in range(0, nelemMethod): * mvDouble[ij] = dval[ij] * free(dval) # <<<<<<<<<<<<<< @@ -70582,7 +72669,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ free(__pyx_v_dval); - /* "PyCafe.pyx":3104 + /* "PyCafe.pyx":3194 * mvDouble[ij] = dval[ij] * free(dval) * return mvDouble # <<<<<<<<<<<<<< @@ -70590,15 +72677,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * if status != ICAFE_NORMAL: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_10 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_r = __pyx_t_10; - __pyx_t_10 = 0; + __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; goto __pyx_L0; } - __pyx_L181:; + __pyx_L228:; - /* "PyCafe.pyx":3051 + /* "PyCafe.pyx":3141 * status = self._c_cafe.getDoubleArray(handle, dval) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -70607,7 +72694,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":3042 + /* "PyCafe.pyx":3132 * return mvFloat * * elif dtcheck in [CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -70618,7 +72705,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C default: break; } - /* "PyCafe.pyx":3106 + /* "PyCafe.pyx":3196 * return mvDouble * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -70628,7 +72715,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3107 + /* "PyCafe.pyx":3197 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -70638,7 +72725,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3108 + /* "PyCafe.pyx":3198 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -70648,7 +72735,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3109 + /* "PyCafe.pyx":3199 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -70657,17 +72744,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":3108 + /* "PyCafe.pyx":3198 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * else: */ - goto __pyx_L206; + goto __pyx_L253; } - /* "PyCafe.pyx":3111 + /* "PyCafe.pyx":3201 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -70677,9 +72764,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C /*else*/ { __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, __pyx_v_status); } - __pyx_L206:; + __pyx_L253:; - /* "PyCafe.pyx":3107 + /* "PyCafe.pyx":3197 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -70688,7 +72775,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":3112 + /* "PyCafe.pyx":3202 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -70698,84 +72785,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3114 + /* "PyCafe.pyx":3204 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, */ - __pyx_t_10 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3114, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 3114, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 3114, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3114, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 3204, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 3204, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_handle, __pyx_t_8) < 0) __PYX_ERR(3, 3114, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_handle, __pyx_t_8) < 0) __PYX_ERR(3, 3204, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":3115 + /* "PyCafe.pyx":3205 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, * _error_text=self.cs.code(status), */ - __pyx_t_8 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3115, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_pv_name, __pyx_t_8) < 0) __PYX_ERR(3, 3114, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_pv_name, __pyx_t_8) < 0) __PYX_ERR(3, 3204, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":3116 + /* "PyCafe.pyx":3206 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, # <<<<<<<<<<<<<< * _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3116, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_code, __pyx_t_8) < 0) __PYX_ERR(3, 3114, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_code, __pyx_t_8) < 0) __PYX_ERR(3, 3204, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":3117 + /* "PyCafe.pyx":3207 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, * _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_8 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3117, __pyx_L1_error) + __pyx_t_8 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_text, __pyx_t_8) < 0) __PYX_ERR(3, 3114, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_text, __pyx_t_8) < 0) __PYX_ERR(3, 3204, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":3118 + /* "PyCafe.pyx":3208 * _error_code=status, * _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_8 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3118, __pyx_L1_error) + __pyx_t_8 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_info, __pyx_t_8) < 0) __PYX_ERR(3, 3114, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_info, __pyx_t_8) < 0) __PYX_ERR(3, 3204, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":3113 + /* "PyCafe.pyx":3203 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3113, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":3119 + /* "PyCafe.pyx":3209 * _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -70783,9 +72870,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * return [None] */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 3119, __pyx_L1_error) + __PYX_ERR(3, 3209, __pyx_L1_error) - /* "PyCafe.pyx":3112 + /* "PyCafe.pyx":3202 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -70794,7 +72881,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":3121 + /* "PyCafe.pyx":3211 * raise _cafeException * * return [None] # <<<<<<<<<<<<<< @@ -70802,7 +72889,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3121, __pyx_L1_error) + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 3211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); @@ -70811,7 +72898,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __pyx_t_8 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3106 + /* "PyCafe.pyx":3196 * return mvDouble * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -70820,7 +72907,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":2530 + /* "PyCafe.pyx":2529 * ############################################################################ * @verify_handlepv * def getArray(self, handlePV, str dt='native', str art='numpy'): # <<<<<<<<<<<<<< @@ -70838,14 +72925,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); - __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1); + __PYX_XDEC_MEMVIEW(&__pyx_t_19, 1); __PYX_XDEC_MEMVIEW(&__pyx_t_20, 1); __PYX_XDEC_MEMVIEW(&__pyx_t_22, 1); - __PYX_XDEC_MEMVIEW(&__pyx_t_27, 1); - __PYX_XDEC_MEMVIEW(&__pyx_t_29, 1); - __PYX_XDEC_MEMVIEW(&__pyx_t_31, 1); + __PYX_XDEC_MEMVIEW(&__pyx_t_33, 1); __PYX_XDEC_MEMVIEW(&__pyx_t_35, 1); - __PYX_XDEC_MEMVIEW(&__pyx_t_39, 1); + __PYX_XDEC_MEMVIEW(&__pyx_t_37, 1); + __PYX_XDEC_MEMVIEW(&__pyx_t_41, 1); + __PYX_XDEC_MEMVIEW(&__pyx_t_45, 1); __Pyx_AddTraceback("PyCafe.CyCafe.getArray", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -70865,13 +72952,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_258getArray(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_v_mvStr); __Pyx_XDECREF(__pyx_v_arrayArray); __Pyx_XDECREF(__pyx_v_ctypesArray); + __Pyx_XDECREF(__pyx_v_start); + __Pyx_XDECREF(__pyx_v_end); __Pyx_XDECREF(__pyx_v_ctypesArray16); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "PyCafe.pyx":3129 +/* "PyCafe.pyx":3219 * ############################################################################ * * def getPVInt(self, handlePV): # <<<<<<<<<<<<<< @@ -70902,7 +72991,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_260getPVInt(struct __pyx_obj_6PyCafe_C PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getPVInt", 0); - /* "PyCafe.pyx":3130 + /* "PyCafe.pyx":3220 * * def getPVInt(self, handlePV): * return self.getPV(handlePV, 'int') # <<<<<<<<<<<<<< @@ -70910,7 +72999,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_260getPVInt(struct __pyx_obj_6PyCafe_C * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3130, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -70927,7 +73016,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_260getPVInt(struct __pyx_obj_6PyCafe_C #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3130, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3220, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -70935,13 +73024,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_260getPVInt(struct __pyx_obj_6PyCafe_C #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3130, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3220, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3130, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -70952,7 +73041,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_260getPVInt(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_n_u_int); __Pyx_GIVEREF(__pyx_n_u_int); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_int); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3130, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -70961,7 +73050,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_260getPVInt(struct __pyx_obj_6PyCafe_C __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3129 + /* "PyCafe.pyx":3219 * ############################################################################ * * def getPVInt(self, handlePV): # <<<<<<<<<<<<<< @@ -70985,7 +73074,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_260getPVInt(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":3134 +/* "PyCafe.pyx":3224 * * ############################################################################ * def getPVFloat(self, handlePV): # <<<<<<<<<<<<<< @@ -71016,7 +73105,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_262getPVFloat(struct __pyx_obj_6PyCafe PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getPVFloat", 0); - /* "PyCafe.pyx":3135 + /* "PyCafe.pyx":3225 * ############################################################################ * def getPVFloat(self, handlePV): * return self.getPV(handlePV, 'float') # <<<<<<<<<<<<<< @@ -71024,7 +73113,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_262getPVFloat(struct __pyx_obj_6PyCafe * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3135, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -71041,7 +73130,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_262getPVFloat(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3135, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3225, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -71049,13 +73138,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_262getPVFloat(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3135, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3225, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3135, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -71066,7 +73155,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_262getPVFloat(struct __pyx_obj_6PyCafe __Pyx_INCREF(__pyx_n_u_float); __Pyx_GIVEREF(__pyx_n_u_float); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_float); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3135, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -71075,7 +73164,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_262getPVFloat(struct __pyx_obj_6PyCafe __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3134 + /* "PyCafe.pyx":3224 * * ############################################################################ * def getPVFloat(self, handlePV): # <<<<<<<<<<<<<< @@ -71099,7 +73188,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_262getPVFloat(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":3139 +/* "PyCafe.pyx":3229 * * ############################################################################ * def getPVStr(self, handlePV): # <<<<<<<<<<<<<< @@ -71130,7 +73219,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_264getPVStr(struct __pyx_obj_6PyCafe_C PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getPVStr", 0); - /* "PyCafe.pyx":3140 + /* "PyCafe.pyx":3230 * ############################################################################ * def getPVStr(self, handlePV): * return self.getPV(handlePV, 'str') # <<<<<<<<<<<<<< @@ -71138,7 +73227,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_264getPVStr(struct __pyx_obj_6PyCafe_C * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3140, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPV); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -71155,7 +73244,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_264getPVStr(struct __pyx_obj_6PyCafe_C #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3140, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3230, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -71163,13 +73252,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_264getPVStr(struct __pyx_obj_6PyCafe_C #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3140, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3230, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3140, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -71180,7 +73269,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_264getPVStr(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_n_u_str); __Pyx_GIVEREF(__pyx_n_u_str); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_str); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3140, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -71189,7 +73278,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_264getPVStr(struct __pyx_obj_6PyCafe_C __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3139 + /* "PyCafe.pyx":3229 * * ############################################################################ * def getPVStr(self, handlePV): # <<<<<<<<<<<<<< @@ -71213,7 +73302,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_264getPVStr(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":3144 +/* "PyCafe.pyx":3234 * * ############################################################################ * def getPV(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -71257,7 +73346,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_267getPV(PyObject *__pyx_v_self, PyObj } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPV") < 0)) __PYX_ERR(3, 3144, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPV") < 0)) __PYX_ERR(3, 3234, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -71273,13 +73362,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_267getPV(PyObject *__pyx_v_self, PyObj } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getPV", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3144, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getPV", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3234, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getPV", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 3144, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 3234, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_266getPV(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_dt); /* function exit code */ @@ -71313,7 +73402,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa struct __pyx_opt_args_6PyCafe_PVDataHolderToStruct __pyx_t_11; __Pyx_RefNannySetupContext("getPV", 0); - /* "PyCafe.pyx":3145 + /* "PyCafe.pyx":3235 * ############################################################################ * def getPV(self, handlePV, str dt='native'): * cdef str _METHOD = "getPV" # <<<<<<<<<<<<<< @@ -71323,7 +73412,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __Pyx_INCREF(__pyx_n_u_getPV); __pyx_v__METHOD = __pyx_n_u_getPV; - /* "PyCafe.pyx":3147 + /* "PyCafe.pyx":3237 * cdef str _METHOD = "getPV" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -71332,7 +73421,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa */ __pyx_v_handle = 0; - /* "PyCafe.pyx":3149 + /* "PyCafe.pyx":3239 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -71353,17 +73442,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3150 + /* "PyCafe.pyx":3240 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3150, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3240, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":3149 + /* "PyCafe.pyx":3239 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -71373,7 +73462,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa goto __pyx_L3; } - /* "PyCafe.pyx":3151 + /* "PyCafe.pyx":3241 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -71384,21 +73473,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3152 + /* "PyCafe.pyx":3242 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format(self._exception_text, _METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 3152, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3152, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 3242, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3152, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3242, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":3151 + /* "PyCafe.pyx":3241 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -71408,7 +73497,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa goto __pyx_L3; } - /* "PyCafe.pyx":3154 + /* "PyCafe.pyx":3244 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format(self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -71416,7 +73505,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa * */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3154, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -71433,7 +73522,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_4}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3154, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3244, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -71441,13 +73530,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_4}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3154, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3244, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3154, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -71461,21 +73550,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_4); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_4); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_4); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3154, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3154, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 3154, __pyx_L1_error) + __PYX_ERR(3, 3244, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":3158 + /* "PyCafe.pyx":3248 * * cdef int status * cdef PVDataHolder pvd = PVDataHolder(self.hh.getNelemNative(handle)) # <<<<<<<<<<<<<< @@ -71486,11 +73575,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __pyx_t_10 = PVDataHolder(__pyx_v_self->hh.getNelemNative(__pyx_v_handle)); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 3158, __pyx_L1_error) + __PYX_ERR(3, 3248, __pyx_L1_error) } __pyx_v_pvd = __pyx_t_10; - /* "PyCafe.pyx":3160 + /* "PyCafe.pyx":3250 * cdef PVDataHolder pvd = PVDataHolder(self.hh.getNelemNative(handle)) * * with nogil: # <<<<<<<<<<<<<< @@ -71505,7 +73594,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa #endif /*try:*/ { - /* "PyCafe.pyx":3161 + /* "PyCafe.pyx":3251 * * with nogil: * status = self._c_cafe.get(handle, pvd) # <<<<<<<<<<<<<< @@ -71515,7 +73604,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __pyx_v_status = __pyx_v_self->_c_cafe->get(__pyx_v_handle, __pyx_v_pvd); } - /* "PyCafe.pyx":3160 + /* "PyCafe.pyx":3250 * cdef PVDataHolder pvd = PVDataHolder(self.hh.getNelemNative(handle)) * * with nogil: # <<<<<<<<<<<<<< @@ -71534,7 +73623,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa } } - /* "PyCafe.pyx":3163 + /* "PyCafe.pyx":3253 * status = self._c_cafe.get(handle, pvd) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -71544,7 +73633,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3164 + /* "PyCafe.pyx":3254 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -71554,7 +73643,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3165 + /* "PyCafe.pyx":3255 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -71564,7 +73653,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3166 + /* "PyCafe.pyx":3256 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -71573,7 +73662,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":3165 + /* "PyCafe.pyx":3255 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -71583,7 +73672,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa goto __pyx_L11; } - /* "PyCafe.pyx":3168 + /* "PyCafe.pyx":3258 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -71595,7 +73684,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa } __pyx_L11:; - /* "PyCafe.pyx":3164 + /* "PyCafe.pyx":3254 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -71604,7 +73693,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa */ } - /* "PyCafe.pyx":3169 + /* "PyCafe.pyx":3259 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -71614,76 +73703,76 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3171 + /* "PyCafe.pyx":3261 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3171, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 3171, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 3171, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3171, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 3261, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 3261, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 3171, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 3261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":3172 + /* "PyCafe.pyx":3262 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3172, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 3171, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 3261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":3173 + /* "PyCafe.pyx":3263 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3173, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 3171, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 3261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3173, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 3171, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 3261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":3174 + /* "PyCafe.pyx":3264 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3174, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3264, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 3171, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 3261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":3170 + /* "PyCafe.pyx":3260 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3170, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":3175 + /* "PyCafe.pyx":3265 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -71691,9 +73780,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa * pvd_valnone = PVDataHolderToStruct(pvd, dt) */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 3175, __pyx_L1_error) + __PYX_ERR(3, 3265, __pyx_L1_error) - /* "PyCafe.pyx":3169 + /* "PyCafe.pyx":3259 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -71702,7 +73791,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa */ } - /* "PyCafe.pyx":3177 + /* "PyCafe.pyx":3267 * raise _cafeException * * pvd_valnone = PVDataHolderToStruct(pvd, dt) # <<<<<<<<<<<<<< @@ -71711,12 +73800,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa */ __pyx_t_11.__pyx_n = 1; __pyx_t_11.dt = __pyx_v_dt; - __pyx_t_5 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct(__pyx_v_pvd, &__pyx_t_11)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3177, __pyx_L1_error) + __pyx_t_5 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct(__pyx_v_pvd, &__pyx_t_11)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_pvd_valnone = ((struct __pyx_obj_6PyCafe_pvdata *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":3178 + /* "PyCafe.pyx":3268 * * pvd_valnone = PVDataHolderToStruct(pvd, dt) * pvd_valnone.value[0] = None # <<<<<<<<<<<<<< @@ -71725,11 +73814,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa */ if (unlikely(__pyx_v_pvd_valnone->value == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 3178, __pyx_L1_error) + __PYX_ERR(3, 3268, __pyx_L1_error) } - if (unlikely(__Pyx_SetItemInt(__pyx_v_pvd_valnone->value, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(3, 3178, __pyx_L1_error) + if (unlikely(__Pyx_SetItemInt(__pyx_v_pvd_valnone->value, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(3, 3268, __pyx_L1_error) - /* "PyCafe.pyx":3179 + /* "PyCafe.pyx":3269 * pvd_valnone = PVDataHolderToStruct(pvd, dt) * pvd_valnone.value[0] = None * return pvd_valnone # <<<<<<<<<<<<<< @@ -71741,7 +73830,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __pyx_r = ((PyObject *)__pyx_v_pvd_valnone); goto __pyx_L0; - /* "PyCafe.pyx":3163 + /* "PyCafe.pyx":3253 * status = self._c_cafe.get(handle, pvd) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -71750,7 +73839,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa */ } - /* "PyCafe.pyx":3181 + /* "PyCafe.pyx":3271 * return pvd_valnone * * return PVDataHolderToStruct(pvd, dt) # <<<<<<<<<<<<<< @@ -71760,13 +73849,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa __Pyx_XDECREF(__pyx_r); __pyx_t_11.__pyx_n = 1; __pyx_t_11.dt = __pyx_v_dt; - __pyx_t_5 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct(__pyx_v_pvd, &__pyx_t_11)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3181, __pyx_L1_error) + __pyx_t_5 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct(__pyx_v_pvd, &__pyx_t_11)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 3271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3144 + /* "PyCafe.pyx":3234 * * ############################################################################ * def getPV(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -71793,7 +73882,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_266getPV(struct __pyx_obj_6PyCafe_CyCa return __pyx_r; } -/* "PyCafe.pyx":3189 +/* "PyCafe.pyx":3279 * ################################################################################## * * def getPVStrList(self, handleList): # <<<<<<<<<<<<<< @@ -71823,7 +73912,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_268getPVStrList(struct __pyx_obj_6PyCa PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getPVStrList", 0); - /* "PyCafe.pyx":3190 + /* "PyCafe.pyx":3280 * * def getPVStrList(self, handleList): * return self.getPVList(handleList, dt='str') # <<<<<<<<<<<<<< @@ -71831,17 +73920,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_268getPVStrList(struct __pyx_obj_6PyCa * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3190, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3280, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3190, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3280, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handleList); __Pyx_GIVEREF(__pyx_v_handleList); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handleList); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3190, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3280, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 3190, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3190, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 3280, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3280, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -71850,7 +73939,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_268getPVStrList(struct __pyx_obj_6PyCa __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3189 + /* "PyCafe.pyx":3279 * ################################################################################## * * def getPVStrList(self, handleList): # <<<<<<<<<<<<<< @@ -71874,7 +73963,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_268getPVStrList(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":3194 +/* "PyCafe.pyx":3284 * * ################################################################################## * def getPVIntList(self, handleList): # <<<<<<<<<<<<<< @@ -71904,7 +73993,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_270getPVIntList(struct __pyx_obj_6PyCa PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getPVIntList", 0); - /* "PyCafe.pyx":3195 + /* "PyCafe.pyx":3285 * ################################################################################## * def getPVIntList(self, handleList): * return self.getPVList(handleList, dt='int') # <<<<<<<<<<<<<< @@ -71912,17 +74001,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_270getPVIntList(struct __pyx_obj_6PyCa * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3195, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3195, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handleList); __Pyx_GIVEREF(__pyx_v_handleList); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handleList); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3195, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 3195, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3195, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 3285, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -71931,7 +74020,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_270getPVIntList(struct __pyx_obj_6PyCa __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3194 + /* "PyCafe.pyx":3284 * * ################################################################################## * def getPVIntList(self, handleList): # <<<<<<<<<<<<<< @@ -71955,7 +74044,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_270getPVIntList(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":3199 +/* "PyCafe.pyx":3289 * * ################################################################################## * def getPVFloatList(self, handleList): # <<<<<<<<<<<<<< @@ -71985,7 +74074,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_272getPVFloatList(struct __pyx_obj_6Py PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getPVFloatList", 0); - /* "PyCafe.pyx":3200 + /* "PyCafe.pyx":3290 * ################################################################################## * def getPVFloatList(self, handleList): * return self.getPVList(handleList, dt='float') # <<<<<<<<<<<<<< @@ -71993,17 +74082,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_272getPVFloatList(struct __pyx_obj_6Py * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3200, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3200, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handleList); __Pyx_GIVEREF(__pyx_v_handleList); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handleList); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3200, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 3200, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3200, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 3290, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -72012,7 +74101,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_272getPVFloatList(struct __pyx_obj_6Py __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3199 + /* "PyCafe.pyx":3289 * * ################################################################################## * def getPVFloatList(self, handleList): # <<<<<<<<<<<<<< @@ -72036,7 +74125,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_272getPVFloatList(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":3204 +/* "PyCafe.pyx":3294 * * ################################################################################## * def getPVList(self, handleList, str dt='native', cacheFlag=False): # <<<<<<<<<<<<<< @@ -72090,7 +74179,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_275getPVList(PyObject *__pyx_v_self, P } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPVList") < 0)) __PYX_ERR(3, 3204, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPVList") < 0)) __PYX_ERR(3, 3294, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -72109,13 +74198,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_275getPVList(PyObject *__pyx_v_self, P } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getPVList", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3204, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getPVList", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3294, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getPVList", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 3204, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 3294, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_274getPVList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handleList, __pyx_v_dt, __pyx_v_cacheFlag); /* function exit code */ @@ -72173,7 +74262,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_RefNannySetupContext("getPVList", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":3205 + /* "PyCafe.pyx":3295 * ################################################################################## * def getPVList(self, handleList, str dt='native', cacheFlag=False): * cdef str _METHOD = "getPVList" # <<<<<<<<<<<<<< @@ -72183,7 +74272,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_INCREF(__pyx_n_u_getPVList); __pyx_v__METHOD = __pyx_n_u_getPVList; - /* "PyCafe.pyx":3207 + /* "PyCafe.pyx":3297 * cdef str _METHOD = "getPVList" * * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -72211,40 +74300,40 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3208 + /* "PyCafe.pyx":3298 * * if isinstance(handleList, (str, int, long)): * hl = [] # <<<<<<<<<<<<<< * hl.append(handleList) * handleList = [] */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3208, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_hl = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3209 + /* "PyCafe.pyx":3299 * if isinstance(handleList, (str, int, long)): * hl = [] * hl.append(handleList) # <<<<<<<<<<<<<< * handleList = [] * handleList = hl */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_hl, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3209, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_hl, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3299, __pyx_L1_error) - /* "PyCafe.pyx":3210 + /* "PyCafe.pyx":3300 * hl = [] * hl.append(handleList) * handleList = [] # <<<<<<<<<<<<<< * handleList = hl * */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3210, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3211 + /* "PyCafe.pyx":3301 * hl.append(handleList) * handleList = [] * handleList = hl # <<<<<<<<<<<<<< @@ -72254,7 +74343,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_INCREF(__pyx_v_hl); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_v_hl); - /* "PyCafe.pyx":3207 + /* "PyCafe.pyx":3297 * cdef str _METHOD = "getPVList" * * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -72263,34 +74352,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3213 + /* "PyCafe.pyx":3303 * handleList = hl * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3213, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3214 + /* "PyCafe.pyx":3304 * * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) # <<<<<<<<<<<<<< * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3214, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3214, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3304, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3213 + /* "PyCafe.pyx":3303 * handleList = hl * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -72300,14 +74389,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L7; } - /* "PyCafe.pyx":3215 + /* "PyCafe.pyx":3305 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3215, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyInt_Check(__pyx_t_4); __pyx_t_2 = (__pyx_t_3 != 0); @@ -72324,17 +74413,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3216 + /* "PyCafe.pyx":3306 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument should be a 'list' of of type \ */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3216, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":3217 + /* "PyCafe.pyx":3307 * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -72356,7 +74445,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_2}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3216, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3306, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else @@ -72364,13 +74453,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_2}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3216, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3306, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3216, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -72384,27 +74473,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_a_2); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_a_2); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_a_2); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3216, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3216 + /* "PyCafe.pyx":3306 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * "First input argument should be a 'list' of of type \ */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3216, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 3216, __pyx_L1_error) + __PYX_ERR(3, 3306, __pyx_L1_error) - /* "PyCafe.pyx":3215 + /* "PyCafe.pyx":3305 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -72414,38 +74503,38 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ } __pyx_L7:; - /* "PyCafe.pyx":3235 + /* "PyCafe.pyx":3325 * # do this to avoid compiler warning messages * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * v.push_back(handleList[i]) * */ - __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3235, __pyx_L1_error) + __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3325, __pyx_L1_error) __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; - /* "PyCafe.pyx":3236 + /* "PyCafe.pyx":3326 * * for i in range(0, len(handleList)): * v.push_back(handleList[i]) # <<<<<<<<<<<<<< * * cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3236, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3236, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3326, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_v.push_back(__pyx_t_13); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 3236, __pyx_L1_error) + __PYX_ERR(3, 3326, __pyx_L1_error) } } - /* "PyCafe.pyx":3238 + /* "PyCafe.pyx":3328 * v.push_back(handleList[i]) * * cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) # <<<<<<<<<<<<<< @@ -72454,7 +74543,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_pvd = __pyx_v_self->_c_cafe->getPVData(__pyx_v_v); - /* "PyCafe.pyx":3240 + /* "PyCafe.pyx":3330 * cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) * * for i in range(0, v.size()): # len(handleList)): # # <<<<<<<<<<<<<< @@ -72466,7 +74555,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_14; __pyx_t_10+=1) { __pyx_v_i = __pyx_t_10; - /* "PyCafe.pyx":3241 + /* "PyCafe.pyx":3331 * * for i in range(0, v.size()): # len(handleList)): # * pvd[i].setNelem(self.hh.getNelemNative(v[i])) # handleList[i])) # <<<<<<<<<<<<<< @@ -72476,17 +74565,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ (void)((__pyx_v_pvd[__pyx_v_i]).setNelem(__pyx_v_self->hh.getNelemNative((__pyx_v_v[__pyx_v_i])))); } - /* "PyCafe.pyx":3246 + /* "PyCafe.pyx":3336 * cdef int status * * if cacheFlag: # <<<<<<<<<<<<<< * status = self._c_cafe.getCachePVArray(v, pvd) * else: */ - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_cacheFlag); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 3246, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_cacheFlag); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 3336, __pyx_L1_error) if (__pyx_t_3) { - /* "PyCafe.pyx":3247 + /* "PyCafe.pyx":3337 * * if cacheFlag: * status = self._c_cafe.getCachePVArray(v, pvd) # <<<<<<<<<<<<<< @@ -72495,7 +74584,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_status = __pyx_v_self->_c_cafe->getCachePVArray(__pyx_v_v, __pyx_v_pvd); - /* "PyCafe.pyx":3246 + /* "PyCafe.pyx":3336 * cdef int status * * if cacheFlag: # <<<<<<<<<<<<<< @@ -72505,7 +74594,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L14; } - /* "PyCafe.pyx":3249 + /* "PyCafe.pyx":3339 * status = self._c_cafe.getCachePVArray(v, pvd) * else: * with nogil: # <<<<<<<<<<<<<< @@ -72521,7 +74610,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ #endif /*try:*/ { - /* "PyCafe.pyx":3250 + /* "PyCafe.pyx":3340 * else: * with nogil: * status = self._c_cafe.getPVArray(v, pvd) # <<<<<<<<<<<<<< @@ -72531,7 +74620,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_v_status = __pyx_v_self->_c_cafe->getPVArray(__pyx_v_v, __pyx_v_pvd); } - /* "PyCafe.pyx":3249 + /* "PyCafe.pyx":3339 * status = self._c_cafe.getCachePVArray(v, pvd) * else: * with nogil: # <<<<<<<<<<<<<< @@ -72552,7 +74641,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ } __pyx_L14:; - /* "PyCafe.pyx":3252 + /* "PyCafe.pyx":3342 * status = self._c_cafe.getPVArray(v, pvd) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -72562,7 +74651,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_3 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3253 + /* "PyCafe.pyx":3343 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -72572,7 +74661,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_3 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3254 + /* "PyCafe.pyx":3344 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -72581,7 +74670,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":3255 + /* "PyCafe.pyx":3345 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -72593,7 +74682,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_14; __pyx_t_10+=1) { __pyx_v_i = __pyx_t_10; - /* "PyCafe.pyx":3256 + /* "PyCafe.pyx":3346 * self._c_cafe.printStatusMessage(status) * for i in range(0, v.size()): #len(handleList)): * if (pvd[i].getStatus() != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -72603,38 +74692,38 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_3 = (((__pyx_v_pvd[__pyx_v_i]).getStatus() != ICAFE_NORMAL) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3257 + /* "PyCafe.pyx":3347 * for i in range(0, v.size()): #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()) */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3257, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":3258 + /* "PyCafe.pyx":3348 * 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) */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3258, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3258, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_13)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3258, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_13)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "PyCafe.pyx":3257 + /* "PyCafe.pyx":3347 * for i in range(0, v.size()): #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()) */ - __pyx_t_9 = PyTuple_New(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3257, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_kp_u_Handle); __Pyx_GIVEREF(__pyx_kp_u_Handle); @@ -72648,21 +74737,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ PyTuple_SET_ITEM(__pyx_t_9, 3, __pyx_t_4); __pyx_t_6 = 0; __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3257, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3259 + /* "PyCafe.pyx":3349 * print("Handle=", handleList[i], "PV=", * self.hh.getPVFromHandle(handleList[i])) * print("with error status=", pvd[i].getStatus()) # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * print("") */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3259, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3259, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_kp_u_with_error_status); __Pyx_GIVEREF(__pyx_kp_u_with_error_status); @@ -72670,12 +74759,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3259, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3260 + /* "PyCafe.pyx":3350 * self.hh.getPVFromHandle(handleList[i])) * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -72684,18 +74773,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":3261 + /* "PyCafe.pyx":3351 * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(status) * print("") # <<<<<<<<<<<<<< * #raise Exception("EXCEPTION RAISED in PyCafe def getPVList. Status = %d" %status) * */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3261, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3256 + /* "PyCafe.pyx":3346 * self._c_cafe.printStatusMessage(status) * for i in range(0, v.size()): #len(handleList)): * if (pvd[i].getStatus() != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -72705,7 +74794,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ } } - /* "PyCafe.pyx":3253 + /* "PyCafe.pyx":3343 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -72714,7 +74803,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3252 + /* "PyCafe.pyx":3342 * status = self._c_cafe.getPVArray(v, pvd) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -72723,19 +74812,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3269 + /* "PyCafe.pyx":3359 * cdef CAFEDataTypeCode cdt * * pvdList = [] # <<<<<<<<<<<<<< * cpdef pvdata p1 * */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3269, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3359, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_pvdList = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3274 + /* "PyCafe.pyx":3364 * cdef bytes bytesVal * * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -72747,7 +74836,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_14; __pyx_t_10+=1) { __pyx_v_i = __pyx_t_10; - /* "PyCafe.pyx":3275 + /* "PyCafe.pyx":3365 * * for i in range(0, v.size()): #len(handleList)): * dtn = pvd[i].getDataType() # <<<<<<<<<<<<<< @@ -72756,35 +74845,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_dtn = (__pyx_v_pvd[__pyx_v_i]).getDataType(); - /* "PyCafe.pyx":3277 + /* "PyCafe.pyx":3367 * dtn = pvd[i].getDataType() * * dtcheck = getMatchedDataType(dt, dtn) # <<<<<<<<<<<<<< * localList = [] * */ - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3277, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3277, __pyx_L1_error) + __pyx_t_9 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3277, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3367, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_dtcheck = __pyx_t_13; - /* "PyCafe.pyx":3278 + /* "PyCafe.pyx":3368 * * dtcheck = getMatchedDataType(dt, dtn) * localList = [] # <<<<<<<<<<<<<< * * if pvd[i].getNelem() == 1: */ - __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3278, __pyx_L1_error) + __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_localList, ((PyObject*)__pyx_t_9)); __pyx_t_9 = 0; - /* "PyCafe.pyx":3280 + /* "PyCafe.pyx":3370 * localList = [] * * if pvd[i].getNelem() == 1: # <<<<<<<<<<<<<< @@ -72794,7 +74883,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_3 = (((__pyx_v_pvd[__pyx_v_i]).getNelem() == 1) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3281 + /* "PyCafe.pyx":3371 * * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -72804,14 +74893,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":3282 + /* "PyCafe.pyx":3372 * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: * bytesVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): */ - __pyx_t_9 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3282, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = __pyx_t_9; __Pyx_INCREF(__pyx_t_4); @@ -72819,7 +74908,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; - /* "PyCafe.pyx":3283 + /* "PyCafe.pyx":3373 * if dtcheck == CAFE_STRING: * bytesVal = pvd[i].getAsString() * encoding = False # <<<<<<<<<<<<<< @@ -72828,21 +74917,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":3284 + /* "PyCafe.pyx":3374 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3284, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 3284, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 3374, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3285 + /* "PyCafe.pyx":3375 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -72858,7 +74947,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XGOTREF(__pyx_t_17); /*try:*/ { - /* "PyCafe.pyx":3286 + /* "PyCafe.pyx":3376 * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -72867,14 +74956,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3286, __pyx_L27_error) + __PYX_ERR(3, 3376, __pyx_L27_error) } - __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3286, __pyx_L27_error) + __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3376, __pyx_L27_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3287 + /* "PyCafe.pyx":3377 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -72883,7 +74972,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3285 + /* "PyCafe.pyx":3375 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -72901,7 +74990,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3288 + /* "PyCafe.pyx":3378 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -72916,7 +75005,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L29_except_error; __pyx_L29_except_error:; - /* "PyCafe.pyx":3285 + /* "PyCafe.pyx":3375 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -72936,7 +75025,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_L34_try_end:; } - /* "PyCafe.pyx":3284 + /* "PyCafe.pyx":3374 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< @@ -72945,7 +75034,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3290 + /* "PyCafe.pyx":3380 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -72955,7 +75044,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3291 + /* "PyCafe.pyx":3381 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -72971,7 +75060,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XGOTREF(__pyx_t_15); /*try:*/ { - /* "PyCafe.pyx":3292 + /* "PyCafe.pyx":3382 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -72980,14 +75069,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3292, __pyx_L36_error) + __PYX_ERR(3, 3382, __pyx_L36_error) } - __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3292, __pyx_L36_error) + __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3382, __pyx_L36_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3293 + /* "PyCafe.pyx":3383 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -72996,7 +75085,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3291 + /* "PyCafe.pyx":3381 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73014,7 +75103,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3294 + /* "PyCafe.pyx":3384 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -73029,7 +75118,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L38_except_error; __pyx_L38_except_error:; - /* "PyCafe.pyx":3291 + /* "PyCafe.pyx":3381 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73049,7 +75138,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_L43_try_end:; } - /* "PyCafe.pyx":3290 + /* "PyCafe.pyx":3380 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73058,7 +75147,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3296 + /* "PyCafe.pyx":3386 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73068,7 +75157,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3297 + /* "PyCafe.pyx":3387 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73084,7 +75173,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XGOTREF(__pyx_t_17); /*try:*/ { - /* "PyCafe.pyx":3298 + /* "PyCafe.pyx":3388 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -73093,14 +75182,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3298, __pyx_L45_error) + __PYX_ERR(3, 3388, __pyx_L45_error) } - __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3298, __pyx_L45_error) + __pyx_t_4 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3388, __pyx_L45_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3299 + /* "PyCafe.pyx":3389 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -73109,7 +75198,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3297 + /* "PyCafe.pyx":3387 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73127,7 +75216,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3300 + /* "PyCafe.pyx":3390 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -73142,7 +75231,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L47_except_error; __pyx_L47_except_error:; - /* "PyCafe.pyx":3297 + /* "PyCafe.pyx":3387 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73162,7 +75251,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_L52_try_end:; } - /* "PyCafe.pyx":3296 + /* "PyCafe.pyx":3386 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73171,7 +75260,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3302 + /* "PyCafe.pyx":3392 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73181,19 +75270,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3303 + /* "PyCafe.pyx":3393 * pass * if not encoding: * strVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * * localList.append(strVal) */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3303, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3302 + /* "PyCafe.pyx":3392 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73202,17 +75291,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3305 + /* "PyCafe.pyx":3395 * strVal = pvd[i].getAsString() * * localList.append(strVal) # <<<<<<<<<<<<<< * * elif dtcheck == CAFE_SHORT: */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 3305, __pyx_L1_error) } - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3305, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 3395, __pyx_L1_error) } + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3395, __pyx_L1_error) - /* "PyCafe.pyx":3281 + /* "PyCafe.pyx":3371 * * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -73222,19 +75311,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_SHORT: - /* "PyCafe.pyx":3308 + /* "PyCafe.pyx":3398 * * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3308, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3308, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3398, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3307 + /* "PyCafe.pyx":3397 * localList.append(strVal) * * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -73244,19 +75333,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_FLOAT: - /* "PyCafe.pyx":3310 + /* "PyCafe.pyx":3400 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native */ - __pyx_t_4 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3310, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3400, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3310, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3400, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3309 + /* "PyCafe.pyx":3399 * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -73266,33 +75355,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_ENUM: - /* "PyCafe.pyx":3313 + /* "PyCafe.pyx":3403 * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native * if self._c_cafe.isEnum(handleList[i]): # <<<<<<<<<<<<<< * localList.append(pvd[i].getAsString()) * else: */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3313, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3313, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3403, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = (__pyx_v_self->_c_cafe->isEnum(__pyx_t_13) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3314 + /* "PyCafe.pyx":3404 * # if enum, string taken as native * if self._c_cafe.isEnum(handleList[i]): * localList.append(pvd[i].getAsString()) # <<<<<<<<<<<<<< * else: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3314, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3314, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3404, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3313 + /* "PyCafe.pyx":3403 * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native * if self._c_cafe.isEnum(handleList[i]): # <<<<<<<<<<<<<< @@ -73302,7 +75391,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L54; } - /* "PyCafe.pyx":3316 + /* "PyCafe.pyx":3406 * localList.append(pvd[i].getAsString()) * else: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< @@ -73310,14 +75399,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ * # ( pvd[i].getAsChar()) */ /*else*/ { - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3316, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3316, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3406, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_L54:; - /* "PyCafe.pyx":3311 + /* "PyCafe.pyx":3401 * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -73327,19 +75416,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_CHAR: - /* "PyCafe.pyx":3319 + /* "PyCafe.pyx":3409 * elif dtcheck == CAFE_CHAR: * # ( pvd[i].getAsChar()) * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3319, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3319, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3409, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3317 + /* "PyCafe.pyx":3407 * else: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -73349,19 +75438,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_LONG: - /* "PyCafe.pyx":3321 + /* "PyCafe.pyx":3411 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3321, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3321, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3411, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3320 + /* "PyCafe.pyx":3410 * # ( pvd[i].getAsChar()) * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -73371,19 +75460,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_DOUBLE: - /* "PyCafe.pyx":3323 + /* "PyCafe.pyx":3413 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * else: * localList.append(0) # no data */ - __pyx_t_4 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3323, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3323, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3413, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3322 + /* "PyCafe.pyx":3412 * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -73393,18 +75482,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; default: - /* "PyCafe.pyx":3325 + /* "PyCafe.pyx":3415 * localList.append(pvd[i].getAsDouble()) * else: * localList.append(0) # no data # <<<<<<<<<<<<<< * * else: */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3325, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3415, __pyx_L1_error) break; } - /* "PyCafe.pyx":3280 + /* "PyCafe.pyx":3370 * localList = [] * * if pvd[i].getNelem() == 1: # <<<<<<<<<<<<<< @@ -73414,7 +75503,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L25; } - /* "PyCafe.pyx":3328 + /* "PyCafe.pyx":3418 * * else: * localListInner = [] # <<<<<<<<<<<<<< @@ -73422,12 +75511,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ * for j in range(0, pvd[i].getNelem()): */ /*else*/ { - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3328, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_localListInner, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; - /* "PyCafe.pyx":3329 + /* "PyCafe.pyx":3419 * else: * localListInner = [] * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -73437,7 +75526,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":3330 + /* "PyCafe.pyx":3420 * localListInner = [] * if dtcheck == CAFE_STRING: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -73449,14 +75538,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":3332 + /* "PyCafe.pyx":3422 * for j in range(0, pvd[i].getNelem()): * * bytesVal = pvd[i].getAsString(j) # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): */ - __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3332, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = __pyx_t_4; __Pyx_INCREF(__pyx_t_9); @@ -73464,7 +75553,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_9)); __pyx_t_9 = 0; - /* "PyCafe.pyx":3333 + /* "PyCafe.pyx":3423 * * bytesVal = pvd[i].getAsString(j) * encoding = False # <<<<<<<<<<<<<< @@ -73473,21 +75562,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":3334 + /* "PyCafe.pyx":3424 * bytesVal = pvd[i].getAsString(j) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_9 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3334, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_9, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 3334, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_9, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 3424, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3335 + /* "PyCafe.pyx":3425 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -73503,7 +75592,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XGOTREF(__pyx_t_15); /*try:*/ { - /* "PyCafe.pyx":3336 + /* "PyCafe.pyx":3426 * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -73512,14 +75601,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3336, __pyx_L58_error) + __PYX_ERR(3, 3426, __pyx_L58_error) } - __pyx_t_9 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3336, __pyx_L58_error) + __pyx_t_9 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3426, __pyx_L58_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3337 + /* "PyCafe.pyx":3427 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -73528,7 +75617,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3335 + /* "PyCafe.pyx":3425 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -73546,7 +75635,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3338 + /* "PyCafe.pyx":3428 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -73561,7 +75650,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L60_except_error; __pyx_L60_except_error:; - /* "PyCafe.pyx":3335 + /* "PyCafe.pyx":3425 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -73581,7 +75670,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_L65_try_end:; } - /* "PyCafe.pyx":3334 + /* "PyCafe.pyx":3424 * bytesVal = pvd[i].getAsString(j) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< @@ -73590,7 +75679,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3340 + /* "PyCafe.pyx":3430 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73600,7 +75689,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_3 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3341 + /* "PyCafe.pyx":3431 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73616,7 +75705,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XGOTREF(__pyx_t_17); /*try:*/ { - /* "PyCafe.pyx":3342 + /* "PyCafe.pyx":3432 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -73625,14 +75714,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3342, __pyx_L67_error) + __PYX_ERR(3, 3432, __pyx_L67_error) } - __pyx_t_9 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3342, __pyx_L67_error) + __pyx_t_9 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3432, __pyx_L67_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3343 + /* "PyCafe.pyx":3433 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -73641,7 +75730,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3341 + /* "PyCafe.pyx":3431 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73659,7 +75748,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3344 + /* "PyCafe.pyx":3434 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -73674,7 +75763,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L69_except_error; __pyx_L69_except_error:; - /* "PyCafe.pyx":3341 + /* "PyCafe.pyx":3431 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73694,7 +75783,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_L74_try_end:; } - /* "PyCafe.pyx":3340 + /* "PyCafe.pyx":3430 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73703,7 +75792,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3346 + /* "PyCafe.pyx":3436 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73713,7 +75802,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_3 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3347 + /* "PyCafe.pyx":3437 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73729,7 +75818,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XGOTREF(__pyx_t_15); /*try:*/ { - /* "PyCafe.pyx":3348 + /* "PyCafe.pyx":3438 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -73738,14 +75827,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3348, __pyx_L76_error) + __PYX_ERR(3, 3438, __pyx_L76_error) } - __pyx_t_9 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3348, __pyx_L76_error) + __pyx_t_9 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3438, __pyx_L76_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3349 + /* "PyCafe.pyx":3439 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -73754,7 +75843,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3347 + /* "PyCafe.pyx":3437 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73772,7 +75861,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3350 + /* "PyCafe.pyx":3440 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -73787,7 +75876,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L78_except_error; __pyx_L78_except_error:; - /* "PyCafe.pyx":3347 + /* "PyCafe.pyx":3437 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -73807,7 +75896,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_L83_try_end:; } - /* "PyCafe.pyx":3346 + /* "PyCafe.pyx":3436 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73816,7 +75905,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3352 + /* "PyCafe.pyx":3442 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73826,19 +75915,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_3 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3353 + /* "PyCafe.pyx":3443 * pass * if not encoding: * strVal = pvd[i].getAsString(j) # <<<<<<<<<<<<<< * localListInner.append(strVal) #pvd[i].getAsString(j)) * elif dtcheck == CAFE_SHORT: */ - __pyx_t_9 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3353, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3443, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3352 + /* "PyCafe.pyx":3442 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -73847,18 +75936,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":3354 + /* "PyCafe.pyx":3444 * if not encoding: * strVal = pvd[i].getAsString(j) * localListInner.append(strVal) #pvd[i].getAsString(j)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_SHORT: * for j in range(0, pvd[i].getNelem()): */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 3354, __pyx_L1_error) } - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_v_strVal); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3354, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 3444, __pyx_L1_error) } + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_v_strVal); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3444, __pyx_L1_error) } - /* "PyCafe.pyx":3329 + /* "PyCafe.pyx":3419 * else: * localListInner = [] * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -73868,7 +75957,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_SHORT: - /* "PyCafe.pyx":3356 + /* "PyCafe.pyx":3446 * localListInner.append(strVal) #pvd[i].getAsString(j)) * elif dtcheck == CAFE_SHORT: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -73880,20 +75969,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":3357 + /* "PyCafe.pyx":3447 * 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()): */ - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3357, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3357, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3447, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } - /* "PyCafe.pyx":3355 + /* "PyCafe.pyx":3445 * strVal = pvd[i].getAsString(j) * localListInner.append(strVal) #pvd[i].getAsString(j)) * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -73903,7 +75992,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_FLOAT: - /* "PyCafe.pyx":3359 + /* "PyCafe.pyx":3449 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_FLOAT: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -73915,20 +76004,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":3360 + /* "PyCafe.pyx":3450 * 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()): */ - __pyx_t_9 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3360, __pyx_L1_error) + __pyx_t_9 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3360, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3450, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } - /* "PyCafe.pyx":3358 + /* "PyCafe.pyx":3448 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -73938,7 +76027,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_ENUM: - /* "PyCafe.pyx":3362 + /* "PyCafe.pyx":3452 * localListInner.append(pvd[i].getAsDouble(j)) * elif dtcheck == CAFE_ENUM: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -73950,33 +76039,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":3364 + /* "PyCafe.pyx":3454 * 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: */ - __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3364, __pyx_L1_error) + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_21 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_21 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3364, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_21 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3454, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_3 = (__pyx_v_self->_c_cafe->isEnum(__pyx_t_21) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3365 + /* "PyCafe.pyx":3455 * # 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)) */ - __pyx_t_9 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3365, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3365, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3455, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3364 + /* "PyCafe.pyx":3454 * for j in range(0, pvd[i].getNelem()): * # if enum, string taken as native * if self._c_cafe.isEnum(handleList[i]): # <<<<<<<<<<<<<< @@ -73986,7 +76075,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ goto __pyx_L91; } - /* "PyCafe.pyx":3367 + /* "PyCafe.pyx":3457 * localListInner.append(pvd[i].getAsString(j)) * else: * localListInner.append(pvd[i].getAsLong(j)) # <<<<<<<<<<<<<< @@ -73994,15 +76083,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ * for j in range(0, pvd[i].getNelem()): */ /*else*/ { - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3367, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3367, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3457, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_L91:; } - /* "PyCafe.pyx":3361 + /* "PyCafe.pyx":3451 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsDouble(j)) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -74012,7 +76101,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_CHAR: - /* "PyCafe.pyx":3369 + /* "PyCafe.pyx":3459 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_CHAR: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -74024,20 +76113,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":3371 + /* "PyCafe.pyx":3461 * for j in range(0, pvd[i].getNelem()): * # ( pvd[i].getAsChar(j)) * localListInner.append(pvd[i].getAsLong(j)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * for j in range(0, pvd[i].getNelem()): */ - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3371, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3371, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3461, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } - /* "PyCafe.pyx":3368 + /* "PyCafe.pyx":3458 * else: * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -74047,7 +76136,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_LONG: - /* "PyCafe.pyx":3373 + /* "PyCafe.pyx":3463 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_LONG: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -74059,20 +76148,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":3374 + /* "PyCafe.pyx":3464 * 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()): */ - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3374, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3464, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3374, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3464, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } - /* "PyCafe.pyx":3372 + /* "PyCafe.pyx":3462 * # ( pvd[i].getAsChar(j)) * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -74082,7 +76171,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; case CAFE_DOUBLE: - /* "PyCafe.pyx":3376 + /* "PyCafe.pyx":3466 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_DOUBLE: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -74094,20 +76183,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":3377 + /* "PyCafe.pyx":3467 * 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()): */ - __pyx_t_9 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3377, __pyx_L1_error) + __pyx_t_9 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3377, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3467, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } - /* "PyCafe.pyx":3375 + /* "PyCafe.pyx":3465 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -74117,7 +76206,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ break; default: - /* "PyCafe.pyx":3379 + /* "PyCafe.pyx":3469 * localListInner.append(pvd[i].getAsDouble(j)) * else: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -74129,42 +76218,42 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":3380 + /* "PyCafe.pyx":3470 * else: * for j in range(0, pvd[i].getNelem()): * localListInner.append(0) # no data # <<<<<<<<<<<<<< * localList.append(localListInner) * */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_int_0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3380, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_int_0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3470, __pyx_L1_error) } break; } - /* "PyCafe.pyx":3381 + /* "PyCafe.pyx":3471 * for j in range(0, pvd[i].getNelem()): * localListInner.append(0) # no data * localList.append(localListInner) # <<<<<<<<<<<<<< * * p1 = pvdata() */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_localListInner); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3381, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_localListInner); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3471, __pyx_L1_error) } __pyx_L25:; - /* "PyCafe.pyx":3383 + /* "PyCafe.pyx":3473 * localList.append(localListInner) * * p1 = pvdata() # <<<<<<<<<<<<<< * p1.value = localList * p1.status = pvd[i].getStatus() */ - __pyx_t_9 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvdata)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3383, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvdata)); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_p1, ((struct __pyx_obj_6PyCafe_pvdata *)__pyx_t_9)); __pyx_t_9 = 0; - /* "PyCafe.pyx":3384 + /* "PyCafe.pyx":3474 * * p1 = pvdata() * p1.value = localList # <<<<<<<<<<<<<< @@ -74177,7 +76266,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_DECREF(__pyx_v_p1->value); __pyx_v_p1->value = __pyx_v_localList; - /* "PyCafe.pyx":3385 + /* "PyCafe.pyx":3475 * p1 = pvdata() * p1.value = localList * p1.status = pvd[i].getStatus() # <<<<<<<<<<<<<< @@ -74186,14 +76275,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_p1->status = (__pyx_v_pvd[__pyx_v_i]).getStatus(); - /* "PyCafe.pyx":3386 + /* "PyCafe.pyx":3476 * p1.value = localList * p1.status = pvd[i].getStatus() * p1.statusAsString = pvd[i].getStatusAsString() # <<<<<<<<<<<<<< * p1.nelem = pvd[i].getNelem() * p1.alarmStatus = pvd[i].getAlarmStatus() */ - __pyx_t_9 = __pyx_convert_PyUnicode_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getStatusAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3386, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_PyUnicode_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getStatusAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __Pyx_GOTREF(__pyx_v_p1->statusAsString); @@ -74201,7 +76290,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_v_p1->statusAsString = ((PyObject*)__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3387 + /* "PyCafe.pyx":3477 * p1.status = pvd[i].getStatus() * p1.statusAsString = pvd[i].getStatusAsString() * p1.nelem = pvd[i].getNelem() # <<<<<<<<<<<<<< @@ -74210,7 +76299,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_p1->nelem = (__pyx_v_pvd[__pyx_v_i]).getNelem(); - /* "PyCafe.pyx":3388 + /* "PyCafe.pyx":3478 * p1.statusAsString = pvd[i].getStatusAsString() * p1.nelem = pvd[i].getNelem() * p1.alarmStatus = pvd[i].getAlarmStatus() # <<<<<<<<<<<<<< @@ -74219,7 +76308,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_p1->alarmStatus = (__pyx_v_pvd[__pyx_v_i]).getAlarmStatus(); - /* "PyCafe.pyx":3389 + /* "PyCafe.pyx":3479 * p1.nelem = pvd[i].getNelem() * p1.alarmStatus = pvd[i].getAlarmStatus() * p1.alarmSeverity = pvd[i].getAlarmSeverity() # <<<<<<<<<<<<<< @@ -74228,14 +76317,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_p1->alarmSeverity = (__pyx_v_pvd[__pyx_v_i]).getAlarmSeverity(); - /* "PyCafe.pyx":3390 + /* "PyCafe.pyx":3480 * p1.alarmStatus = pvd[i].getAlarmStatus() * p1.alarmSeverity = pvd[i].getAlarmSeverity() * p1.alarmStatusAsString = pvd[i].getAlarmStatusAsString() # <<<<<<<<<<<<<< * p1.alarmSeverityAsString = pvd[i].getAlarmSeverityAsString() * p1.dataType = pvd[i].getDataType() */ - __pyx_t_9 = __pyx_convert_PyUnicode_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAlarmStatusAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3390, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_PyUnicode_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAlarmStatusAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __Pyx_GOTREF(__pyx_v_p1->alarmStatusAsString); @@ -74243,14 +76332,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_v_p1->alarmStatusAsString = ((PyObject*)__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3391 + /* "PyCafe.pyx":3481 * p1.alarmSeverity = pvd[i].getAlarmSeverity() * p1.alarmStatusAsString = pvd[i].getAlarmStatusAsString() * p1.alarmSeverityAsString = pvd[i].getAlarmSeverityAsString() # <<<<<<<<<<<<<< * p1.dataType = pvd[i].getDataType() * p1.dataTypeAsString = cdt.message(pvd[i].getDataType()) */ - __pyx_t_9 = __pyx_convert_PyUnicode_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAlarmSeverityAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3391, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_PyUnicode_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAlarmSeverityAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __Pyx_GOTREF(__pyx_v_p1->alarmSeverityAsString); @@ -74258,7 +76347,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_v_p1->alarmSeverityAsString = ((PyObject*)__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3392 + /* "PyCafe.pyx":3482 * p1.alarmStatusAsString = pvd[i].getAlarmStatusAsString() * p1.alarmSeverityAsString = pvd[i].getAlarmSeverityAsString() * p1.dataType = pvd[i].getDataType() # <<<<<<<<<<<<<< @@ -74267,14 +76356,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_p1->dataType = (__pyx_v_pvd[__pyx_v_i]).getDataType(); - /* "PyCafe.pyx":3393 + /* "PyCafe.pyx":3483 * p1.alarmSeverityAsString = pvd[i].getAlarmSeverityAsString() * p1.dataType = pvd[i].getDataType() * p1.dataTypeAsString = cdt.message(pvd[i].getDataType()) # <<<<<<<<<<<<<< * pvd._etsNorm = pvd[i].getEpicsTimeStampAsUInt32() * */ - __pyx_t_9 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_cdt.message((__pyx_v_pvd[__pyx_v_i]).getDataType())); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3393, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_cdt.message((__pyx_v_pvd[__pyx_v_i]).getDataType())); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __Pyx_GOTREF(__pyx_v_p1->dataTypeAsString); @@ -74282,7 +76371,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_v_p1->dataTypeAsString = ((PyObject*)__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3394 + /* "PyCafe.pyx":3484 * p1.dataType = pvd[i].getDataType() * p1.dataTypeAsString = cdt.message(pvd[i].getDataType()) * pvd._etsNorm = pvd[i].getEpicsTimeStampAsUInt32() # <<<<<<<<<<<<<< @@ -74291,43 +76380,43 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_pvd->_etsNorm = (__pyx_v_pvd[__pyx_v_i]).getEpicsTimeStampAsUInt32(); - /* "PyCafe.pyx":3396 + /* "PyCafe.pyx":3486 * pvd._etsNorm = pvd[i].getEpicsTimeStampAsUInt32() * * ll = [] # <<<<<<<<<<<<<< * ll.append((pvd[i]._etsNorm).secPastEpoch) * ll.append((pvd[i]._etsNorm).nsec) */ - __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3396, __pyx_L1_error) + __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3486, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_ll, ((PyObject*)__pyx_t_9)); __pyx_t_9 = 0; - /* "PyCafe.pyx":3397 + /* "PyCafe.pyx":3487 * * ll = [] * ll.append((pvd[i]._etsNorm).secPastEpoch) # <<<<<<<<<<<<<< * ll.append((pvd[i]._etsNorm).nsec) * p1.ts = ll */ - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int((__pyx_v_pvd[__pyx_v_i])._etsNorm.secPastEpoch); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3397, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int((__pyx_v_pvd[__pyx_v_i])._etsNorm.secPastEpoch); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3397, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3487, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3398 + /* "PyCafe.pyx":3488 * ll = [] * ll.append((pvd[i]._etsNorm).secPastEpoch) * ll.append((pvd[i]._etsNorm).nsec) # <<<<<<<<<<<<<< * p1.ts = ll * */ - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int((__pyx_v_pvd[__pyx_v_i])._etsNorm.nsec); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3398, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int((__pyx_v_pvd[__pyx_v_i])._etsNorm.nsec); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3488, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3398, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3488, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3399 + /* "PyCafe.pyx":3489 * ll.append((pvd[i]._etsNorm).secPastEpoch) * ll.append((pvd[i]._etsNorm).nsec) * p1.ts = ll # <<<<<<<<<<<<<< @@ -74340,7 +76429,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_DECREF(__pyx_v_p1->ts); __pyx_v_p1->ts = __pyx_v_ll; - /* "PyCafe.pyx":3401 + /* "PyCafe.pyx":3491 * p1.ts = ll * * pvd._etsDate = pvd[i].getEpicsTimeStampAsDate() # <<<<<<<<<<<<<< @@ -74349,103 +76438,103 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ */ __pyx_v_pvd->_etsDate = (__pyx_v_pvd[__pyx_v_i]).getEpicsTimeStampAsDate(); - /* "PyCafe.pyx":3403 + /* "PyCafe.pyx":3493 * pvd._etsDate = pvd[i].getEpicsTimeStampAsDate() * * ld = [] # <<<<<<<<<<<<<< * ld.append((pvd[i]._etsDate).year) * ld.append((pvd[i]._etsDate).mon) */ - __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3403, __pyx_L1_error) + __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_ld, ((PyObject*)__pyx_t_9)); __pyx_t_9 = 0; - /* "PyCafe.pyx":3404 + /* "PyCafe.pyx":3494 * * ld = [] * ld.append((pvd[i]._etsDate).year) # <<<<<<<<<<<<<< * ld.append((pvd[i]._etsDate).mon) * ld.append((pvd[i]._etsDate).day) */ - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.year); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3404, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.year); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3404, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3494, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3405 + /* "PyCafe.pyx":3495 * 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) */ - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.mon); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3405, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.mon); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3405, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3495, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3406 + /* "PyCafe.pyx":3496 * 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) */ - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.day); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3406, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.day); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3406, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3496, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3407 + /* "PyCafe.pyx":3497 * 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) */ - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.hour); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3407, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.hour); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3407, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3497, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3408 + /* "PyCafe.pyx":3498 * 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) */ - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.min); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3408, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.min); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3408, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3498, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3409 + /* "PyCafe.pyx":3499 * 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 */ - __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.sec); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3409, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i])._etsDate.sec); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3409, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3499, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3410 + /* "PyCafe.pyx":3500 * ld.append((pvd[i]._etsDate).min) * ld.append((pvd[i]._etsDate).sec) * ld.append((pvd[i]._etsDate).nsec) # <<<<<<<<<<<<<< * p1.tsDate = ld * */ - __pyx_t_9 = __Pyx_PyInt_From_unsigned_long((__pyx_v_pvd[__pyx_v_i])._etsDate.nsec); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3410, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_unsigned_long((__pyx_v_pvd[__pyx_v_i])._etsDate.nsec); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3410, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_ld, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3500, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":3411 + /* "PyCafe.pyx":3501 * ld.append((pvd[i]._etsDate).sec) * ld.append((pvd[i]._etsDate).nsec) * p1.tsDate = ld # <<<<<<<<<<<<<< @@ -74458,17 +76547,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __Pyx_DECREF(__pyx_v_p1->tsDate); __pyx_v_p1->tsDate = __pyx_v_ld; - /* "PyCafe.pyx":3413 + /* "PyCafe.pyx":3503 * p1.tsDate = ld * * pvdList.append(p1) # <<<<<<<<<<<<<< * * # free(pvd) */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_pvdList, ((PyObject *)__pyx_v_p1)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3413, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_pvdList, ((PyObject *)__pyx_v_p1)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3503, __pyx_L1_error) } - /* "PyCafe.pyx":3417 + /* "PyCafe.pyx":3507 * # free(pvd) * * return pvdList, status # <<<<<<<<<<<<<< @@ -74476,9 +76565,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3417, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3417, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_pvdList); __Pyx_GIVEREF(__pyx_v_pvdList); @@ -74490,7 +76579,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3204 + /* "PyCafe.pyx":3294 * * ################################################################################## * def getPVList(self, handleList, str dt='native', cacheFlag=False): # <<<<<<<<<<<<<< @@ -74525,7 +76614,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_274getPVList(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":3425 +/* "PyCafe.pyx":3515 * ################################################################################## * * def printStatusIfError(self, handleList, statusList): # <<<<<<<<<<<<<< @@ -74564,11 +76653,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_277printStatusIfError(PyObject *__pyx_ case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_statusList)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("printStatusIfError", 1, 2, 2, 1); __PYX_ERR(3, 3425, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("printStatusIfError", 1, 2, 2, 1); __PYX_ERR(3, 3515, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "printStatusIfError") < 0)) __PYX_ERR(3, 3425, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "printStatusIfError") < 0)) __PYX_ERR(3, 3515, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -74581,7 +76670,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_277printStatusIfError(PyObject *__pyx_ } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("printStatusIfError", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3425, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("printStatusIfError", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3515, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.printStatusIfError", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -74620,7 +76709,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __Pyx_INCREF(__pyx_v_handleList); __Pyx_INCREF(__pyx_v_statusList); - /* "PyCafe.pyx":3427 + /* "PyCafe.pyx":3517 * def printStatusIfError(self, handleList, statusList): * ################################################################################## * cdef str _METHOD = "printStatusIfError" # <<<<<<<<<<<<<< @@ -74630,7 +76719,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __Pyx_INCREF(__pyx_n_u_printStatusIfError); __pyx_v__METHOD = __pyx_n_u_printStatusIfError; - /* "PyCafe.pyx":3429 + /* "PyCafe.pyx":3519 * cdef str _METHOD = "printStatusIfError" * * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -74658,40 +76747,40 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3430 + /* "PyCafe.pyx":3520 * * if isinstance(handleList, (str, int, long)): * handleListB = [] # <<<<<<<<<<<<<< * handleListB.append(handleList) * handleList = [] */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3430, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_handleListB = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3431 + /* "PyCafe.pyx":3521 * if isinstance(handleList, (str, int, long)): * handleListB = [] * handleListB.append(handleList) # <<<<<<<<<<<<<< * handleList = [] * handleList = handleListB */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_handleListB, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3431, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_handleListB, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3521, __pyx_L1_error) - /* "PyCafe.pyx":3432 + /* "PyCafe.pyx":3522 * handleListB = [] * handleListB.append(handleList) * handleList = [] # <<<<<<<<<<<<<< * handleList = handleListB * */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3432, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3433 + /* "PyCafe.pyx":3523 * handleListB.append(handleList) * handleList = [] * handleList = handleListB # <<<<<<<<<<<<<< @@ -74701,7 +76790,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __Pyx_INCREF(__pyx_v_handleListB); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_v_handleListB); - /* "PyCafe.pyx":3429 + /* "PyCafe.pyx":3519 * cdef str _METHOD = "printStatusIfError" * * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -74710,34 +76799,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj */ } - /* "PyCafe.pyx":3435 + /* "PyCafe.pyx":3525 * handleList = handleListB * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3435, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3525, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3436 + /* "PyCafe.pyx":3526 * * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) # <<<<<<<<<<<<<< * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format(self._exception_text, _METHOD, */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3436, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3436, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3526, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3526, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3435 + /* "PyCafe.pyx":3525 * handleList = handleListB * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -74747,14 +76836,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj goto __pyx_L7; } - /* "PyCafe.pyx":3437 + /* "PyCafe.pyx":3527 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< * raise Exception("{} {} {}".format(self._exception_text, _METHOD, * "First input argument should be a 'list' of of type if handles or if PVs")) */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3437, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyInt_Check(__pyx_t_4); __pyx_t_2 = (__pyx_t_3 != 0); @@ -74771,14 +76860,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3438 + /* "PyCafe.pyx":3528 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format(self._exception_text, _METHOD, # <<<<<<<<<<<<<< * "First input argument should be a 'list' of of type if handles or if PVs")) * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3438, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -74795,7 +76884,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_4}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3438, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3528, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else @@ -74803,13 +76892,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_4}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3438, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3528, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3438, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -74823,19 +76912,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_a_4); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_a_4); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_a_4); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3438, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3438, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 3438, __pyx_L1_error) + __PYX_ERR(3, 3528, __pyx_L1_error) - /* "PyCafe.pyx":3437 + /* "PyCafe.pyx":3527 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -74845,7 +76934,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj } __pyx_L7:; - /* "PyCafe.pyx":3441 + /* "PyCafe.pyx":3531 * "First input argument should be a 'list' of of type if handles or if PVs")) * * if isinstance(statusList, (int, long)): # <<<<<<<<<<<<<< @@ -74866,40 +76955,40 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3442 + /* "PyCafe.pyx":3532 * * if isinstance(statusList, (int, long)): * statusListB = [] # <<<<<<<<<<<<<< * statusListB.append(statusList) * statusList = [] */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3442, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_statusListB = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3443 + /* "PyCafe.pyx":3533 * if isinstance(statusList, (int, long)): * statusListB = [] * statusListB.append(statusList) # <<<<<<<<<<<<<< * statusList = [] * statusList = statusListB */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_statusListB, __pyx_v_statusList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3443, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_statusListB, __pyx_v_statusList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3533, __pyx_L1_error) - /* "PyCafe.pyx":3444 + /* "PyCafe.pyx":3534 * statusListB = [] * statusListB.append(statusList) * statusList = [] # <<<<<<<<<<<<<< * statusList = statusListB * */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3444, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_statusList, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3445 + /* "PyCafe.pyx":3535 * statusListB.append(statusList) * statusList = [] * statusList = statusListB # <<<<<<<<<<<<<< @@ -74909,7 +76998,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __Pyx_INCREF(__pyx_v_statusListB); __Pyx_DECREF_SET(__pyx_v_statusList, __pyx_v_statusListB); - /* "PyCafe.pyx":3441 + /* "PyCafe.pyx":3531 * "First input argument should be a 'list' of of type if handles or if PVs")) * * if isinstance(statusList, (int, long)): # <<<<<<<<<<<<<< @@ -74918,7 +77007,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj */ } - /* "PyCafe.pyx":3447 + /* "PyCafe.pyx":3537 * statusList = statusListB * * if not isinstance(statusList, (list)): # <<<<<<<<<<<<<< @@ -74929,14 +77018,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3448 + /* "PyCafe.pyx":3538 * * if not isinstance(statusList, (list)): * raise Exception("{} {} {}".format(self._exception_text, _METHOD, # <<<<<<<<<<<<<< * "Second input argument should be of of type ")) * */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3448, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3538, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = NULL; __pyx_t_8 = 0; @@ -74953,7 +77042,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Second_input_argument_should_be}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3448, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3538, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_6); } else @@ -74961,13 +77050,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Second_input_argument_should_be}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3448, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3538, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { - __pyx_t_7 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3448, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3538, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL; @@ -74981,19 +77070,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __Pyx_INCREF(__pyx_kp_u_Second_input_argument_should_be); __Pyx_GIVEREF(__pyx_kp_u_Second_input_argument_should_be); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_8, __pyx_kp_u_Second_input_argument_should_be); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3448, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3538, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3448, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3538, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 3448, __pyx_L1_error) + __PYX_ERR(3, 3538, __pyx_L1_error) - /* "PyCafe.pyx":3447 + /* "PyCafe.pyx":3537 * statusList = statusListB * * if not isinstance(statusList, (list)): # <<<<<<<<<<<<<< @@ -75002,14 +77091,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj */ } - /* "PyCafe.pyx":3451 + /* "PyCafe.pyx":3541 * "Second input argument should be of of type ")) * * if not isinstance(statusList[0], (int, long, float)): # <<<<<<<<<<<<<< * raise Exception("{} {} {}".format(self._exception_text, _METHOD, * "Second input argument should be a of of type ")) */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_statusList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3451, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_statusList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyInt_Check(__pyx_t_4); __pyx_t_2 = (__pyx_t_1 != 0); @@ -75033,14 +77122,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3452 + /* "PyCafe.pyx":3542 * * if not isinstance(statusList[0], (int, long, float)): * raise Exception("{} {} {}".format(self._exception_text, _METHOD, # <<<<<<<<<<<<<< * "Second input argument should be a of of type ")) * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3452, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -75057,7 +77146,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Second_input_argument_should_be_2}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3452, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3542, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else @@ -75065,13 +77154,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_Second_input_argument_should_be_2}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3452, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3542, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3452, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -75085,19 +77174,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __Pyx_INCREF(__pyx_kp_u_Second_input_argument_should_be_2); __Pyx_GIVEREF(__pyx_kp_u_Second_input_argument_should_be_2); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_Second_input_argument_should_be_2); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3452, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3452, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 3452, __pyx_L1_error) + __PYX_ERR(3, 3542, __pyx_L1_error) - /* "PyCafe.pyx":3451 + /* "PyCafe.pyx":3541 * "Second input argument should be of of type ")) * * if not isinstance(statusList[0], (int, long, float)): # <<<<<<<<<<<<<< @@ -75106,48 +77195,48 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj */ } - /* "PyCafe.pyx":3458 + /* "PyCafe.pyx":3548 * # do next step to avoid: * # warning: comparison between signed and unsigned integer expressions * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) */ - __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3458, __pyx_L1_error) + __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3548, __pyx_L1_error) __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; - /* "PyCafe.pyx":3460 + /* "PyCafe.pyx":3550 * for i in range(0, len(handleList)): * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) # <<<<<<<<<<<<<< * * self._c_cafe.printStatusIfError(v, statusList) */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3460, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3550, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3460, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3550, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_v.push_back(__pyx_t_13); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 3460, __pyx_L1_error) + __PYX_ERR(3, 3550, __pyx_L1_error) } } - /* "PyCafe.pyx":3462 + /* "PyCafe.pyx":3552 * v.push_back(handleList[i]) * * self._c_cafe.printStatusIfError(v, statusList) # <<<<<<<<<<<<<< * return * */ - __pyx_t_14 = __pyx_convert_vector_from_py_int(__pyx_v_statusList); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3462, __pyx_L1_error) + __pyx_t_14 = __pyx_convert_vector_from_py_int(__pyx_v_statusList); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 3552, __pyx_L1_error) (void)(__pyx_v_self->_c_cafe->printStatusIfError(__pyx_v_v, __pyx_t_14)); - /* "PyCafe.pyx":3463 + /* "PyCafe.pyx":3553 * * self._c_cafe.printStatusIfError(v, statusList) * return # <<<<<<<<<<<<<< @@ -75158,7 +77247,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":3425 + /* "PyCafe.pyx":3515 * ################################################################################## * * def printStatusIfError(self, handleList, statusList): # <<<<<<<<<<<<<< @@ -75187,7 +77276,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_276printStatusIfError(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":3468 +/* "PyCafe.pyx":3558 * * ################################################################################## * def getAsyn(self, handleList): # <<<<<<<<<<<<<< @@ -75233,7 +77322,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __Pyx_RefNannySetupContext("getAsyn", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":3470 + /* "PyCafe.pyx":3560 * def getAsyn(self, handleList): * ################################################################################## * cdef str _METHOD = "getAsyn" # <<<<<<<<<<<<<< @@ -75243,7 +77332,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __Pyx_INCREF(__pyx_n_u_getAsyn); __pyx_v__METHOD = __pyx_n_u_getAsyn; - /* "PyCafe.pyx":3472 + /* "PyCafe.pyx":3562 * cdef str _METHOD = "getAsyn" * * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -75271,28 +77360,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3473 + /* "PyCafe.pyx":3563 * * if isinstance(handleList, (str, int, long)): * handleListB = [] # <<<<<<<<<<<<<< * handleListB.append(handleList) * #handleList = [] */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3473, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_handleListB = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3474 + /* "PyCafe.pyx":3564 * if isinstance(handleList, (str, int, long)): * handleListB = [] * handleListB.append(handleList) # <<<<<<<<<<<<<< * #handleList = [] * handleList = handleListB */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_handleListB, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3474, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_handleListB, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3564, __pyx_L1_error) - /* "PyCafe.pyx":3476 + /* "PyCafe.pyx":3566 * handleListB.append(handleList) * #handleList = [] * handleList = handleListB # <<<<<<<<<<<<<< @@ -75302,7 +77391,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __Pyx_INCREF(__pyx_v_handleListB); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_v_handleListB); - /* "PyCafe.pyx":3472 + /* "PyCafe.pyx":3562 * cdef str _METHOD = "getAsyn" * * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -75311,34 +77400,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":3478 + /* "PyCafe.pyx":3568 * handleList = handleListB * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3478, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3479 + /* "PyCafe.pyx":3569 * * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) # <<<<<<<<<<<<<< * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format(self._exception_text, _METHOD, */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3479, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3479, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3569, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3478 + /* "PyCafe.pyx":3568 * handleList = handleListB * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -75348,14 +77437,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy goto __pyx_L7; } - /* "PyCafe.pyx":3480 + /* "PyCafe.pyx":3570 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< * raise Exception("{} {} {}".format(self._exception_text, _METHOD, * "First input argument should be a 'list' of of type if handles or if PVs")) */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3480, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3570, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyInt_Check(__pyx_t_4); __pyx_t_2 = (__pyx_t_3 != 0); @@ -75372,14 +77461,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3481 + /* "PyCafe.pyx":3571 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("{} {} {}".format(self._exception_text, _METHOD, # <<<<<<<<<<<<<< * "First input argument should be a 'list' of of type if handles or if PVs")) * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3481, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -75396,7 +77485,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_4}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3481, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3571, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else @@ -75404,13 +77493,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_a_4}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3481, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3571, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3481, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -75424,19 +77513,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_a_4); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_a_4); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_a_4); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3481, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3481, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 3481, __pyx_L1_error) + __PYX_ERR(3, 3571, __pyx_L1_error) - /* "PyCafe.pyx":3480 + /* "PyCafe.pyx":3570 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -75446,58 +77535,58 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy } __pyx_L7:; - /* "PyCafe.pyx":3486 + /* "PyCafe.pyx":3576 * cdef vector[unsigned int] v * cdef vector[int] vStatus * v.reserve(len(handleList)) # <<<<<<<<<<<<<< * vStatus.reserve(len(handleList)) * */ - __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3486, __pyx_L1_error) + __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3576, __pyx_L1_error) __pyx_v_v.reserve(__pyx_t_10); - /* "PyCafe.pyx":3487 + /* "PyCafe.pyx":3577 * cdef vector[int] vStatus * v.reserve(len(handleList)) * vStatus.reserve(len(handleList)) # <<<<<<<<<<<<<< * * # do next step to avoid: */ - __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3487, __pyx_L1_error) + __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3577, __pyx_L1_error) __pyx_v_vStatus.reserve(__pyx_t_10); - /* "PyCafe.pyx":3491 + /* "PyCafe.pyx":3581 * # do next step to avoid: * # warning: comparison between signed and unsigned integer expressions * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) */ - __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3491, __pyx_L1_error) + __pyx_t_10 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3581, __pyx_L1_error) __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; - /* "PyCafe.pyx":3493 + /* "PyCafe.pyx":3583 * for i in range(0, len(handleList)): * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) # <<<<<<<<<<<<<< * * # Need to copy to a vector since */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3493, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3493, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3583, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_v.push_back(__pyx_t_13); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 3493, __pyx_L1_error) + __PYX_ERR(3, 3583, __pyx_L1_error) } } - /* "PyCafe.pyx":3497 + /* "PyCafe.pyx":3587 * # Need to copy to a vector since * # Coercion from Python not allowed without the GIL * with nogil: # <<<<<<<<<<<<<< @@ -75512,7 +77601,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":3498 + /* "PyCafe.pyx":3588 * # Coercion from Python not allowed without the GIL * with nogil: * status = self._c_cafe.getV(v, vStatus) # <<<<<<<<<<<<<< @@ -75522,7 +77611,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getV(__pyx_v_v, __pyx_v_vStatus); } - /* "PyCafe.pyx":3497 + /* "PyCafe.pyx":3587 * # Need to copy to a vector since * # Coercion from Python not allowed without the GIL * with nogil: # <<<<<<<<<<<<<< @@ -75541,7 +77630,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":3500 + /* "PyCafe.pyx":3590 * status = self._c_cafe.getV(v, vStatus) * * if (status != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -75551,7 +77640,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __pyx_t_3 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3501 + /* "PyCafe.pyx":3591 * * if (status != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -75561,18 +77650,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __pyx_t_3 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3502 + /* "PyCafe.pyx":3592 * if (status != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error/Warning from def getAsyn: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3502, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3503 + /* "PyCafe.pyx":3593 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error/Warning from def getAsyn: ") * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -75581,7 +77670,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":3501 + /* "PyCafe.pyx":3591 * * if (status != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -75590,7 +77679,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":3500 + /* "PyCafe.pyx":3590 * status = self._c_cafe.getV(v, vStatus) * * if (status != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -75599,7 +77688,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":3505 + /* "PyCafe.pyx":3595 * self._c_cafe.printStatusMessage(status) * * return status, vStatus # <<<<<<<<<<<<<< @@ -75607,11 +77696,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3505, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3505, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3505, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 3595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); @@ -75623,7 +77712,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy __pyx_t_9 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3468 + /* "PyCafe.pyx":3558 * * ################################################################################## * def getAsyn(self, handleList): # <<<<<<<<<<<<<< @@ -75650,7 +77739,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_278getAsyn(struct __pyx_obj_6PyCafe_Cy return __pyx_r; } -/* "PyCafe.pyx":3513 +/* "PyCafe.pyx":3603 * ################################################################################## * @verify_handlepv * def waitForGetEvent(self, handlePV): # <<<<<<<<<<<<<< @@ -75680,17 +77769,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_280waitForGetEvent(struct __pyx_obj_6P PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("waitForGetEvent", 0); - /* "PyCafe.pyx":3515 + /* "PyCafe.pyx":3605 * def waitForGetEvent(self, handlePV): * * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.waitForGetEvent(handle) */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3515, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3605, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":3516 + /* "PyCafe.pyx":3606 * * cdef unsigned int handle = handlePV * with nogil: # <<<<<<<<<<<<<< @@ -75705,7 +77794,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_280waitForGetEvent(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":3517 + /* "PyCafe.pyx":3607 * cdef unsigned int handle = handlePV * with nogil: * status = self._c_cafe.waitForGetEvent(handle) # <<<<<<<<<<<<<< @@ -75715,7 +77804,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_280waitForGetEvent(struct __pyx_obj_6P __pyx_v_status = __pyx_v_self->_c_cafe->waitForGetEvent(__pyx_v_handle); } - /* "PyCafe.pyx":3516 + /* "PyCafe.pyx":3606 * * cdef unsigned int handle = handlePV * with nogil: # <<<<<<<<<<<<<< @@ -75734,7 +77823,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_280waitForGetEvent(struct __pyx_obj_6P } } - /* "PyCafe.pyx":3518 + /* "PyCafe.pyx":3608 * with nogil: * status = self._c_cafe.waitForGetEvent(handle) * return status # <<<<<<<<<<<<<< @@ -75742,13 +77831,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_280waitForGetEvent(struct __pyx_obj_6P * # END: def waitForGetEvent(self, handlePV) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3518, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3513 + /* "PyCafe.pyx":3603 * ################################################################################## * @verify_handlepv * def waitForGetEvent(self, handlePV): # <<<<<<<<<<<<<< @@ -75769,7 +77858,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_280waitForGetEvent(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":3524 +/* "PyCafe.pyx":3614 * * ################################################################################## * def waitForBundledEvents(self, handleList): # <<<<<<<<<<<<<< @@ -75813,7 +77902,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __Pyx_RefNannySetupContext("waitForBundledEvents", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":3525 + /* "PyCafe.pyx":3615 * ################################################################################## * def waitForBundledEvents(self, handleList): * cdef str _METHOD = "waitForBundledEvents(self, handleList)" # <<<<<<<<<<<<<< @@ -75823,7 +77912,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __Pyx_INCREF(__pyx_kp_u_waitForBundledEvents_self_handle); __pyx_v__METHOD = __pyx_kp_u_waitForBundledEvents_self_handle; - /* "PyCafe.pyx":3527 + /* "PyCafe.pyx":3617 * cdef str _METHOD = "waitForBundledEvents(self, handleList)" * * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -75851,28 +77940,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3528 + /* "PyCafe.pyx":3618 * * if isinstance(handleList, (str, int, long)): * handleListB = [] # <<<<<<<<<<<<<< * handleListB.append(handleList) * #handleList = [] */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3528, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_handleListB = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3529 + /* "PyCafe.pyx":3619 * if isinstance(handleList, (str, int, long)): * handleListB = [] * handleListB.append(handleList) # <<<<<<<<<<<<<< * #handleList = [] * handleList = handleListB */ - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_handleListB, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3529, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_handleListB, __pyx_v_handleList); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 3619, __pyx_L1_error) - /* "PyCafe.pyx":3531 + /* "PyCafe.pyx":3621 * handleListB.append(handleList) * #handleList = [] * handleList = handleListB # <<<<<<<<<<<<<< @@ -75882,7 +77971,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __Pyx_INCREF(__pyx_v_handleListB); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_v_handleListB); - /* "PyCafe.pyx":3527 + /* "PyCafe.pyx":3617 * cdef str _METHOD = "waitForBundledEvents(self, handleList)" * * if isinstance(handleList, (str, int, long)): # <<<<<<<<<<<<<< @@ -75891,7 +77980,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o */ } - /* "PyCafe.pyx":3533 + /* "PyCafe.pyx":3623 * handleList = handleListB * * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -75902,20 +77991,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3534 + /* "PyCafe.pyx":3624 * * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def waitForBundledEvents. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3534, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3624, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 3534, __pyx_L1_error) + __PYX_ERR(3, 3624, __pyx_L1_error) - /* "PyCafe.pyx":3533 + /* "PyCafe.pyx":3623 * handleList = handleListB * * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -75924,34 +78013,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o */ } - /* "PyCafe.pyx":3537 + /* "PyCafe.pyx":3627 * 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)): */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3537, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3627, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":3538 + /* "PyCafe.pyx":3628 * * 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\ */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3538, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3538, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3628, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3537 + /* "PyCafe.pyx":3627 * First input argument, should be of handles or PVs") * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -75961,14 +78050,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o goto __pyx_L8; } - /* "PyCafe.pyx":3539 + /* "PyCafe.pyx":3629 * 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 of type if handles or if PVs") */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3539, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyInt_Check(__pyx_t_4); __pyx_t_2 = (__pyx_t_1 != 0); @@ -75985,20 +78074,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3540 + /* "PyCafe.pyx":3630 * 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 of type if handles or if PVs") * */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3540, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3630, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 3540, __pyx_L1_error) + __PYX_ERR(3, 3630, __pyx_L1_error) - /* "PyCafe.pyx":3539 + /* "PyCafe.pyx":3629 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -76008,58 +78097,58 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o } __pyx_L8:; - /* "PyCafe.pyx":3546 + /* "PyCafe.pyx":3636 * cdef vector[int] vRB * * v.reserve(len(handleList)) # <<<<<<<<<<<<<< * vRB.reserve(len(handleList)) * for i in range(0, len(handleList)): */ - __pyx_t_6 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3546, __pyx_L1_error) + __pyx_t_6 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3636, __pyx_L1_error) __pyx_v_v.reserve(__pyx_t_6); - /* "PyCafe.pyx":3547 + /* "PyCafe.pyx":3637 * * v.reserve(len(handleList)) * vRB.reserve(len(handleList)) # <<<<<<<<<<<<<< * for i in range(0, len(handleList)): * # do this copy to avoid compiler warning messages */ - __pyx_t_6 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3547, __pyx_L1_error) + __pyx_t_6 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3637, __pyx_L1_error) __pyx_v_vRB.reserve(__pyx_t_6); - /* "PyCafe.pyx":3548 + /* "PyCafe.pyx":3638 * v.reserve(len(handleList)) * vRB.reserve(len(handleList)) * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) */ - __pyx_t_6 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3548, __pyx_L1_error) + __pyx_t_6 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3638, __pyx_L1_error) __pyx_t_7 = __pyx_t_6; for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":3550 + /* "PyCafe.pyx":3640 * for i in range(0, len(handleList)): * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) # <<<<<<<<<<<<<< * * # Wait for bundle */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3550, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3640, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3550, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3640, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_v.push_back(__pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 3550, __pyx_L1_error) + __PYX_ERR(3, 3640, __pyx_L1_error) } } - /* "PyCafe.pyx":3553 + /* "PyCafe.pyx":3643 * * # Wait for bundle * with nogil: # <<<<<<<<<<<<<< @@ -76074,7 +78163,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o #endif /*try:*/ { - /* "PyCafe.pyx":3554 + /* "PyCafe.pyx":3644 * # Wait for bundle * with nogil: * status = self._c_cafe.waitForBundledEvents(v, vRB) # <<<<<<<<<<<<<< @@ -76084,7 +78173,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __pyx_v_status = __pyx_v_self->_c_cafe->waitForBundledEvents(__pyx_v_v, __pyx_v_vRB); } - /* "PyCafe.pyx":3553 + /* "PyCafe.pyx":3643 * * # Wait for bundle * with nogil: # <<<<<<<<<<<<<< @@ -76103,7 +78192,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o } } - /* "PyCafe.pyx":3555 + /* "PyCafe.pyx":3645 * with nogil: * status = self._c_cafe.waitForBundledEvents(v, vRB) * if (status != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -76113,7 +78202,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3556 + /* "PyCafe.pyx":3646 * status = self._c_cafe.waitForBundledEvents(v, vRB) * if (status != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -76123,18 +78212,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3557 + /* "PyCafe.pyx":3647 * if (status != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def waitForBundledEvents: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * return status */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3557, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":3558 + /* "PyCafe.pyx":3648 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def waitForBundledEvents: ") * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -76143,7 +78232,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":3556 + /* "PyCafe.pyx":3646 * status = self._c_cafe.waitForBundledEvents(v, vRB) * if (status != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -76152,7 +78241,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o */ } - /* "PyCafe.pyx":3559 + /* "PyCafe.pyx":3649 * print("Error in def waitForBundledEvents: ") * self._c_cafe.printStatusMessage(status) * return status # <<<<<<<<<<<<<< @@ -76160,13 +78249,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3559, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3649, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3555 + /* "PyCafe.pyx":3645 * with nogil: * status = self._c_cafe.waitForBundledEvents(v, vRB) * if (status != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -76175,7 +78264,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o */ } - /* "PyCafe.pyx":3560 + /* "PyCafe.pyx":3650 * self._c_cafe.printStatusMessage(status) * return status * return status, vRB # <<<<<<<<<<<<<< @@ -76183,11 +78272,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o * # END: def waitForBundledEvents(self, handleList): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3560, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3650, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_10 = __pyx_convert_vector_to_py_int(__pyx_v_vRB); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3560, __pyx_L1_error) + __pyx_t_10 = __pyx_convert_vector_to_py_int(__pyx_v_vRB); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 3650, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3560, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3650, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_4); @@ -76199,7 +78288,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o __pyx_t_11 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3524 + /* "PyCafe.pyx":3614 * * ################################################################################## * def waitForBundledEvents(self, handleList): # <<<<<<<<<<<<<< @@ -76225,7 +78314,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_282waitForBundledEvents(struct __pyx_o return __pyx_r; } -/* "PyCafe.pyx":3567 +/* "PyCafe.pyx":3657 * ################################################################################## * * def getScalarArray(self, handleList, str dt='native', bint cacheFlag=False): # <<<<<<<<<<<<<< @@ -76278,7 +78367,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_285getScalarArray(PyObject *__pyx_v_se } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getScalarArray") < 0)) __PYX_ERR(3, 3567, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getScalarArray") < 0)) __PYX_ERR(3, 3657, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -76294,20 +78383,20 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_285getScalarArray(PyObject *__pyx_v_se __pyx_v_handleList = values[0]; __pyx_v_dt = ((PyObject*)values[1]); if (values[2]) { - __pyx_v_cacheFlag = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_cacheFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3567, __pyx_L3_error) + __pyx_v_cacheFlag = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_cacheFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3657, __pyx_L3_error) } else { __pyx_v_cacheFlag = ((int)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getScalarArray", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3567, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getScalarArray", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3657, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getScalarArray", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 3567, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 3657, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_284getScalarArray(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handleList, __pyx_v_dt, __pyx_v_cacheFlag); /* function exit code */ @@ -76368,7 +78457,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_RefNannySetupContext("getScalarArray", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":3569 + /* "PyCafe.pyx":3659 * def getScalarArray(self, handleList, str dt='native', bint cacheFlag=False): * * cdef str _METHOD = "getScalarArray(handleList, str dt, bint cacheFlag)" # <<<<<<<<<<<<<< @@ -76378,7 +78467,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_INCREF(__pyx_kp_u_getScalarArray_handleList_str_dt); __pyx_v__METHOD = __pyx_kp_u_getScalarArray_handleList_str_dt; - /* "PyCafe.pyx":3573 + /* "PyCafe.pyx":3663 * # cdef float [::1] mvFloat #C-contiguous * * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -76389,20 +78478,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3574 + /* "PyCafe.pyx":3664 * * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def getScalarArray. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3574, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3664, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 3574, __pyx_L1_error) + __PYX_ERR(3, 3664, __pyx_L1_error) - /* "PyCafe.pyx":3573 + /* "PyCafe.pyx":3663 * # cdef float [::1] mvFloat #C-contiguous * * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -76411,34 +78500,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3577 + /* "PyCafe.pyx":3667 * 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)): */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3577, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyUnicode_Check(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3578 + /* "PyCafe.pyx":3668 * * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) # <<<<<<<<<<<<<< * elif not isinstance(handleList[0], (int, long)): * raise Exception("EXCEPTION RAISED IN PyCafe def getScalarArray. \n\ */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3578, __pyx_L1_error) - __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3578, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3668, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3577 + /* "PyCafe.pyx":3667 * First input argument, should be of handles or PVs") * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -76448,14 +78537,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py goto __pyx_L4; } - /* "PyCafe.pyx":3579 + /* "PyCafe.pyx":3669 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< * raise Exception("EXCEPTION RAISED IN PyCafe def getScalarArray. \n\ * First input argument, should be a 'list' of of type if handles or if PVs") */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3579, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3669, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyInt_Check(__pyx_t_3); __pyx_t_4 = (__pyx_t_2 != 0); @@ -76472,20 +78561,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3580 + /* "PyCafe.pyx":3670 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("EXCEPTION RAISED IN PyCafe def getScalarArray. \n\ # <<<<<<<<<<<<<< * First input argument, should be a 'list' of of type if handles or if PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3580, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3670, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 3580, __pyx_L1_error) + __PYX_ERR(3, 3670, __pyx_L1_error) - /* "PyCafe.pyx":3579 + /* "PyCafe.pyx":3669 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -76495,29 +78584,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __pyx_L4:; - /* "PyCafe.pyx":3583 + /* "PyCafe.pyx":3673 * First input argument, should be a 'list' of of type if handles or if PVs") * * nelemPrevious = [] # <<<<<<<<<<<<<< * * for i in range(0, len(handleList)): */ - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3583, __pyx_L1_error) + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3673, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_nelemPrevious = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3585 + /* "PyCafe.pyx":3675 * nelemPrevious = [] * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * nelemPrevious.append(self._c_cafe.setNelemToOne(handleList[i])) * */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3585, __pyx_L1_error) - __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3585, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3675, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3585, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -76525,16 +78614,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3585, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_6 = __pyx_t_3; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3585, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3585, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3675, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -76542,17 +78631,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3585, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3675, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3585, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3585, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3675, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3585, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -76562,7 +78651,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3585, __pyx_L1_error) + else __PYX_ERR(3, 3675, __pyx_L1_error) } break; } @@ -76571,23 +78660,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3586 + /* "PyCafe.pyx":3676 * * for i in range(0, len(handleList)): * nelemPrevious.append(self._c_cafe.setNelemToOne(handleList[i])) # <<<<<<<<<<<<<< * * # pack into numpy */ - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3586, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3586, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3676, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->setNelemToOne(__pyx_t_8)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3586, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->setNelemToOne(__pyx_t_8)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_nelemPrevious, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3586, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_nelemPrevious, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3676, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3585 + /* "PyCafe.pyx":3675 * nelemPrevious = [] * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -76597,37 +78686,37 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3592 + /* "PyCafe.pyx":3682 * cdef vector[int] vStatus * * v.reserve(len(handleList)) # <<<<<<<<<<<<<< * vStatus.reserve(len(handleList)) * */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3592, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3682, __pyx_L1_error) __pyx_v_v.reserve(__pyx_t_5); - /* "PyCafe.pyx":3593 + /* "PyCafe.pyx":3683 * * v.reserve(len(handleList)) * vStatus.reserve(len(handleList)) # <<<<<<<<<<<<<< * * for i in range(0, len(handleList)): */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3593, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3683, __pyx_L1_error) __pyx_v_vStatus.reserve(__pyx_t_5); - /* "PyCafe.pyx":3595 + /* "PyCafe.pyx":3685 * vStatus.reserve(len(handleList)) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3595, __pyx_L1_error) - __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3595, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3685, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3595, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -76635,16 +78724,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3595, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(PyList_CheckExact(__pyx_t_6)) || PyTuple_CheckExact(__pyx_t_6)) { __pyx_t_3 = __pyx_t_6; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3595, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3595, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3685, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; for (;;) { @@ -76652,17 +78741,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3595, __pyx_L1_error) + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3685, __pyx_L1_error) #else - __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3595, __pyx_L1_error) + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3595, __pyx_L1_error) + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3685, __pyx_L1_error) #else - __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3595, __pyx_L1_error) + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif } @@ -76672,7 +78761,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3595, __pyx_L1_error) + else __PYX_ERR(3, 3685, __pyx_L1_error) } break; } @@ -76681,25 +78770,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3597 + /* "PyCafe.pyx":3687 * for i in range(0, len(handleList)): * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) # <<<<<<<<<<<<<< * * cdef vector[int] vRB */ - __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3597, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3597, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3687, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_v.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 3597, __pyx_L1_error) + __PYX_ERR(3, 3687, __pyx_L1_error) } - /* "PyCafe.pyx":3595 + /* "PyCafe.pyx":3685 * vStatus.reserve(len(handleList)) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -76709,7 +78798,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3600 + /* "PyCafe.pyx":3690 * * cdef vector[int] vRB * status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -76718,7 +78807,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":3602 + /* "PyCafe.pyx":3692 * status = ICAFE_NORMAL * * if (cacheFlag == False): # <<<<<<<<<<<<<< @@ -76728,7 +78817,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((__pyx_v_cacheFlag == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3605 + /* "PyCafe.pyx":3695 * # Need to copy to a vector since * # Coercion from Python not allowed without the GIL * with nogil: # <<<<<<<<<<<<<< @@ -76743,7 +78832,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py #endif /*try:*/ { - /* "PyCafe.pyx":3606 + /* "PyCafe.pyx":3696 * # Coercion from Python not allowed without the GIL * with nogil: * status = self._c_cafe.getV(v, vStatus) # <<<<<<<<<<<<<< @@ -76753,7 +78842,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_v_status = __pyx_v_self->_c_cafe->getV(__pyx_v_v, __pyx_v_vStatus); } - /* "PyCafe.pyx":3605 + /* "PyCafe.pyx":3695 * # Need to copy to a vector since * # Coercion from Python not allowed without the GIL * with nogil: # <<<<<<<<<<<<<< @@ -76772,7 +78861,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } } - /* "PyCafe.pyx":3614 + /* "PyCafe.pyx":3704 * # Functionality not yet moved to CAFE:: * # Required for when dt='native' * if (status != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -76782,20 +78871,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3615 + /* "PyCafe.pyx":3705 * # 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 */ - __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3705, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -76803,16 +78892,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_6 = __pyx_t_3; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3705, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -76820,17 +78909,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3705, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3705, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3615, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -76840,7 +78929,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3615, __pyx_L1_error) + else __PYX_ERR(3, 3705, __pyx_L1_error) } break; } @@ -76849,27 +78938,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3616 + /* "PyCafe.pyx":3706 * 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)): */ - __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3616, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3706, __pyx_L1_error) __pyx_t_2 = (((__pyx_v_vStatus[__pyx_t_10]) == ICAFE_WAITING_FOR_PREV_CALLBACK) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3618 + /* "PyCafe.pyx":3708 * 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): */ - __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_v_i, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3618, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_v_i, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3618, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -76877,16 +78966,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3618, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_11 = __pyx_t_3; __Pyx_INCREF(__pyx_t_11); __pyx_t_12 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_12 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3618, __pyx_L1_error) + __pyx_t_12 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_13 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 3618, __pyx_L1_error) + __pyx_t_13 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 3708, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -76894,17 +78983,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_11))) { if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(3, 3618, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(3, 3708, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3618, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(3, 3618, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(3, 3708, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3618, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -76914,7 +79003,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3618, __pyx_L1_error) + else __PYX_ERR(3, 3708, __pyx_L1_error) } break; } @@ -76923,41 +79012,41 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_j, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3619 + /* "PyCafe.pyx":3709 * # getHandle * for j in range(0, (i-1)): * if(v[j] == v[i]): # <<<<<<<<<<<<<< * if (vStatus[j] == ICAFE_NORMAL): * vStatus[i] = vStatus[j] */ - __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3619, __pyx_L1_error) - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3619, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3709, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3709, __pyx_L1_error) __pyx_t_2 = (((__pyx_v_v[__pyx_t_14]) == (__pyx_v_v[__pyx_t_15])) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3620 + /* "PyCafe.pyx":3710 * for j in range(0, (i-1)): * if(v[j] == v[i]): * if (vStatus[j] == ICAFE_NORMAL): # <<<<<<<<<<<<<< * vStatus[i] = vStatus[j] * */ - __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3620, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3710, __pyx_L1_error) __pyx_t_2 = (((__pyx_v_vStatus[__pyx_t_10]) == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3621 + /* "PyCafe.pyx":3711 * if(v[j] == v[i]): * if (vStatus[j] == ICAFE_NORMAL): * vStatus[i] = vStatus[j] # <<<<<<<<<<<<<< * * # ca_poll() Not required as above will flush! */ - __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3621, __pyx_L1_error) - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3621, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3711, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3711, __pyx_L1_error) (__pyx_v_vStatus[__pyx_t_16]) = (__pyx_v_vStatus[__pyx_t_10]); - /* "PyCafe.pyx":3620 + /* "PyCafe.pyx":3710 * for j in range(0, (i-1)): * if(v[j] == v[i]): * if (vStatus[j] == ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -76966,7 +79055,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3619 + /* "PyCafe.pyx":3709 * # getHandle * for j in range(0, (i-1)): * if(v[j] == v[i]): # <<<<<<<<<<<<<< @@ -76975,7 +79064,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3618 + /* "PyCafe.pyx":3708 * if (vStatus[i] == ICAFE_WAITING_FOR_PREV_CALLBACK): * # getHandle * for j in range(0, (i-1)): # <<<<<<<<<<<<<< @@ -76985,7 +79074,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3616 + /* "PyCafe.pyx":3706 * if (status != ICAFE_NORMAL): * for i in range(0, len(vStatus)): * if (vStatus[i] == ICAFE_WAITING_FOR_PREV_CALLBACK): # <<<<<<<<<<<<<< @@ -76994,7 +79083,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3615 + /* "PyCafe.pyx":3705 * # Required for when dt='native' * if (status != ICAFE_NORMAL): * for i in range(0, len(vStatus)): # <<<<<<<<<<<<<< @@ -77004,7 +79093,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3614 + /* "PyCafe.pyx":3704 * # Functionality not yet moved to CAFE:: * # Required for when dt='native' * if (status != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -77013,7 +79102,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3627 + /* "PyCafe.pyx":3717 * # Wait for bundle * * with nogil: # <<<<<<<<<<<<<< @@ -77028,7 +79117,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py #endif /*try:*/ { - /* "PyCafe.pyx":3628 + /* "PyCafe.pyx":3718 * * with nogil: * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) # <<<<<<<<<<<<<< @@ -77038,7 +79127,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_v_statusBundle = __pyx_v_self->_c_cafe->waitForBundledEvents(__pyx_v_v, __pyx_v_vRB); } - /* "PyCafe.pyx":3627 + /* "PyCafe.pyx":3717 * # Wait for bundle * * with nogil: # <<<<<<<<<<<<<< @@ -77057,7 +79146,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } } - /* "PyCafe.pyx":3629 + /* "PyCafe.pyx":3719 * with nogil: * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) * if (statusBundle != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -77067,7 +79156,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((__pyx_v_statusBundle != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3630 + /* "PyCafe.pyx":3720 * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -77077,18 +79166,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3631 + /* "PyCafe.pyx":3721 * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def getScalarArray: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(statusBundle) * */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3631, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3632 + /* "PyCafe.pyx":3722 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def getScalarArray: ") * self._c_cafe.printStatusMessage(statusBundle) # <<<<<<<<<<<<<< @@ -77097,7 +79186,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_statusBundle); - /* "PyCafe.pyx":3630 + /* "PyCafe.pyx":3720 * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -77106,7 +79195,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3629 + /* "PyCafe.pyx":3719 * with nogil: * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) * if (statusBundle != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -77115,7 +79204,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3602 + /* "PyCafe.pyx":3692 * status = ICAFE_NORMAL * * if (cacheFlag == False): # <<<<<<<<<<<<<< @@ -77124,7 +79213,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3634 + /* "PyCafe.pyx":3724 * self._c_cafe.printStatusMessage(statusBundle) * * cdef unsigned int dtcheck = CAFE_NOT_REQUESTED # native type not yet know # <<<<<<<<<<<<<< @@ -77133,35 +79222,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_dtcheck = CAFE_NOT_REQUESTED; - /* "PyCafe.pyx":3635 + /* "PyCafe.pyx":3725 * * cdef unsigned int dtcheck = CAFE_NOT_REQUESTED # native type not yet know * dtcheck = getMatchedDataType(dt, dtcheck) # <<<<<<<<<<<<<< * * #print ("dt=", dt, "dtcheck=", dtcheck) */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtcheck); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3635, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtcheck); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3725, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_6); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3635, __pyx_L1_error) + __pyx_t_11 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_6); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3725, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3635, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3725, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_v_dtcheck = __pyx_t_8; - /* "PyCafe.pyx":3639 + /* "PyCafe.pyx":3729 * #print ("dt=", dt, "dtcheck=", dtcheck) * * localList = [] # <<<<<<<<<<<<<< * cdef bytes bytesVal * */ - __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3639, __pyx_L1_error) + __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_v_localList = ((PyObject*)__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3642 + /* "PyCafe.pyx":3732 * cdef bytes bytesVal * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -77171,7 +79260,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":3644 + /* "PyCafe.pyx":3734 * if dtcheck in [CAFE_STRING]: * * self.vStr.clear() # <<<<<<<<<<<<<< @@ -77180,17 +79269,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_self->vStr.clear(); - /* "PyCafe.pyx":3645 + /* "PyCafe.pyx":3735 * * self.vStr.clear() * self.vStr.reserve(len(handleList)) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3645, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3735, __pyx_L1_error) __pyx_v_self->vStr.reserve(__pyx_t_5); - /* "PyCafe.pyx":3647 + /* "PyCafe.pyx":3737 * self.vStr.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -77205,7 +79294,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py #endif /*try:*/ { - /* "PyCafe.pyx":3648 + /* "PyCafe.pyx":3738 * * with nogil: * status = self._c_cafe.getCacheVStr(v, self.vStr, vStatus) # <<<<<<<<<<<<<< @@ -77215,7 +79304,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_v_status = __pyx_v_self->_c_cafe->getCacheVStr(__pyx_v_v, __pyx_v_self->vStr, __pyx_v_vStatus); } - /* "PyCafe.pyx":3647 + /* "PyCafe.pyx":3737 * self.vStr.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -77234,17 +79323,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } } - /* "PyCafe.pyx":3650 + /* "PyCafe.pyx":3740 * status = self._c_cafe.getCacheVStr(v, self.vStr, vStatus) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3650, __pyx_L1_error) - __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3650, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3740, __pyx_L1_error) + __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3650, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -77252,16 +79341,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3650, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) { __pyx_t_6 = __pyx_t_11; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3650, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3650, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3740, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; for (;;) { @@ -77269,17 +79358,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3650, __pyx_L1_error) + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3740, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3650, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3650, __pyx_L1_error) + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3740, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3650, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } @@ -77289,7 +79378,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3650, __pyx_L1_error) + else __PYX_ERR(3, 3740, __pyx_L1_error) } break; } @@ -77298,23 +79387,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3652 + /* "PyCafe.pyx":3742 * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) # <<<<<<<<<<<<<< * * bytesVal = ( self.vStr[i] ) */ - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3652, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3652, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3742, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3652, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3652, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3742, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3651 + /* "PyCafe.pyx":3741 * * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( # <<<<<<<<<<<<<< @@ -77323,15 +79412,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ (void)(__pyx_v_self->_c_cafe->setNelemToPrevious(__pyx_t_8, __pyx_t_17)); - /* "PyCafe.pyx":3654 + /* "PyCafe.pyx":3744 * handleList[i], nelemPrevious[i]) * * bytesVal = ( self.vStr[i] ) # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): */ - __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3654, __pyx_L1_error) - __pyx_t_11 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_t_18]))); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3654, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3744, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_t_18]))); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_3 = __pyx_t_11; __Pyx_INCREF(__pyx_t_3); @@ -77339,7 +79428,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "PyCafe.pyx":3655 + /* "PyCafe.pyx":3745 * * bytesVal = ( self.vStr[i] ) * encoding = False # <<<<<<<<<<<<<< @@ -77348,25 +79437,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":3656 + /* "PyCafe.pyx":3746 * bytesVal = ( self.vStr[i] ) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3656, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3656, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3746, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_t_17)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3656, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_t_17)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3656, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3746, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3657 + /* "PyCafe.pyx":3747 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): * try: # <<<<<<<<<<<<<< @@ -77382,7 +79471,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XGOTREF(__pyx_t_21); /*try:*/ { - /* "PyCafe.pyx":3658 + /* "PyCafe.pyx":3748 * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -77391,14 +79480,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3658, __pyx_L34_error) + __PYX_ERR(3, 3748, __pyx_L34_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3658, __pyx_L34_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3748, __pyx_L34_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3659 + /* "PyCafe.pyx":3749 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -77407,7 +79496,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3657 + /* "PyCafe.pyx":3747 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): * try: # <<<<<<<<<<<<<< @@ -77423,7 +79512,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3660 + /* "PyCafe.pyx":3750 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -77438,7 +79527,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py goto __pyx_L36_except_error; __pyx_L36_except_error:; - /* "PyCafe.pyx":3657 + /* "PyCafe.pyx":3747 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): * try: # <<<<<<<<<<<<<< @@ -77458,7 +79547,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_L41_try_end:; } - /* "PyCafe.pyx":3656 + /* "PyCafe.pyx":3746 * bytesVal = ( self.vStr[i] ) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): # <<<<<<<<<<<<<< @@ -77467,7 +79556,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3662 + /* "PyCafe.pyx":3752 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -77477,7 +79566,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3663 + /* "PyCafe.pyx":3753 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -77493,7 +79582,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "PyCafe.pyx":3664 + /* "PyCafe.pyx":3754 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -77502,14 +79591,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3664, __pyx_L43_error) + __PYX_ERR(3, 3754, __pyx_L43_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3664, __pyx_L43_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3754, __pyx_L43_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3665 + /* "PyCafe.pyx":3755 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -77518,7 +79607,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3663 + /* "PyCafe.pyx":3753 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -77534,7 +79623,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3666 + /* "PyCafe.pyx":3756 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -77549,7 +79638,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py goto __pyx_L45_except_error; __pyx_L45_except_error:; - /* "PyCafe.pyx":3663 + /* "PyCafe.pyx":3753 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -77569,7 +79658,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_L50_try_end:; } - /* "PyCafe.pyx":3662 + /* "PyCafe.pyx":3752 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -77578,7 +79667,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3668 + /* "PyCafe.pyx":3758 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -77588,7 +79677,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3669 + /* "PyCafe.pyx":3759 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -77604,7 +79693,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XGOTREF(__pyx_t_21); /*try:*/ { - /* "PyCafe.pyx":3670 + /* "PyCafe.pyx":3760 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -77613,14 +79702,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3670, __pyx_L52_error) + __PYX_ERR(3, 3760, __pyx_L52_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3670, __pyx_L52_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3760, __pyx_L52_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3671 + /* "PyCafe.pyx":3761 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -77629,7 +79718,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3669 + /* "PyCafe.pyx":3759 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -77645,7 +79734,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3672 + /* "PyCafe.pyx":3762 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -77660,7 +79749,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py goto __pyx_L54_except_error; __pyx_L54_except_error:; - /* "PyCafe.pyx":3669 + /* "PyCafe.pyx":3759 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -77680,7 +79769,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_L59_try_end:; } - /* "PyCafe.pyx":3668 + /* "PyCafe.pyx":3758 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -77689,7 +79778,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3674 + /* "PyCafe.pyx":3764 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -77699,20 +79788,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3675 + /* "PyCafe.pyx":3765 * pass * if not encoding: * strVal = self.vStr[i] # <<<<<<<<<<<<<< * * localList.append(strVal) */ - __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3675, __pyx_L1_error) - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_t_18]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3675, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3765, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_t_18]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3765, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3674 + /* "PyCafe.pyx":3764 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -77721,17 +79810,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3677 + /* "PyCafe.pyx":3767 * strVal = self.vStr[i] * * localList.append(strVal) # <<<<<<<<<<<<<< * * return localList, status, vStatus */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 3677, __pyx_L1_error) } - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3677, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 3767, __pyx_L1_error) } + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3767, __pyx_L1_error) - /* "PyCafe.pyx":3650 + /* "PyCafe.pyx":3740 * status = self._c_cafe.getCacheVStr(v, self.vStr, vStatus) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -77741,7 +79830,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3679 + /* "PyCafe.pyx":3769 * localList.append(strVal) * * return localList, status, vStatus # <<<<<<<<<<<<<< @@ -77749,11 +79838,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3679, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3679, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3679, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -77768,7 +79857,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_11 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3642 + /* "PyCafe.pyx":3732 * cdef bytes bytesVal * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -77778,7 +79867,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; case CAFE_SHORT: - /* "PyCafe.pyx":3681 + /* "PyCafe.pyx":3771 * return localList, status, vStatus * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -77788,7 +79877,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py case CAFE_CHAR: case CAFE_LONG: - /* "PyCafe.pyx":3683 + /* "PyCafe.pyx":3773 * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: * * self.vInt.clear() # <<<<<<<<<<<<<< @@ -77797,17 +79886,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_self->vInt.clear(); - /* "PyCafe.pyx":3684 + /* "PyCafe.pyx":3774 * * self.vInt.clear() * self.vInt.reserve(len(handleList)) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3684, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3774, __pyx_L1_error) __pyx_v_self->vInt.reserve(__pyx_t_5); - /* "PyCafe.pyx":3686 + /* "PyCafe.pyx":3776 * self.vInt.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -77822,7 +79911,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py #endif /*try:*/ { - /* "PyCafe.pyx":3687 + /* "PyCafe.pyx":3777 * * with nogil: * status = self._c_cafe.getCacheVLong(v, self.vInt, vStatus) # <<<<<<<<<<<<<< @@ -77832,7 +79921,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_v_status = __pyx_v_self->_c_cafe->getCacheVLong(__pyx_v_v, __pyx_v_self->vInt, __pyx_v_vStatus); } - /* "PyCafe.pyx":3686 + /* "PyCafe.pyx":3776 * self.vInt.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -77851,17 +79940,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } } - /* "PyCafe.pyx":3692 + /* "PyCafe.pyx":3782 * #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]) */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3692, __pyx_L1_error) - __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3692, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3782, __pyx_L1_error) + __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3692, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -77869,16 +79958,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3692, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) { __pyx_t_3 = __pyx_t_11; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3692, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3692, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3782, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; for (;;) { @@ -77886,17 +79975,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3692, __pyx_L1_error) + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3782, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3692, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3692, __pyx_L1_error) + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3782, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3692, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } @@ -77906,7 +79995,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3692, __pyx_L1_error) + else __PYX_ERR(3, 3782, __pyx_L1_error) } break; } @@ -77915,23 +80004,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3694 + /* "PyCafe.pyx":3784 * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) # <<<<<<<<<<<<<< * * # localList=[] */ - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3694, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3694, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3784, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3694, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3694, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3784, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3693 + /* "PyCafe.pyx":3783 * * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( # <<<<<<<<<<<<<< @@ -77940,7 +80029,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ (void)(__pyx_v_self->_c_cafe->setNelemToPrevious(__pyx_t_17, __pyx_t_8)); - /* "PyCafe.pyx":3692 + /* "PyCafe.pyx":3782 * #print ("status " , vStatus[i], " i", i, self._c_cafe.getPVFromHandle(handleList[i])) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -77950,7 +80039,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3700 + /* "PyCafe.pyx":3790 * * # for i in range(0, len(self.vInt)): * return self.vInt, status, vStatus # <<<<<<<<<<<<<< @@ -77958,13 +80047,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_convert_vector_to_py_dbr_long_t(__pyx_v_self->vInt); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3700, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_dbr_long_t(__pyx_v_self->vInt); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3700, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3700, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_23 = PyTuple_New(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3700, __pyx_L1_error) + __pyx_t_23 = PyTuple_New(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_3); @@ -77979,7 +80068,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_23 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3681 + /* "PyCafe.pyx":3771 * return localList, status, vStatus * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -77989,7 +80078,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; case CAFE_FLOAT: - /* "PyCafe.pyx":3702 + /* "PyCafe.pyx":3792 * return self.vInt, status, vStatus * * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -77998,7 +80087,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ case CAFE_DOUBLE: - /* "PyCafe.pyx":3704 + /* "PyCafe.pyx":3794 * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: * * self.vFloat.clear() # <<<<<<<<<<<<<< @@ -78007,17 +80096,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_self->vFloat.clear(); - /* "PyCafe.pyx":3705 + /* "PyCafe.pyx":3795 * * self.vFloat.clear() * self.vFloat.reserve(len(handleList)) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3705, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3795, __pyx_L1_error) __pyx_v_self->vFloat.reserve(__pyx_t_5); - /* "PyCafe.pyx":3707 + /* "PyCafe.pyx":3797 * self.vFloat.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -78032,7 +80121,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py #endif /*try:*/ { - /* "PyCafe.pyx":3708 + /* "PyCafe.pyx":3798 * * with nogil: * status = self._c_cafe.getCacheVDouble(v, self.vFloat, vStatus) # <<<<<<<<<<<<<< @@ -78042,7 +80131,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_v_status = __pyx_v_self->_c_cafe->getCacheVDouble(__pyx_v_v, __pyx_v_self->vFloat, __pyx_v_vStatus); } - /* "PyCafe.pyx":3707 + /* "PyCafe.pyx":3797 * self.vFloat.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -78061,17 +80150,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } } - /* "PyCafe.pyx":3710 + /* "PyCafe.pyx":3800 * status = self._c_cafe.getCacheVDouble(v, self.vFloat, vStatus) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3710, __pyx_L1_error) - __pyx_t_23 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3710, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3800, __pyx_L1_error) + __pyx_t_23 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3710, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -78079,16 +80168,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_23); __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3710, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_23)) || PyTuple_CheckExact(__pyx_t_23)) { __pyx_t_6 = __pyx_t_23; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_23); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3710, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_23); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3710, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3800, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; for (;;) { @@ -78096,17 +80185,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_23 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_23); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3710, __pyx_L1_error) + __pyx_t_23 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_23); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3800, __pyx_L1_error) #else - __pyx_t_23 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3710, __pyx_L1_error) + __pyx_t_23 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_23 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_23); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3710, __pyx_L1_error) + __pyx_t_23 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_23); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3800, __pyx_L1_error) #else - __pyx_t_23 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3710, __pyx_L1_error) + __pyx_t_23 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); #endif } @@ -78116,7 +80205,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3710, __pyx_L1_error) + else __PYX_ERR(3, 3800, __pyx_L1_error) } break; } @@ -78125,23 +80214,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":3712 + /* "PyCafe.pyx":3802 * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) # <<<<<<<<<<<<<< * * # for i in range(0, len(vStatus)): */ - __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3712, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3802, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3712, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3802, __pyx_L1_error) __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3712, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3802, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3712, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3802, __pyx_L1_error) __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":3711 + /* "PyCafe.pyx":3801 * * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( # <<<<<<<<<<<<<< @@ -78150,7 +80239,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ (void)(__pyx_v_self->_c_cafe->setNelemToPrevious(__pyx_t_8, __pyx_t_17)); - /* "PyCafe.pyx":3710 + /* "PyCafe.pyx":3800 * status = self._c_cafe.getCacheVDouble(v, self.vFloat, vStatus) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -78160,7 +80249,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3727 + /* "PyCafe.pyx":3817 * * # for i in range(0, len(self.vFloat)): * return self.vFloat, status, vStatus # <<<<<<<<<<<<<< @@ -78168,13 +80257,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py * # Native */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __pyx_convert_vector_to_py_double(__pyx_v_self->vFloat); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3727, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_vector_to_py_double(__pyx_v_self->vFloat); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_23 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3727, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_11 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3727, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3727, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); @@ -78189,7 +80278,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3702 + /* "PyCafe.pyx":3792 * return self.vInt, status, vStatus * * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -78200,7 +80289,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py default: break; } - /* "PyCafe.pyx":3740 + /* "PyCafe.pyx":3830 * # Create temporary group from handleList * # Does group exist? * cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) # <<<<<<<<<<<<<< @@ -78209,16 +80298,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_pvd = __pyx_v_self->_c_cafe->getPVData(__pyx_v_v); - /* "PyCafe.pyx":3756 + /* "PyCafe.pyx":3846 * * # Required to allocate memory for shared pointer * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< * pvd[i].setNelem(1) * */ - __pyx_t_3 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3756, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3756, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -78226,16 +80315,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3756, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_11 = __pyx_t_3; __Pyx_INCREF(__pyx_t_11); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3756, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_7 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3756, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3846, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -78243,17 +80332,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_11))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3756, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3846, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3756, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3756, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3846, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3756, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -78263,7 +80352,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3756, __pyx_L1_error) + else __PYX_ERR(3, 3846, __pyx_L1_error) } break; } @@ -78272,17 +80361,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3757 + /* "PyCafe.pyx":3847 * # Required to allocate memory for shared pointer * for i in range(0, v.size()): #len(handleList)): * pvd[i].setNelem(1) # <<<<<<<<<<<<<< * * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3757, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3847, __pyx_L1_error) (void)((__pyx_v_pvd[__pyx_t_12]).setNelem(1)); - /* "PyCafe.pyx":3756 + /* "PyCafe.pyx":3846 * * # Required to allocate memory for shared pointer * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -78292,7 +80381,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3759 + /* "PyCafe.pyx":3849 * pvd[i].setNelem(1) * * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) # <<<<<<<<<<<<<< @@ -78301,17 +80390,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_statusNoWait = __pyx_v_self->_c_cafe->getCachePVArrayNoWait(__pyx_v_v, __pyx_v_pvd); - /* "PyCafe.pyx":3761 + /* "PyCafe.pyx":3851 * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * self._c_cafe.setNelemToPrevious(handleList[i], nelemPrevious[i]) * */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3761, __pyx_L1_error) - __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3761, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3851, __pyx_L1_error) + __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3761, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -78319,16 +80408,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3761, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) { __pyx_t_3 = __pyx_t_11; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3761, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3761, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3851, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; for (;;) { @@ -78336,17 +80425,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3761, __pyx_L1_error) + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3851, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3761, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3761, __pyx_L1_error) + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3851, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3761, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } @@ -78356,7 +80445,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3761, __pyx_L1_error) + else __PYX_ERR(3, 3851, __pyx_L1_error) } break; } @@ -78365,24 +80454,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3762 + /* "PyCafe.pyx":3852 * * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious(handleList[i], nelemPrevious[i]) # <<<<<<<<<<<<<< * * statusList = [] */ - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3762, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3762, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3852, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3762, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3762, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3852, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; (void)(__pyx_v_self->_c_cafe->setNelemToPrevious(__pyx_t_17, __pyx_t_8)); - /* "PyCafe.pyx":3761 + /* "PyCafe.pyx":3851 * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -78392,19 +80481,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3764 + /* "PyCafe.pyx":3854 * self._c_cafe.setNelemToPrevious(handleList[i], nelemPrevious[i]) * * statusList = [] # <<<<<<<<<<<<<< * statusFlag = True * statusLocal = ICAFE_NORMAL */ - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3764, __pyx_L1_error) + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3854, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_statusList = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3765 + /* "PyCafe.pyx":3855 * * statusList = [] * statusFlag = True # <<<<<<<<<<<<<< @@ -78413,19 +80502,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_statusFlag = 1; - /* "PyCafe.pyx":3766 + /* "PyCafe.pyx":3856 * statusList = [] * statusFlag = True * statusLocal = ICAFE_NORMAL # <<<<<<<<<<<<<< * if (cacheFlag): * */ - __pyx_t_3 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3766, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_statusLocal = __pyx_t_3; __pyx_t_3 = 0; - /* "PyCafe.pyx":3767 + /* "PyCafe.pyx":3857 * statusFlag = True * statusLocal = ICAFE_NORMAL * if (cacheFlag): # <<<<<<<<<<<<<< @@ -78435,16 +80524,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_1 = (__pyx_v_cacheFlag != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3773 + /* "PyCafe.pyx":3863 * # self._c_cafe.printStatusMessage(status) * # status=ICAFE_NORMAL * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< * statusList.append(pvd[i].getStatus()) * if pvd[i].getStatus() != ICAFE_NORMAL: */ - __pyx_t_3 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3773, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3863, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3773, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3863, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -78452,16 +80541,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3773, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3863, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_11 = __pyx_t_3; __Pyx_INCREF(__pyx_t_11); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3773, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3863, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_7 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3773, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3863, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -78469,17 +80558,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_11))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3773, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3863, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3773, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3863, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3773, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3863, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3773, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3863, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -78489,7 +80578,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3773, __pyx_L1_error) + else __PYX_ERR(3, 3863, __pyx_L1_error) } break; } @@ -78498,41 +80587,41 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3774 + /* "PyCafe.pyx":3864 * # status=ICAFE_NORMAL * for i in range(0, v.size()): #len(handleList)): * statusList.append(pvd[i].getStatus()) # <<<<<<<<<<<<<< * if pvd[i].getStatus() != ICAFE_NORMAL: * print("Error in Element ", i, " from ", len( */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3774, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3774, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3864, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3864, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3774, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3864, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3775 + /* "PyCafe.pyx":3865 * for i in range(0, v.size()): #len(handleList)): * statusList.append(pvd[i].getStatus()) * if pvd[i].getStatus() != ICAFE_NORMAL: # <<<<<<<<<<<<<< * print("Error in Element ", i, " from ", len( * handleList), " in PyCafe def getScalarArray") */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3775, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3865, __pyx_L1_error) __pyx_t_1 = (((__pyx_v_pvd[__pyx_t_12]).getStatus() != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3776 + /* "PyCafe.pyx":3866 * statusList.append(pvd[i].getStatus()) * if pvd[i].getStatus() != ICAFE_NORMAL: * print("Error in Element ", i, " from ", len( # <<<<<<<<<<<<<< * handleList), " in PyCafe def getScalarArray") * print("Handle= ", handleList[i], " PV=", */ - __pyx_t_12 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3776, __pyx_L1_error) - __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3776, __pyx_L1_error) + __pyx_t_12 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3866, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_23 = PyTuple_New(5); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3776, __pyx_L1_error) + __pyx_t_23 = PyTuple_New(5); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_INCREF(__pyx_kp_u_Error_in_Element); __Pyx_GIVEREF(__pyx_kp_u_Error_in_Element); @@ -78549,43 +80638,43 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_kp_u_in_PyCafe_def_getScalarArray); PyTuple_SET_ITEM(__pyx_t_23, 4, __pyx_kp_u_in_PyCafe_def_getScalarArray); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3776, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3778 + /* "PyCafe.pyx":3868 * print("Error in Element ", i, " from ", len( * handleList), " in PyCafe def getScalarArray") * print("Handle= ", handleList[i], " PV=", # <<<<<<<<<<<<<< * self.hh.getPVFromHandle(handleList[i])) * print("with error status=", pvd[i].getStatus()) */ - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3778, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3868, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "PyCafe.pyx":3779 + /* "PyCafe.pyx":3869 * handleList), " in PyCafe def getScalarArray") * print("Handle= ", handleList[i], " PV=", * self.hh.getPVFromHandle(handleList[i])) # <<<<<<<<<<<<<< * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) */ - __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3779, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3869, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3779, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3869, __pyx_L1_error) __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_8)); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3779, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_8)); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3869, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - /* "PyCafe.pyx":3778 + /* "PyCafe.pyx":3868 * print("Error in Element ", i, " from ", len( * handleList), " in PyCafe def getScalarArray") * print("Handle= ", handleList[i], " PV=", # <<<<<<<<<<<<<< * self.hh.getPVFromHandle(handleList[i])) * print("with error status=", pvd[i].getStatus()) */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3778, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3868, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_kp_u_Handle_2); __Pyx_GIVEREF(__pyx_kp_u_Handle_2); @@ -78599,22 +80688,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_23); __pyx_t_3 = 0; __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3778, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3868, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":3780 + /* "PyCafe.pyx":3870 * 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: */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3780, __pyx_L1_error) - __pyx_t_23 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3780, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3870, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3780, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_kp_u_with_error_status); __Pyx_GIVEREF(__pyx_kp_u_with_error_status); @@ -78622,22 +80711,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_23); __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3780, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":3781 + /* "PyCafe.pyx":3871 * 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() */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3781, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3871, __pyx_L1_error) __pyx_v_self->_c_cafe->printStatusMessage((__pyx_v_pvd[__pyx_t_12]).getStatus()); - /* "PyCafe.pyx":3782 + /* "PyCafe.pyx":3872 * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * if statusFlag: # <<<<<<<<<<<<<< @@ -78647,20 +80736,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_1 = (__pyx_v_statusFlag != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3783 + /* "PyCafe.pyx":3873 * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * if statusFlag: * statusLocal = pvd[i].getStatus() # <<<<<<<<<<<<<< * statusFlag = False * */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3783, __pyx_L1_error) - __pyx_t_23 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3783, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3873, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_DECREF_SET(__pyx_v_statusLocal, __pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":3784 + /* "PyCafe.pyx":3874 * if statusFlag: * statusLocal = pvd[i].getStatus() * statusFlag = False # <<<<<<<<<<<<<< @@ -78669,7 +80758,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_statusFlag = 0; - /* "PyCafe.pyx":3782 + /* "PyCafe.pyx":3872 * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * if statusFlag: # <<<<<<<<<<<<<< @@ -78678,7 +80767,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3775 + /* "PyCafe.pyx":3865 * for i in range(0, v.size()): #len(handleList)): * statusList.append(pvd[i].getStatus()) * if pvd[i].getStatus() != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -78687,7 +80776,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3773 + /* "PyCafe.pyx":3863 * # self._c_cafe.printStatusMessage(status) * # status=ICAFE_NORMAL * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -78697,7 +80786,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3767 + /* "PyCafe.pyx":3857 * statusFlag = True * statusLocal = ICAFE_NORMAL * if (cacheFlag): # <<<<<<<<<<<<<< @@ -78706,28 +80795,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3794 + /* "PyCafe.pyx":3884 * cdef unsigned int dtn * * localList = [] # <<<<<<<<<<<<<< * * */ - __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3794, __pyx_L1_error) + __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF_SET(__pyx_v_localList, ((PyObject*)__pyx_t_11)); __pyx_t_11 = 0; - /* "PyCafe.pyx":3797 + /* "PyCafe.pyx":3887 * * * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< * * dtn = pvd[i].getDataType() */ - __pyx_t_11 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -78735,16 +80824,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_23, 1, __pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_23, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_23, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) { __pyx_t_23 = __pyx_t_11; __Pyx_INCREF(__pyx_t_23); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_23 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_23 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_7 = Py_TYPE(__pyx_t_23)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_23)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3887, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; for (;;) { @@ -78752,17 +80841,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py if (likely(PyList_CheckExact(__pyx_t_23))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_23)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyList_GET_ITEM(__pyx_t_23, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_23, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3887, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_23, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_23, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_23)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_23, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_23, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3887, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_23, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3797, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_23, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } @@ -78772,7 +80861,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3797, __pyx_L1_error) + else __PYX_ERR(3, 3887, __pyx_L1_error) } break; } @@ -78781,33 +80870,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3799 + /* "PyCafe.pyx":3889 * for i in range(0, v.size()): #len(handleList)): * * dtn = pvd[i].getDataType() # <<<<<<<<<<<<<< * dtcheck = getMatchedDataType(dt, dtn) * */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3799, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3889, __pyx_L1_error) __pyx_v_dtn = (__pyx_v_pvd[__pyx_t_12]).getDataType(); - /* "PyCafe.pyx":3800 + /* "PyCafe.pyx":3890 * * dtn = pvd[i].getDataType() * dtcheck = getMatchedDataType(dt, dtn) # <<<<<<<<<<<<<< * * #print ("dt=", dt, "dtn=", dtn, "dtcheck=", dtcheck) */ - __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3800, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3800, __pyx_L1_error) + __pyx_t_6 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3800, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_dtcheck = __pyx_t_8; - /* "PyCafe.pyx":3806 + /* "PyCafe.pyx":3896 * #print (pvd[i].getAsDouble()) * * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -78817,15 +80906,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":3807 + /* "PyCafe.pyx":3897 * * if dtcheck == CAFE_STRING: * bytesVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3807, __pyx_L1_error) - __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3807, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3897, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_11 = __pyx_t_6; __Pyx_INCREF(__pyx_t_11); @@ -78833,7 +80922,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_11)); __pyx_t_11 = 0; - /* "PyCafe.pyx":3808 + /* "PyCafe.pyx":3898 * if dtcheck == CAFE_STRING: * bytesVal = pvd[i].getAsString() * encoding = False # <<<<<<<<<<<<<< @@ -78842,22 +80931,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":3809 + /* "PyCafe.pyx":3899 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3809, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_t_15]))); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3809, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3899, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_t_15]))); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_11, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 3809, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_11, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 3899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3810 + /* "PyCafe.pyx":3900 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -78873,7 +80962,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "PyCafe.pyx":3811 + /* "PyCafe.pyx":3901 * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -78882,14 +80971,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3811, __pyx_L83_error) + __PYX_ERR(3, 3901, __pyx_L83_error) } - __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3811, __pyx_L83_error) + __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3901, __pyx_L83_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3812 + /* "PyCafe.pyx":3902 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -78898,7 +80987,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3810 + /* "PyCafe.pyx":3900 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -78915,7 +81004,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3813 + /* "PyCafe.pyx":3903 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -78930,7 +81019,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py goto __pyx_L85_except_error; __pyx_L85_except_error:; - /* "PyCafe.pyx":3810 + /* "PyCafe.pyx":3900 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -78950,7 +81039,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_L90_try_end:; } - /* "PyCafe.pyx":3809 + /* "PyCafe.pyx":3899 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< @@ -78959,7 +81048,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3815 + /* "PyCafe.pyx":3905 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -78969,7 +81058,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3816 + /* "PyCafe.pyx":3906 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -78985,7 +81074,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XGOTREF(__pyx_t_21); /*try:*/ { - /* "PyCafe.pyx":3817 + /* "PyCafe.pyx":3907 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -78994,14 +81083,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3817, __pyx_L92_error) + __PYX_ERR(3, 3907, __pyx_L92_error) } - __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3817, __pyx_L92_error) + __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3907, __pyx_L92_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3818 + /* "PyCafe.pyx":3908 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -79010,7 +81099,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3816 + /* "PyCafe.pyx":3906 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -79027,7 +81116,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3819 + /* "PyCafe.pyx":3909 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -79042,7 +81131,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py goto __pyx_L94_except_error; __pyx_L94_except_error:; - /* "PyCafe.pyx":3816 + /* "PyCafe.pyx":3906 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -79062,7 +81151,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_L99_try_end:; } - /* "PyCafe.pyx":3815 + /* "PyCafe.pyx":3905 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -79071,7 +81160,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3821 + /* "PyCafe.pyx":3911 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -79081,7 +81170,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3822 + /* "PyCafe.pyx":3912 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -79097,7 +81186,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "PyCafe.pyx":3823 + /* "PyCafe.pyx":3913 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -79106,14 +81195,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3823, __pyx_L101_error) + __PYX_ERR(3, 3913, __pyx_L101_error) } - __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3823, __pyx_L101_error) + __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3913, __pyx_L101_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3824 + /* "PyCafe.pyx":3914 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -79122,7 +81211,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3822 + /* "PyCafe.pyx":3912 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -79139,7 +81228,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3825 + /* "PyCafe.pyx":3915 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -79154,7 +81243,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py goto __pyx_L103_except_error; __pyx_L103_except_error:; - /* "PyCafe.pyx":3822 + /* "PyCafe.pyx":3912 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -79174,7 +81263,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_L108_try_end:; } - /* "PyCafe.pyx":3821 + /* "PyCafe.pyx":3911 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -79183,7 +81272,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3827 + /* "PyCafe.pyx":3917 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -79193,20 +81282,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3828 + /* "PyCafe.pyx":3918 * pass * if not encoding: * strVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * * localList.append(strVal) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3828, __pyx_L1_error) - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3828, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3918, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3918, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3827 + /* "PyCafe.pyx":3917 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -79215,17 +81304,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3830 + /* "PyCafe.pyx":3920 * strVal = pvd[i].getAsString() * * localList.append(strVal) # <<<<<<<<<<<<<< * * ##localList.append(pvd[i].getAsString()) */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 3830, __pyx_L1_error) } - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3830, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 3920, __pyx_L1_error) } + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3920, __pyx_L1_error) - /* "PyCafe.pyx":3806 + /* "PyCafe.pyx":3896 * #print (pvd[i].getAsDouble()) * * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -79235,20 +81324,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; case CAFE_SHORT: - /* "PyCafe.pyx":3834 + /* "PyCafe.pyx":3924 * ##localList.append(pvd[i].getAsString()) * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3834, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3834, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3924, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3834, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3924, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3833 + /* "PyCafe.pyx":3923 * * ##localList.append(pvd[i].getAsString()) * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -79258,20 +81347,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; case CAFE_FLOAT: - /* "PyCafe.pyx":3836 + /* "PyCafe.pyx":3926 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3836, __pyx_L1_error) - __pyx_t_11 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_t_12]).getAsDouble()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3836, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3926, __pyx_L1_error) + __pyx_t_11 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_t_12]).getAsDouble()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3926, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3836, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3926, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3835 + /* "PyCafe.pyx":3925 * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -79281,31 +81370,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; case CAFE_ENUM: - /* "PyCafe.pyx":3840 + /* "PyCafe.pyx":3930 * # if enum, string taken as native * * if self._c_cafe.isEnum(self.hh.getHandleFromPV(pvd[i].getPVName())): # <<<<<<<<<<<<<< * localList.append(pvd[i].getAsString()) * else: */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3840, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3930, __pyx_L1_error) __pyx_t_2 = (__pyx_v_self->_c_cafe->isEnum(__pyx_v_self->hh.getHandleFromPV((__pyx_v_pvd[__pyx_t_12]).getPVName())) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3841 + /* "PyCafe.pyx":3931 * * if self._c_cafe.isEnum(self.hh.getHandleFromPV(pvd[i].getPVName())): * localList.append(pvd[i].getAsString()) # <<<<<<<<<<<<<< * else: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3841, __pyx_L1_error) - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3841, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3931, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3931, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3841, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3931, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3840 + /* "PyCafe.pyx":3930 * # if enum, string taken as native * * if self._c_cafe.isEnum(self.hh.getHandleFromPV(pvd[i].getPVName())): # <<<<<<<<<<<<<< @@ -79315,7 +81404,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py goto __pyx_L110; } - /* "PyCafe.pyx":3843 + /* "PyCafe.pyx":3933 * localList.append(pvd[i].getAsString()) * else: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< @@ -79323,15 +81412,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py * elif dtcheck == CAFE_CHAR: */ /*else*/ { - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3843, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3843, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3933, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3933, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3843, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3933, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __pyx_L110:; - /* "PyCafe.pyx":3837 + /* "PyCafe.pyx":3927 * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -79341,20 +81430,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; case CAFE_CHAR: - /* "PyCafe.pyx":3847 + /* "PyCafe.pyx":3937 * elif dtcheck == CAFE_CHAR: * # pvd[i].getAsChar() * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3847, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3847, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3937, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3937, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3847, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3937, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3845 + /* "PyCafe.pyx":3935 * localList.append(pvd[i].getAsLong()) * * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -79364,20 +81453,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; case CAFE_LONG: - /* "PyCafe.pyx":3849 + /* "PyCafe.pyx":3939 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3849, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3849, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3939, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3939, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3849, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3939, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3848 + /* "PyCafe.pyx":3938 * # pvd[i].getAsChar() * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -79387,20 +81476,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; case CAFE_DOUBLE: - /* "PyCafe.pyx":3851 + /* "PyCafe.pyx":3941 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * else: * localList.append(0) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3851, __pyx_L1_error) - __pyx_t_11 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_t_12]).getAsDouble()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3851, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3941, __pyx_L1_error) + __pyx_t_11 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_t_12]).getAsDouble()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3941, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3851, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3941, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3850 + /* "PyCafe.pyx":3940 * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -79410,16 +81499,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; default: - /* "PyCafe.pyx":3853 + /* "PyCafe.pyx":3943 * localList.append(pvd[i].getAsDouble()) * else: * localList.append(0) # <<<<<<<<<<<<<< * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: * print("def getScalarArray:") */ - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3853, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3943, __pyx_L1_error) - /* "PyCafe.pyx":3854 + /* "PyCafe.pyx":3944 * else: * localList.append(0) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: # <<<<<<<<<<<<<< @@ -79429,25 +81518,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_HIGH) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3855 + /* "PyCafe.pyx":3945 * localList.append(0) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: * print("def getScalarArray:") # <<<<<<<<<<<<<< * print("Entering 0 for element", i, * "as channel is not connected!") */ - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3855, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3856 + /* "PyCafe.pyx":3946 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: * print("def getScalarArray:") * print("Entering 0 for element", i, # <<<<<<<<<<<<<< * "as channel is not connected!") * */ - __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3856, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3946, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_kp_u_Entering_0_for_element); __Pyx_GIVEREF(__pyx_kp_u_Entering_0_for_element); @@ -79458,12 +81547,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __Pyx_INCREF(__pyx_kp_u_as_channel_is_not_connected); __Pyx_GIVEREF(__pyx_kp_u_as_channel_is_not_connected); PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_kp_u_as_channel_is_not_connected); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3856, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3946, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3854 + /* "PyCafe.pyx":3944 * else: * localList.append(0) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: # <<<<<<<<<<<<<< @@ -79474,7 +81563,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py break; } - /* "PyCafe.pyx":3797 + /* "PyCafe.pyx":3887 * * * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -79484,7 +81573,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py } __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":3862 + /* "PyCafe.pyx":3952 * * # free(pvd) * if cacheFlag: # <<<<<<<<<<<<<< @@ -79494,7 +81583,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_2 = (__pyx_v_cacheFlag != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3863 + /* "PyCafe.pyx":3953 * # free(pvd) * if cacheFlag: * return localList, statusLocal, statusList # <<<<<<<<<<<<<< @@ -79502,7 +81591,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py * # use vstatus instead of statusList (as cache is NoWait) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_23 = PyTuple_New(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3863, __pyx_L1_error) + __pyx_t_23 = PyTuple_New(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3953, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -79517,7 +81606,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_23 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3862 + /* "PyCafe.pyx":3952 * * # free(pvd) * if cacheFlag: # <<<<<<<<<<<<<< @@ -79526,7 +81615,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":3866 + /* "PyCafe.pyx":3956 * * # use vstatus instead of statusList (as cache is NoWait) * return localList, status, vStatus # <<<<<<<<<<<<<< @@ -79534,11 +81623,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_23 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3866, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 3956, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_6 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3866, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3956, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3866, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3956, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -79553,7 +81642,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py __pyx_t_11 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3567 + /* "PyCafe.pyx":3657 * ################################################################################## * * def getScalarArray(self, handleList, str dt='native', bint cacheFlag=False): # <<<<<<<<<<<<<< @@ -79587,7 +81676,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_284getScalarArray(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":3877 +/* "PyCafe.pyx":3967 * ################################################################################## * * def getStrScalarList(self, handleList): # <<<<<<<<<<<<<< @@ -79617,7 +81706,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_286getStrScalarList(struct __pyx_obj_6 PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getStrScalarList", 0); - /* "PyCafe.pyx":3879 + /* "PyCafe.pyx":3969 * def getStrScalarList(self, handleList): * ################################################################################## * return self.getScalarList(handleList, dt='str') # <<<<<<<<<<<<<< @@ -79625,17 +81714,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_286getStrScalarList(struct __pyx_obj_6 * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getScalarList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3879, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getScalarList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3879, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handleList); __Pyx_GIVEREF(__pyx_v_handleList); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handleList); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3879, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 3879, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3879, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 3969, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -79644,7 +81733,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_286getStrScalarList(struct __pyx_obj_6 __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3877 + /* "PyCafe.pyx":3967 * ################################################################################## * * def getStrScalarList(self, handleList): # <<<<<<<<<<<<<< @@ -79668,7 +81757,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_286getStrScalarList(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":3882 +/* "PyCafe.pyx":3972 * * ################################################################################## * def getIntScalarList(self, handleList): # <<<<<<<<<<<<<< @@ -79698,7 +81787,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_288getIntScalarList(struct __pyx_obj_6 PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getIntScalarList", 0); - /* "PyCafe.pyx":3884 + /* "PyCafe.pyx":3974 * def getIntScalarList(self, handleList): * ################################################################################## * return self.getScalarList(handleList, dt='int') # <<<<<<<<<<<<<< @@ -79706,17 +81795,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_288getIntScalarList(struct __pyx_obj_6 * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getScalarList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3884, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getScalarList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3884, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handleList); __Pyx_GIVEREF(__pyx_v_handleList); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handleList); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3884, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 3884, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3884, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 3974, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -79725,7 +81814,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_288getIntScalarList(struct __pyx_obj_6 __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3882 + /* "PyCafe.pyx":3972 * * ################################################################################## * def getIntScalarList(self, handleList): # <<<<<<<<<<<<<< @@ -79749,7 +81838,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_288getIntScalarList(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":3887 +/* "PyCafe.pyx":3977 * * ################################################################################## * def getFloatScalarList(self, handleList): # <<<<<<<<<<<<<< @@ -79779,7 +81868,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_290getFloatScalarList(struct __pyx_obj PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getFloatScalarList", 0); - /* "PyCafe.pyx":3889 + /* "PyCafe.pyx":3979 * def getFloatScalarList(self, handleList): * ################################################################################## * return self.getScalarList(handleList, dt='float') # <<<<<<<<<<<<<< @@ -79787,17 +81876,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_290getFloatScalarList(struct __pyx_obj * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getScalarList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3889, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getScalarList); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3889, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handleList); __Pyx_GIVEREF(__pyx_v_handleList); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handleList); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3889, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 3889, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3889, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 3979, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -79806,7 +81895,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_290getFloatScalarList(struct __pyx_obj __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3887 + /* "PyCafe.pyx":3977 * * ################################################################################## * def getFloatScalarList(self, handleList): # <<<<<<<<<<<<<< @@ -79830,7 +81919,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_290getFloatScalarList(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":3892 +/* "PyCafe.pyx":3982 * * ################################################################################## * def getScalarList(self, handleList, dt: str = 'native', # <<<<<<<<<<<<<< @@ -79853,7 +81942,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_293getScalarList(PyObject *__pyx_v_sel PyObject* values[4] = {0,0,0,0}; values[1] = ((PyObject*)__pyx_n_u_native); - /* "PyCafe.pyx":3893 + /* "PyCafe.pyx":3983 * ################################################################################## * def getScalarList(self, handleList, dt: str = 'native', * cacheFlag: bool = False, dictFlag: bool = False): # <<<<<<<<<<<<<< @@ -79902,7 +81991,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_293getScalarList(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getScalarList") < 0)) __PYX_ERR(3, 3892, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getScalarList") < 0)) __PYX_ERR(3, 3982, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -79924,16 +82013,16 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_293getScalarList(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getScalarList", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3892, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getScalarList", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3982, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getScalarList", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 3892, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 3982, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_292getScalarList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handleList, __pyx_v_dt, __pyx_v_cacheFlag, __pyx_v_dictFlag); - /* "PyCafe.pyx":3892 + /* "PyCafe.pyx":3982 * * ################################################################################## * def getScalarList(self, handleList, dt: str = 'native', # <<<<<<<<<<<<<< @@ -79999,7 +82088,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_RefNannySetupContext("getScalarList", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":3895 + /* "PyCafe.pyx":3985 * cacheFlag: bool = False, dictFlag: bool = False): * ################################################################################## * cdef str _METHOD = "getScalarList(handleList, str dt, bint cacheFlag)" # <<<<<<<<<<<<<< @@ -80009,7 +82098,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_getScalarList_handleList_str_dt); __pyx_v__METHOD = __pyx_kp_u_getScalarList_handleList_str_dt; - /* "PyCafe.pyx":3899 + /* "PyCafe.pyx":3989 * # cdef float [::1] mvFloat #C-contiguous * * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -80020,20 +82109,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3900 + /* "PyCafe.pyx":3990 * * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def getScalarList. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3900, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3990, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 3900, __pyx_L1_error) + __PYX_ERR(3, 3990, __pyx_L1_error) - /* "PyCafe.pyx":3899 + /* "PyCafe.pyx":3989 * # cdef float [::1] mvFloat #C-contiguous * * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -80042,34 +82131,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":3903 + /* "PyCafe.pyx":3993 * 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)): */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3903, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3993, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyUnicode_Check(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3904 + /* "PyCafe.pyx":3994 * * 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\ */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3904, __pyx_L1_error) - __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3904, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 3994, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3994, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3903 + /* "PyCafe.pyx":3993 * First input argument, should be of handles or PVs") * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -80079,14 +82168,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC goto __pyx_L4; } - /* "PyCafe.pyx":3905 + /* "PyCafe.pyx":3995 * 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 of type if handles or if PVs") */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3905, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3995, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyInt_Check(__pyx_t_3); __pyx_t_4 = (__pyx_t_2 != 0); @@ -80103,20 +82192,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3906 + /* "PyCafe.pyx":3996 * 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 of type if handles or if PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3906, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3996, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 3906, __pyx_L1_error) + __PYX_ERR(3, 3996, __pyx_L1_error) - /* "PyCafe.pyx":3905 + /* "PyCafe.pyx":3995 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -80126,29 +82215,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __pyx_L4:; - /* "PyCafe.pyx":3909 + /* "PyCafe.pyx":3999 * First input argument, should be a 'list' of of type if handles or if PVs") * * nelemPrevious = [] # <<<<<<<<<<<<<< * * for i in range(0, len(handleList)): */ - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3909, __pyx_L1_error) + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3999, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_nelemPrevious = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3911 + /* "PyCafe.pyx":4001 * nelemPrevious = [] * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * nelemPrevious.append(self._c_cafe.setNelemToOne(handleList[i])) * */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3911, __pyx_L1_error) - __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3911, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4001, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3911, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -80156,16 +82245,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3911, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_6 = __pyx_t_3; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3911, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3911, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4001, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -80173,17 +82262,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3911, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4001, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3911, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3911, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4001, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3911, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -80193,7 +82282,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3911, __pyx_L1_error) + else __PYX_ERR(3, 4001, __pyx_L1_error) } break; } @@ -80202,23 +82291,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3912 + /* "PyCafe.pyx":4002 * * for i in range(0, len(handleList)): * nelemPrevious.append(self._c_cafe.setNelemToOne(handleList[i])) # <<<<<<<<<<<<<< * * # c=self.hh.getNelemClient(handleList[i]) */ - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3912, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4002, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3912, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4002, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->setNelemToOne(__pyx_t_8)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3912, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->setNelemToOne(__pyx_t_8)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4002, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_nelemPrevious, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 3912, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_nelemPrevious, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4002, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3911 + /* "PyCafe.pyx":4001 * nelemPrevious = [] * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -80228,37 +82317,37 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3925 + /* "PyCafe.pyx":4015 * cdef vector[int] vStatus * * v.reserve(len(handleList)) # <<<<<<<<<<<<<< * vStatus.reserve(len(handleList)) * */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3925, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4015, __pyx_L1_error) __pyx_v_v.reserve(__pyx_t_5); - /* "PyCafe.pyx":3926 + /* "PyCafe.pyx":4016 * * v.reserve(len(handleList)) * vStatus.reserve(len(handleList)) # <<<<<<<<<<<<<< * * for i in range(0, len(handleList)): */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3926, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4016, __pyx_L1_error) __pyx_v_vStatus.reserve(__pyx_t_5); - /* "PyCafe.pyx":3928 + /* "PyCafe.pyx":4018 * vStatus.reserve(len(handleList)) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3928, __pyx_L1_error) - __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3928, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4018, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3928, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -80266,16 +82355,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3928, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(PyList_CheckExact(__pyx_t_6)) || PyTuple_CheckExact(__pyx_t_6)) { __pyx_t_3 = __pyx_t_6; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3928, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3928, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4018, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; for (;;) { @@ -80283,17 +82372,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3928, __pyx_L1_error) + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4018, __pyx_L1_error) #else - __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3928, __pyx_L1_error) + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3928, __pyx_L1_error) + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_6); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4018, __pyx_L1_error) #else - __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3928, __pyx_L1_error) + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif } @@ -80303,7 +82392,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3928, __pyx_L1_error) + else __PYX_ERR(3, 4018, __pyx_L1_error) } break; } @@ -80312,25 +82401,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3930 + /* "PyCafe.pyx":4020 * for i in range(0, len(handleList)): * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) # <<<<<<<<<<<<<< * * cdef vector[int] vRB */ - __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3930, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4020, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3930, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4020, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; try { __pyx_v_v.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 3930, __pyx_L1_error) + __PYX_ERR(3, 4020, __pyx_L1_error) } - /* "PyCafe.pyx":3928 + /* "PyCafe.pyx":4018 * vStatus.reserve(len(handleList)) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -80340,7 +82429,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3933 + /* "PyCafe.pyx":4023 * * cdef vector[int] vRB * status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -80349,19 +82438,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":3937 + /* "PyCafe.pyx":4027 * cdef bytes bytesVal * * if (cacheFlag == False): # <<<<<<<<<<<<<< * # Need to copy to a vector since * # Coercion from Python not allowed without the GIL */ - __pyx_t_3 = PyObject_RichCompare(__pyx_v_cacheFlag, Py_False, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3937, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3937, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_cacheFlag, Py_False, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4027, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4027, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_2) { - /* "PyCafe.pyx":3940 + /* "PyCafe.pyx":4030 * # Need to copy to a vector since * # Coercion from Python not allowed without the GIL * with nogil: # <<<<<<<<<<<<<< @@ -80376,7 +82465,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":3941 + /* "PyCafe.pyx":4031 * # Coercion from Python not allowed without the GIL * with nogil: * status = self._c_cafe.getV(v, vStatus) # <<<<<<<<<<<<<< @@ -80386,7 +82475,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_v_status = __pyx_v_self->_c_cafe->getV(__pyx_v_v, __pyx_v_vStatus); } - /* "PyCafe.pyx":3940 + /* "PyCafe.pyx":4030 * # Need to copy to a vector since * # Coercion from Python not allowed without the GIL * with nogil: # <<<<<<<<<<<<<< @@ -80405,7 +82494,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":3953 + /* "PyCafe.pyx":4043 * # Functionality not yet moved to CAFE:: * # Required for when dt='native' * if (status != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -80415,20 +82504,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3954 + /* "PyCafe.pyx":4044 * # 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 */ - __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4044, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -80436,16 +82525,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_6 = __pyx_t_3; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4044, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -80453,17 +82542,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4044, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4044, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3954, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -80473,7 +82562,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3954, __pyx_L1_error) + else __PYX_ERR(3, 4044, __pyx_L1_error) } break; } @@ -80482,27 +82571,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3955 + /* "PyCafe.pyx":4045 * 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)): */ - __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3955, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4045, __pyx_L1_error) __pyx_t_2 = (((__pyx_v_vStatus[__pyx_t_10]) == ICAFE_WAITING_FOR_PREV_CALLBACK) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3957 + /* "PyCafe.pyx":4047 * 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): */ - __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_v_i, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3957, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_v_i, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3957, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -80510,16 +82599,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3957, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_11 = __pyx_t_3; __Pyx_INCREF(__pyx_t_11); __pyx_t_12 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_12 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3957, __pyx_L1_error) + __pyx_t_12 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_13 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 3957, __pyx_L1_error) + __pyx_t_13 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 4047, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -80527,17 +82616,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_11))) { if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(3, 3957, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(3, 4047, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3957, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(3, 3957, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(3, 4047, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3957, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -80547,7 +82636,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3957, __pyx_L1_error) + else __PYX_ERR(3, 4047, __pyx_L1_error) } break; } @@ -80556,41 +82645,41 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_j, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3958 + /* "PyCafe.pyx":4048 * # getHandle * for j in range(0, (i-1)): * if(v[j] == v[i]): # <<<<<<<<<<<<<< * if (vStatus[j] == ICAFE_NORMAL): * vStatus[i] = vStatus[j] */ - __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3958, __pyx_L1_error) - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3958, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4048, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4048, __pyx_L1_error) __pyx_t_2 = (((__pyx_v_v[__pyx_t_14]) == (__pyx_v_v[__pyx_t_15])) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3959 + /* "PyCafe.pyx":4049 * for j in range(0, (i-1)): * if(v[j] == v[i]): * if (vStatus[j] == ICAFE_NORMAL): # <<<<<<<<<<<<<< * vStatus[i] = vStatus[j] * */ - __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3959, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4049, __pyx_L1_error) __pyx_t_2 = (((__pyx_v_vStatus[__pyx_t_10]) == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3960 + /* "PyCafe.pyx":4050 * if(v[j] == v[i]): * if (vStatus[j] == ICAFE_NORMAL): * vStatus[i] = vStatus[j] # <<<<<<<<<<<<<< * * # ca_poll() Not required as above will flush! */ - __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3960, __pyx_L1_error) - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3960, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_j); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4050, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4050, __pyx_L1_error) (__pyx_v_vStatus[__pyx_t_16]) = (__pyx_v_vStatus[__pyx_t_10]); - /* "PyCafe.pyx":3959 + /* "PyCafe.pyx":4049 * for j in range(0, (i-1)): * if(v[j] == v[i]): * if (vStatus[j] == ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -80599,7 +82688,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":3958 + /* "PyCafe.pyx":4048 * # getHandle * for j in range(0, (i-1)): * if(v[j] == v[i]): # <<<<<<<<<<<<<< @@ -80608,7 +82697,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":3957 + /* "PyCafe.pyx":4047 * if (vStatus[i] == ICAFE_WAITING_FOR_PREV_CALLBACK): * # getHandle * for j in range(0, (i-1)): # <<<<<<<<<<<<<< @@ -80618,7 +82707,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3955 + /* "PyCafe.pyx":4045 * if (status != ICAFE_NORMAL): * for i in range(0, len(vStatus)): * if (vStatus[i] == ICAFE_WAITING_FOR_PREV_CALLBACK): # <<<<<<<<<<<<<< @@ -80627,7 +82716,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":3954 + /* "PyCafe.pyx":4044 * # Required for when dt='native' * if (status != ICAFE_NORMAL): * for i in range(0, len(vStatus)): # <<<<<<<<<<<<<< @@ -80637,7 +82726,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3953 + /* "PyCafe.pyx":4043 * # Functionality not yet moved to CAFE:: * # Required for when dt='native' * if (status != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -80646,7 +82735,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":3965 + /* "PyCafe.pyx":4055 * # Wait for bundle * * with nogil: # <<<<<<<<<<<<<< @@ -80661,7 +82750,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":3966 + /* "PyCafe.pyx":4056 * * with nogil: * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) # <<<<<<<<<<<<<< @@ -80671,7 +82760,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_v_statusBundle = __pyx_v_self->_c_cafe->waitForBundledEvents(__pyx_v_v, __pyx_v_vRB); } - /* "PyCafe.pyx":3965 + /* "PyCafe.pyx":4055 * # Wait for bundle * * with nogil: # <<<<<<<<<<<<<< @@ -80690,7 +82779,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":3968 + /* "PyCafe.pyx":4058 * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) * * if (statusBundle != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -80700,7 +82789,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_statusBundle != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3969 + /* "PyCafe.pyx":4059 * * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -80710,18 +82799,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":3970 + /* "PyCafe.pyx":4060 * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def getScalarList: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(statusBundle) * */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3970, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4060, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":3971 + /* "PyCafe.pyx":4061 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def getScalarList: ") * self._c_cafe.printStatusMessage(statusBundle) # <<<<<<<<<<<<<< @@ -80730,7 +82819,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_statusBundle); - /* "PyCafe.pyx":3969 + /* "PyCafe.pyx":4059 * * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -80739,7 +82828,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":3968 + /* "PyCafe.pyx":4058 * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) * * if (statusBundle != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -80748,7 +82837,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":3937 + /* "PyCafe.pyx":4027 * cdef bytes bytesVal * * if (cacheFlag == False): # <<<<<<<<<<<<<< @@ -80757,7 +82846,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":3973 + /* "PyCafe.pyx":4063 * self._c_cafe.printStatusMessage(statusBundle) * * cdef unsigned int dtcheck = CAFE_NOT_REQUESTED # native type not yet know # <<<<<<<<<<<<<< @@ -80766,23 +82855,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_dtcheck = CAFE_NOT_REQUESTED; - /* "PyCafe.pyx":3974 + /* "PyCafe.pyx":4064 * * cdef unsigned int dtcheck = CAFE_NOT_REQUESTED # native type not yet know * dtcheck = getMatchedDataType(dt, dtcheck) # <<<<<<<<<<<<<< * * #print ("dt=", dt, "dtcheck=", dtcheck) */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtcheck); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3974, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtcheck); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_6); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3974, __pyx_L1_error) + __pyx_t_11 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_6); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3974, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4064, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_v_dtcheck = __pyx_t_8; - /* "PyCafe.pyx":3978 + /* "PyCafe.pyx":4068 * #print ("dt=", dt, "dtcheck=", dtcheck) * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -80792,7 +82881,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":3980 + /* "PyCafe.pyx":4070 * if dtcheck in [CAFE_STRING]: * * self.vStr.clear() # <<<<<<<<<<<<<< @@ -80801,17 +82890,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_self->vStr.clear(); - /* "PyCafe.pyx":3981 + /* "PyCafe.pyx":4071 * * self.vStr.clear() * self.vStr.reserve(len(handleList)) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3981, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4071, __pyx_L1_error) __pyx_v_self->vStr.reserve(__pyx_t_5); - /* "PyCafe.pyx":3983 + /* "PyCafe.pyx":4073 * self.vStr.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -80826,7 +82915,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":3984 + /* "PyCafe.pyx":4074 * * with nogil: * status = self._c_cafe.getCacheVStr(v, self.vStr, vStatus) # <<<<<<<<<<<<<< @@ -80836,7 +82925,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_v_status = __pyx_v_self->_c_cafe->getCacheVStr(__pyx_v_v, __pyx_v_self->vStr, __pyx_v_vStatus); } - /* "PyCafe.pyx":3983 + /* "PyCafe.pyx":4073 * self.vStr.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -80855,29 +82944,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":3987 + /* "PyCafe.pyx":4077 * * * localList=[] # <<<<<<<<<<<<<< * # statusList=[] * */ - __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3987, __pyx_L1_error) + __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4077, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_v_localList = ((PyObject*)__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3990 + /* "PyCafe.pyx":4080 * # statusList=[] * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 3990, __pyx_L1_error) - __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3990, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4080, __pyx_L1_error) + __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3990, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -80885,16 +82974,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3990, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) { __pyx_t_6 = __pyx_t_11; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 3990, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 3990, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4080, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; for (;;) { @@ -80902,17 +82991,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3990, __pyx_L1_error) + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4080, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3990, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 3990, __pyx_L1_error) + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4080, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3990, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } @@ -80922,7 +83011,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 3990, __pyx_L1_error) + else __PYX_ERR(3, 4080, __pyx_L1_error) } break; } @@ -80931,23 +83020,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3992 + /* "PyCafe.pyx":4082 * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) # <<<<<<<<<<<<<< * bytesVal = ( self.vStr[i] ) * encoding = False */ - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3992, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4082, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3992, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4082, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3992, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4082, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3992, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4082, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":3991 + /* "PyCafe.pyx":4081 * * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( # <<<<<<<<<<<<<< @@ -80956,15 +83045,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ (void)(__pyx_v_self->_c_cafe->setNelemToPrevious(__pyx_t_8, __pyx_t_17)); - /* "PyCafe.pyx":3993 + /* "PyCafe.pyx":4083 * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) * bytesVal = ( self.vStr[i] ) # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): */ - __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 3993, __pyx_L1_error) - __pyx_t_11 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_t_18]))); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 3993, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4083, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_t_18]))); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4083, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_3 = __pyx_t_11; __Pyx_INCREF(__pyx_t_3); @@ -80972,7 +83061,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "PyCafe.pyx":3994 + /* "PyCafe.pyx":4084 * handleList[i], nelemPrevious[i]) * bytesVal = ( self.vStr[i] ) * encoding = False # <<<<<<<<<<<<<< @@ -80981,25 +83070,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":3995 + /* "PyCafe.pyx":4085 * bytesVal = ( self.vStr[i] ) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3995, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4085, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3995, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4085, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_t_17)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3995, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_t_17)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4085, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 3995, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4085, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":3996 + /* "PyCafe.pyx":4086 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): * try: # <<<<<<<<<<<<<< @@ -81015,7 +83104,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_21); /*try:*/ { - /* "PyCafe.pyx":3997 + /* "PyCafe.pyx":4087 * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -81024,14 +83113,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 3997, __pyx_L34_error) + __PYX_ERR(3, 4087, __pyx_L34_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3997, __pyx_L34_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4087, __pyx_L34_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3998 + /* "PyCafe.pyx":4088 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -81040,7 +83129,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":3996 + /* "PyCafe.pyx":4086 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): * try: # <<<<<<<<<<<<<< @@ -81056,7 +83145,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":3999 + /* "PyCafe.pyx":4089 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -81071,7 +83160,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC goto __pyx_L36_except_error; __pyx_L36_except_error:; - /* "PyCafe.pyx":3996 + /* "PyCafe.pyx":4086 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): * try: # <<<<<<<<<<<<<< @@ -81091,7 +83180,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_L41_try_end:; } - /* "PyCafe.pyx":3995 + /* "PyCafe.pyx":4085 * bytesVal = ( self.vStr[i] ) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handleList[i]): # <<<<<<<<<<<<<< @@ -81100,7 +83189,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4001 + /* "PyCafe.pyx":4091 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -81110,7 +83199,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4002 + /* "PyCafe.pyx":4092 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -81126,7 +83215,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "PyCafe.pyx":4003 + /* "PyCafe.pyx":4093 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -81135,14 +83224,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4003, __pyx_L43_error) + __PYX_ERR(3, 4093, __pyx_L43_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4003, __pyx_L43_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4093, __pyx_L43_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4004 + /* "PyCafe.pyx":4094 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -81151,7 +83240,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4002 + /* "PyCafe.pyx":4092 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -81167,7 +83256,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4005 + /* "PyCafe.pyx":4095 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -81182,7 +83271,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC goto __pyx_L45_except_error; __pyx_L45_except_error:; - /* "PyCafe.pyx":4002 + /* "PyCafe.pyx":4092 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -81202,7 +83291,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_L50_try_end:; } - /* "PyCafe.pyx":4001 + /* "PyCafe.pyx":4091 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -81211,7 +83300,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4007 + /* "PyCafe.pyx":4097 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -81221,7 +83310,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4008 + /* "PyCafe.pyx":4098 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -81237,7 +83326,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_21); /*try:*/ { - /* "PyCafe.pyx":4009 + /* "PyCafe.pyx":4099 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -81246,14 +83335,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4009, __pyx_L52_error) + __PYX_ERR(3, 4099, __pyx_L52_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4009, __pyx_L52_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4099, __pyx_L52_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4010 + /* "PyCafe.pyx":4100 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -81262,7 +83351,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4008 + /* "PyCafe.pyx":4098 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -81278,7 +83367,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4011 + /* "PyCafe.pyx":4101 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -81293,7 +83382,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC goto __pyx_L54_except_error; __pyx_L54_except_error:; - /* "PyCafe.pyx":4008 + /* "PyCafe.pyx":4098 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -81313,7 +83402,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_L59_try_end:; } - /* "PyCafe.pyx":4007 + /* "PyCafe.pyx":4097 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -81322,7 +83411,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4013 + /* "PyCafe.pyx":4103 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -81332,20 +83421,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4014 + /* "PyCafe.pyx":4104 * pass * if not encoding: * strVal = self.vStr[i] # <<<<<<<<<<<<<< * * localList.append(strVal) */ - __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4014, __pyx_L1_error) - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_self->vStr[__pyx_t_18])); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4014, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4104, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_self->vStr[__pyx_t_18])); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4104, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4013 + /* "PyCafe.pyx":4103 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -81354,17 +83443,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4016 + /* "PyCafe.pyx":4106 * strVal = self.vStr[i] * * localList.append(strVal) # <<<<<<<<<<<<<< * * return localList, status, vStatus */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4016, __pyx_L1_error) } - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4016, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4106, __pyx_L1_error) } + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4106, __pyx_L1_error) - /* "PyCafe.pyx":3990 + /* "PyCafe.pyx":4080 * # statusList=[] * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -81374,7 +83463,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4018 + /* "PyCafe.pyx":4108 * localList.append(strVal) * * return localList, status, vStatus # <<<<<<<<<<<<<< @@ -81382,11 +83471,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4018, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4018, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4018, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -81401,7 +83490,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_11 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3978 + /* "PyCafe.pyx":4068 * #print ("dt=", dt, "dtcheck=", dtcheck) * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -81411,7 +83500,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; case CAFE_SHORT: - /* "PyCafe.pyx":4020 + /* "PyCafe.pyx":4110 * return localList, status, vStatus * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -81421,7 +83510,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC case CAFE_CHAR: case CAFE_LONG: - /* "PyCafe.pyx":4022 + /* "PyCafe.pyx":4112 * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: * * self.vInt.clear() # <<<<<<<<<<<<<< @@ -81430,17 +83519,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_self->vInt.clear(); - /* "PyCafe.pyx":4023 + /* "PyCafe.pyx":4113 * * self.vInt.clear() * self.vInt.reserve(len(handleList)) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4023, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4113, __pyx_L1_error) __pyx_v_self->vInt.reserve(__pyx_t_5); - /* "PyCafe.pyx":4025 + /* "PyCafe.pyx":4115 * self.vInt.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -81455,7 +83544,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":4026 + /* "PyCafe.pyx":4116 * * with nogil: * status = self._c_cafe.getCacheVLong(v, self.vInt, vStatus) # <<<<<<<<<<<<<< @@ -81465,7 +83554,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_v_status = __pyx_v_self->_c_cafe->getCacheVLong(__pyx_v_v, __pyx_v_self->vInt, __pyx_v_vStatus); } - /* "PyCafe.pyx":4025 + /* "PyCafe.pyx":4115 * self.vInt.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -81484,17 +83573,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":4031 + /* "PyCafe.pyx":4121 * #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]) */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4031, __pyx_L1_error) - __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4031, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4121, __pyx_L1_error) + __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4031, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -81502,16 +83591,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4031, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) { __pyx_t_3 = __pyx_t_11; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4031, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4031, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4121, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; for (;;) { @@ -81519,17 +83608,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4031, __pyx_L1_error) + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4121, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4031, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4031, __pyx_L1_error) + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4121, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4031, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } @@ -81539,7 +83628,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 4031, __pyx_L1_error) + else __PYX_ERR(3, 4121, __pyx_L1_error) } break; } @@ -81548,23 +83637,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4033 + /* "PyCafe.pyx":4123 * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) # <<<<<<<<<<<<<< * * # localList=[] */ - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4033, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4033, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4033, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4033, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4032 + /* "PyCafe.pyx":4122 * * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( # <<<<<<<<<<<<<< @@ -81573,7 +83662,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ (void)(__pyx_v_self->_c_cafe->setNelemToPrevious(__pyx_t_17, __pyx_t_8)); - /* "PyCafe.pyx":4031 + /* "PyCafe.pyx":4121 * #print ("status " , vStatus[i], " i", i, self._c_cafe.getPVFromHandle(handleList[i])) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -81583,7 +83672,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4039 + /* "PyCafe.pyx":4129 * * # for i in range(0, len(self.vInt)): * return self.vInt, status, vStatus # <<<<<<<<<<<<<< @@ -81591,13 +83680,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_convert_vector_to_py_dbr_long_t(__pyx_v_self->vInt); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4039, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_dbr_long_t(__pyx_v_self->vInt); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4039, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4039, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_23 = PyTuple_New(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4039, __pyx_L1_error) + __pyx_t_23 = PyTuple_New(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_3); @@ -81612,7 +83701,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_23 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4020 + /* "PyCafe.pyx":4110 * return localList, status, vStatus * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -81622,7 +83711,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; case CAFE_FLOAT: - /* "PyCafe.pyx":4041 + /* "PyCafe.pyx":4131 * return self.vInt, status, vStatus * * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -81631,7 +83720,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ case CAFE_DOUBLE: - /* "PyCafe.pyx":4043 + /* "PyCafe.pyx":4133 * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: * * self.vFloat.clear() # <<<<<<<<<<<<<< @@ -81640,17 +83729,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_self->vFloat.clear(); - /* "PyCafe.pyx":4044 + /* "PyCafe.pyx":4134 * * self.vFloat.clear() * self.vFloat.reserve(len(handleList)) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4044, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4134, __pyx_L1_error) __pyx_v_self->vFloat.reserve(__pyx_t_5); - /* "PyCafe.pyx":4046 + /* "PyCafe.pyx":4136 * self.vFloat.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -81665,7 +83754,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":4047 + /* "PyCafe.pyx":4137 * * with nogil: * status = self._c_cafe.getCacheVDouble(v, self.vFloat, vStatus) # <<<<<<<<<<<<<< @@ -81675,7 +83764,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_v_status = __pyx_v_self->_c_cafe->getCacheVDouble(__pyx_v_v, __pyx_v_self->vFloat, __pyx_v_vStatus); } - /* "PyCafe.pyx":4046 + /* "PyCafe.pyx":4136 * self.vFloat.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -81694,17 +83783,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":4049 + /* "PyCafe.pyx":4139 * status = self._c_cafe.getCacheVDouble(v, self.vFloat, vStatus) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4049, __pyx_L1_error) - __pyx_t_23 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4049, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4139, __pyx_L1_error) + __pyx_t_23 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4049, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -81712,16 +83801,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_23); __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4049, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_23)) || PyTuple_CheckExact(__pyx_t_23)) { __pyx_t_6 = __pyx_t_23; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_23); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4049, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_23); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4049, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4139, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; for (;;) { @@ -81729,17 +83818,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_23 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_23); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4049, __pyx_L1_error) + __pyx_t_23 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_23); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4139, __pyx_L1_error) #else - __pyx_t_23 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4049, __pyx_L1_error) + __pyx_t_23 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_23 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_23); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4049, __pyx_L1_error) + __pyx_t_23 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_23); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4139, __pyx_L1_error) #else - __pyx_t_23 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4049, __pyx_L1_error) + __pyx_t_23 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); #endif } @@ -81749,7 +83838,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 4049, __pyx_L1_error) + else __PYX_ERR(3, 4139, __pyx_L1_error) } break; } @@ -81758,23 +83847,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":4051 + /* "PyCafe.pyx":4141 * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) # <<<<<<<<<<<<<< * * #for i in range(0, len(vStatus)): */ - __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4051, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4051, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4141, __pyx_L1_error) __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4051, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4051, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4141, __pyx_L1_error) __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":4050 + /* "PyCafe.pyx":4140 * * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious( # <<<<<<<<<<<<<< @@ -81783,7 +83872,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ (void)(__pyx_v_self->_c_cafe->setNelemToPrevious(__pyx_t_8, __pyx_t_17)); - /* "PyCafe.pyx":4049 + /* "PyCafe.pyx":4139 * status = self._c_cafe.getCacheVDouble(v, self.vFloat, vStatus) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -81793,7 +83882,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4066 + /* "PyCafe.pyx":4156 * * # for i in range(0, len(self.vFloat)): * return self.vFloat, status, vStatus # <<<<<<<<<<<<<< @@ -81801,13 +83890,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC * # Native */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __pyx_convert_vector_to_py_double(__pyx_v_self->vFloat); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4066, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_vector_to_py_double(__pyx_v_self->vFloat); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_23 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4066, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_11 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4066, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4066, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); @@ -81822,7 +83911,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4041 + /* "PyCafe.pyx":4131 * return self.vInt, status, vStatus * * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -81833,7 +83922,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC default: break; } - /* "PyCafe.pyx":4078 + /* "PyCafe.pyx":4168 * * * cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) # <<<<<<<<<<<<<< @@ -81842,16 +83931,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_pvd = __pyx_v_self->_c_cafe->getPVData(__pyx_v_v); - /* "PyCafe.pyx":4093 + /* "PyCafe.pyx":4183 * * # Required to allocate memory for shared pointer * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< * pvd[i].setNelem(1) * */ - __pyx_t_3 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4093, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4093, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -81859,16 +83948,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4093, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_11 = __pyx_t_3; __Pyx_INCREF(__pyx_t_11); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4093, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_7 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4093, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4183, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -81876,17 +83965,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_11))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4093, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4183, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4093, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4093, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4183, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4093, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -81896,7 +83985,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 4093, __pyx_L1_error) + else __PYX_ERR(3, 4183, __pyx_L1_error) } break; } @@ -81905,17 +83994,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4094 + /* "PyCafe.pyx":4184 * # Required to allocate memory for shared pointer * for i in range(0, v.size()): #len(handleList)): * pvd[i].setNelem(1) # <<<<<<<<<<<<<< * * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4094, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4184, __pyx_L1_error) (void)((__pyx_v_pvd[__pyx_t_12]).setNelem(1)); - /* "PyCafe.pyx":4093 + /* "PyCafe.pyx":4183 * * # Required to allocate memory for shared pointer * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -81925,7 +84014,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4096 + /* "PyCafe.pyx":4186 * pvd[i].setNelem(1) * * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) # <<<<<<<<<<<<<< @@ -81934,17 +84023,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_statusNoWait = __pyx_v_self->_c_cafe->getCachePVArrayNoWait(__pyx_v_v, __pyx_v_pvd); - /* "PyCafe.pyx":4098 + /* "PyCafe.pyx":4188 * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * self._c_cafe.setNelemToPrevious(handleList[i], nelemPrevious[i]) * */ - __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4098, __pyx_L1_error) - __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_5 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4188, __pyx_L1_error) + __pyx_t_11 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -81952,16 +84041,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) { __pyx_t_3 = __pyx_t_11; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4188, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; for (;;) { @@ -81969,17 +84058,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4188, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4188, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4098, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } @@ -81989,7 +84078,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 4098, __pyx_L1_error) + else __PYX_ERR(3, 4188, __pyx_L1_error) } break; } @@ -81998,24 +84087,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4099 + /* "PyCafe.pyx":4189 * * for i in range(0, len(handleList)): * self._c_cafe.setNelemToPrevious(handleList[i], nelemPrevious[i]) # <<<<<<<<<<<<<< * * statusList = [] */ - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4099, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4099, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4189, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4099, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_v_nelemPrevious, __pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4099, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4189, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; (void)(__pyx_v_self->_c_cafe->setNelemToPrevious(__pyx_t_17, __pyx_t_8)); - /* "PyCafe.pyx":4098 + /* "PyCafe.pyx":4188 * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -82025,19 +84114,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4101 + /* "PyCafe.pyx":4191 * self._c_cafe.setNelemToPrevious(handleList[i], nelemPrevious[i]) * * statusList = [] # <<<<<<<<<<<<<< * statusFlag = True * statusLocal = ICAFE_NORMAL */ - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4101, __pyx_L1_error) + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4191, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_statusList = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4102 + /* "PyCafe.pyx":4192 * * statusList = [] * statusFlag = True # <<<<<<<<<<<<<< @@ -82046,28 +84135,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_statusFlag = 1; - /* "PyCafe.pyx":4103 + /* "PyCafe.pyx":4193 * statusList = [] * statusFlag = True * statusLocal = ICAFE_NORMAL # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4103, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_statusLocal = __pyx_t_3; __pyx_t_3 = 0; - /* "PyCafe.pyx":4114 + /* "PyCafe.pyx":4204 * # self._c_cafe.printStatusMessage(status) * # status=ICAFE_NORMAL * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< * statusList.append(pvd[i].getStatus()) * if pvd[i].getStatus() != ICAFE_NORMAL: */ - __pyx_t_3 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4114, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4114, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -82075,16 +84164,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4114, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_11 = __pyx_t_3; __Pyx_INCREF(__pyx_t_11); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4114, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_7 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4114, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4204, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -82092,17 +84181,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_11))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4114, __pyx_L1_error) + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4204, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4114, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_11)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4114, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4204, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4114, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } @@ -82112,7 +84201,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 4114, __pyx_L1_error) + else __PYX_ERR(3, 4204, __pyx_L1_error) } break; } @@ -82121,41 +84210,41 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4115 + /* "PyCafe.pyx":4205 * # status=ICAFE_NORMAL * for i in range(0, v.size()): #len(handleList)): * statusList.append(pvd[i].getStatus()) # <<<<<<<<<<<<<< * if pvd[i].getStatus() != ICAFE_NORMAL: * print("Error in Element ", i, " from ", len( */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4115, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4115, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4205, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4115, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4205, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4116 + /* "PyCafe.pyx":4206 * for i in range(0, v.size()): #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") */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4116, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4206, __pyx_L1_error) __pyx_t_1 = (((__pyx_v_pvd[__pyx_t_12]).getStatus() != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4117 + /* "PyCafe.pyx":4207 * 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=", */ - __pyx_t_12 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4117, __pyx_L1_error) - __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4117, __pyx_L1_error) + __pyx_t_12 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4207, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_23 = PyTuple_New(5); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4117, __pyx_L1_error) + __pyx_t_23 = PyTuple_New(5); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_INCREF(__pyx_kp_u_Error_in_Element); __Pyx_GIVEREF(__pyx_kp_u_Error_in_Element); @@ -82172,43 +84261,43 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_kp_u_in_PyCafe_def_getScalarList); PyTuple_SET_ITEM(__pyx_t_23, 4, __pyx_kp_u_in_PyCafe_def_getScalarList); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4117, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4119 + /* "PyCafe.pyx":4209 * 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()) */ - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4119, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "PyCafe.pyx":4120 + /* "PyCafe.pyx":4210 * 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()) */ - __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4120, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_GetItem(__pyx_v_handleList, __pyx_v_i); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4120, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_23); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4210, __pyx_L1_error) __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_8)); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4120, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_8)); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - /* "PyCafe.pyx":4119 + /* "PyCafe.pyx":4209 * 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()) */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4119, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_kp_u_Handle_2); __Pyx_GIVEREF(__pyx_kp_u_Handle_2); @@ -82222,22 +84311,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_23); __pyx_t_3 = 0; __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4119, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":4121 + /* "PyCafe.pyx":4211 * 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: */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4121, __pyx_L1_error) - __pyx_t_23 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4121, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4211, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4121, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_kp_u_with_error_status); __Pyx_GIVEREF(__pyx_kp_u_with_error_status); @@ -82245,22 +84334,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_23); __pyx_t_23 = 0; - __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4121, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":4122 + /* "PyCafe.pyx":4212 * 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() */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4122, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4212, __pyx_L1_error) __pyx_v_self->_c_cafe->printStatusMessage((__pyx_v_pvd[__pyx_t_12]).getStatus()); - /* "PyCafe.pyx":4123 + /* "PyCafe.pyx":4213 * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * if statusFlag: # <<<<<<<<<<<<<< @@ -82270,20 +84359,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_1 = (__pyx_v_statusFlag != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4124 + /* "PyCafe.pyx":4214 * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * if statusFlag: * statusLocal = pvd[i].getStatus() # <<<<<<<<<<<<<< * statusFlag = False * */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4124, __pyx_L1_error) - __pyx_t_23 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4124, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4214, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getStatus()); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_DECREF_SET(__pyx_v_statusLocal, __pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":4125 + /* "PyCafe.pyx":4215 * if statusFlag: * statusLocal = pvd[i].getStatus() * statusFlag = False # <<<<<<<<<<<<<< @@ -82292,7 +84381,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_statusFlag = 0; - /* "PyCafe.pyx":4123 + /* "PyCafe.pyx":4213 * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * if statusFlag: # <<<<<<<<<<<<<< @@ -82301,7 +84390,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4116 + /* "PyCafe.pyx":4206 * for i in range(0, v.size()): #len(handleList)): * statusList.append(pvd[i].getStatus()) * if pvd[i].getStatus() != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -82310,7 +84399,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4114 + /* "PyCafe.pyx":4204 * # self._c_cafe.printStatusMessage(status) * # status=ICAFE_NORMAL * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -82320,28 +84409,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4135 + /* "PyCafe.pyx":4225 * cdef unsigned int dtn * * localList = [] # <<<<<<<<<<<<<< * * */ - __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4135, __pyx_L1_error) + __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_v_localList = ((PyObject*)__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4138 + /* "PyCafe.pyx":4228 * * * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< * * dtn = pvd[i].getDataType() */ - __pyx_t_11 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4138, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int(((int)__pyx_v_v.size())); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4138, __pyx_L1_error) + __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); @@ -82349,16 +84438,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_23, 1, __pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_23, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4138, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_23, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) { __pyx_t_23 = __pyx_t_11; __Pyx_INCREF(__pyx_t_23); __pyx_t_5 = 0; __pyx_t_7 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_23 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4138, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_23 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_7 = Py_TYPE(__pyx_t_23)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4138, __pyx_L1_error) + __pyx_t_7 = Py_TYPE(__pyx_t_23)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4228, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; for (;;) { @@ -82366,17 +84455,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC if (likely(PyList_CheckExact(__pyx_t_23))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_23)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyList_GET_ITEM(__pyx_t_23, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4138, __pyx_L1_error) + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_23, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4228, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_23, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4138, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_23, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_23)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_23, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4138, __pyx_L1_error) + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_23, __pyx_t_5); __Pyx_INCREF(__pyx_t_11); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(3, 4228, __pyx_L1_error) #else - __pyx_t_11 = PySequence_ITEM(__pyx_t_23, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4138, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(__pyx_t_23, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif } @@ -82386,7 +84475,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(3, 4138, __pyx_L1_error) + else __PYX_ERR(3, 4228, __pyx_L1_error) } break; } @@ -82395,33 +84484,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4140 + /* "PyCafe.pyx":4230 * for i in range(0, v.size()): #len(handleList)): * * dtn = pvd[i].getDataType() # <<<<<<<<<<<<<< * dtcheck = getMatchedDataType(dt, dtn) * */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4140, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4230, __pyx_L1_error) __pyx_v_dtn = (__pyx_v_pvd[__pyx_t_12]).getDataType(); - /* "PyCafe.pyx":4141 + /* "PyCafe.pyx":4231 * * dtn = pvd[i].getDataType() * dtcheck = getMatchedDataType(dt, dtn) # <<<<<<<<<<<<<< * * #print ("dt=", dt, "dtn=", dtn, "dtcheck=", dtcheck) */ - __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4141, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4141, __pyx_L1_error) + __pyx_t_6 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4141, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4231, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_dtcheck = __pyx_t_8; - /* "PyCafe.pyx":4147 + /* "PyCafe.pyx":4237 * #print (pvd[i].getAsDouble()) * * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -82431,15 +84520,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":4149 + /* "PyCafe.pyx":4239 * if dtcheck == CAFE_STRING: * * bytesVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4149, __pyx_L1_error) - __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4149, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4239, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_11 = __pyx_t_6; __Pyx_INCREF(__pyx_t_11); @@ -82447,7 +84536,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_11)); __pyx_t_11 = 0; - /* "PyCafe.pyx":4150 + /* "PyCafe.pyx":4240 * * bytesVal = pvd[i].getAsString() * encoding = False # <<<<<<<<<<<<<< @@ -82456,22 +84545,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":4151 + /* "PyCafe.pyx":4241 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4151, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_t_15]))); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4151, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4241, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_t_15]))); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_11, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4151, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_11, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4241, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4152 + /* "PyCafe.pyx":4242 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -82487,7 +84576,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "PyCafe.pyx":4153 + /* "PyCafe.pyx":4243 * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -82496,14 +84585,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4153, __pyx_L82_error) + __PYX_ERR(3, 4243, __pyx_L82_error) } - __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4153, __pyx_L82_error) + __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4243, __pyx_L82_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4154 + /* "PyCafe.pyx":4244 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -82512,7 +84601,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4152 + /* "PyCafe.pyx":4242 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -82529,7 +84618,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4155 + /* "PyCafe.pyx":4245 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -82544,7 +84633,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC goto __pyx_L84_except_error; __pyx_L84_except_error:; - /* "PyCafe.pyx":4152 + /* "PyCafe.pyx":4242 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -82564,7 +84653,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_L89_try_end:; } - /* "PyCafe.pyx":4151 + /* "PyCafe.pyx":4241 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< @@ -82573,7 +84662,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4157 + /* "PyCafe.pyx":4247 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -82583,7 +84672,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4158 + /* "PyCafe.pyx":4248 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -82599,7 +84688,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_21); /*try:*/ { - /* "PyCafe.pyx":4159 + /* "PyCafe.pyx":4249 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -82608,14 +84697,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4159, __pyx_L91_error) + __PYX_ERR(3, 4249, __pyx_L91_error) } - __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4159, __pyx_L91_error) + __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4249, __pyx_L91_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4160 + /* "PyCafe.pyx":4250 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -82624,7 +84713,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4158 + /* "PyCafe.pyx":4248 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -82641,7 +84730,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4161 + /* "PyCafe.pyx":4251 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -82656,7 +84745,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC goto __pyx_L93_except_error; __pyx_L93_except_error:; - /* "PyCafe.pyx":4158 + /* "PyCafe.pyx":4248 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -82676,7 +84765,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_L98_try_end:; } - /* "PyCafe.pyx":4157 + /* "PyCafe.pyx":4247 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -82685,7 +84774,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4163 + /* "PyCafe.pyx":4253 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -82695,7 +84784,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4164 + /* "PyCafe.pyx":4254 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -82711,7 +84800,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "PyCafe.pyx":4165 + /* "PyCafe.pyx":4255 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -82720,14 +84809,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4165, __pyx_L100_error) + __PYX_ERR(3, 4255, __pyx_L100_error) } - __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4165, __pyx_L100_error) + __pyx_t_11 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4255, __pyx_L100_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4166 + /* "PyCafe.pyx":4256 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -82736,7 +84825,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4164 + /* "PyCafe.pyx":4254 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -82753,7 +84842,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4167 + /* "PyCafe.pyx":4257 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -82768,7 +84857,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC goto __pyx_L102_except_error; __pyx_L102_except_error:; - /* "PyCafe.pyx":4164 + /* "PyCafe.pyx":4254 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -82788,7 +84877,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_L107_try_end:; } - /* "PyCafe.pyx":4163 + /* "PyCafe.pyx":4253 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -82797,7 +84886,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4169 + /* "PyCafe.pyx":4259 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -82807,20 +84896,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4170 + /* "PyCafe.pyx":4260 * pass * if not encoding: * strVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * * localList.append(strVal) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4170, __pyx_L1_error) - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4170, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4260, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4169 + /* "PyCafe.pyx":4259 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -82829,17 +84918,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4172 + /* "PyCafe.pyx":4262 * strVal = pvd[i].getAsString() * * localList.append(strVal) # <<<<<<<<<<<<<< * * elif dtcheck == CAFE_SHORT: */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4172, __pyx_L1_error) } - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4172, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4262, __pyx_L1_error) } + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4262, __pyx_L1_error) - /* "PyCafe.pyx":4147 + /* "PyCafe.pyx":4237 * #print (pvd[i].getAsDouble()) * * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -82849,20 +84938,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; case CAFE_SHORT: - /* "PyCafe.pyx":4175 + /* "PyCafe.pyx":4265 * * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4175, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4175, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4265, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4175, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4265, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4174 + /* "PyCafe.pyx":4264 * localList.append(strVal) * * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -82872,20 +84961,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; case CAFE_FLOAT: - /* "PyCafe.pyx":4177 + /* "PyCafe.pyx":4267 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4177, __pyx_L1_error) - __pyx_t_11 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_t_12]).getAsDouble()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4177, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4267, __pyx_L1_error) + __pyx_t_11 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_t_12]).getAsDouble()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4177, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4267, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4176 + /* "PyCafe.pyx":4266 * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -82895,31 +84984,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; case CAFE_ENUM: - /* "PyCafe.pyx":4181 + /* "PyCafe.pyx":4271 * # if enum, string taken as native * * if self._c_cafe.isEnum(self.hh.getHandleFromPV(pvd[i].getPVName())): # <<<<<<<<<<<<<< * localList.append(pvd[i].getAsString()) * else: */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4181, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4271, __pyx_L1_error) __pyx_t_2 = (__pyx_v_self->_c_cafe->isEnum(__pyx_v_self->hh.getHandleFromPV((__pyx_v_pvd[__pyx_t_12]).getPVName())) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4182 + /* "PyCafe.pyx":4272 * * if self._c_cafe.isEnum(self.hh.getHandleFromPV(pvd[i].getPVName())): * localList.append(pvd[i].getAsString()) # <<<<<<<<<<<<<< * else: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4182, __pyx_L1_error) - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4182, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4272, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_t_12]).getAsString()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4182, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4272, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4181 + /* "PyCafe.pyx":4271 * # if enum, string taken as native * * if self._c_cafe.isEnum(self.hh.getHandleFromPV(pvd[i].getPVName())): # <<<<<<<<<<<<<< @@ -82929,7 +85018,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC goto __pyx_L109; } - /* "PyCafe.pyx":4184 + /* "PyCafe.pyx":4274 * localList.append(pvd[i].getAsString()) * else: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< @@ -82937,15 +85026,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC * elif dtcheck == CAFE_CHAR: */ /*else*/ { - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4184, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4184, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4274, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4184, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4274, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __pyx_L109:; - /* "PyCafe.pyx":4178 + /* "PyCafe.pyx":4268 * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -82955,20 +85044,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; case CAFE_CHAR: - /* "PyCafe.pyx":4188 + /* "PyCafe.pyx":4278 * elif dtcheck == CAFE_CHAR: * # pvd[i].getAsChar() * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4188, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4188, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4278, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4188, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4278, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4186 + /* "PyCafe.pyx":4276 * localList.append(pvd[i].getAsLong()) * * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -82978,20 +85067,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; case CAFE_LONG: - /* "PyCafe.pyx":4190 + /* "PyCafe.pyx":4280 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4190, __pyx_L1_error) - __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4190, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4280, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_t_12]).getAsLong()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4280, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4190, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4280, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4189 + /* "PyCafe.pyx":4279 * # pvd[i].getAsChar() * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -83001,20 +85090,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; case CAFE_DOUBLE: - /* "PyCafe.pyx":4192 + /* "PyCafe.pyx":4282 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * else: * localList.append(0) */ - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4192, __pyx_L1_error) - __pyx_t_11 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_t_12]).getAsDouble()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4192, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 4282, __pyx_L1_error) + __pyx_t_11 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_t_12]).getAsDouble()); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4192, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_11); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4282, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4191 + /* "PyCafe.pyx":4281 * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -83024,16 +85113,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; default: - /* "PyCafe.pyx":4194 + /* "PyCafe.pyx":4284 * localList.append(pvd[i].getAsDouble()) * else: * localList.append(0) # <<<<<<<<<<<<<< * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: * print("def getScalarList:") */ - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4194, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(3, 4284, __pyx_L1_error) - /* "PyCafe.pyx":4195 + /* "PyCafe.pyx":4285 * else: * localList.append(0) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: # <<<<<<<<<<<<<< @@ -83043,25 +85132,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_HIGH) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4196 + /* "PyCafe.pyx":4286 * localList.append(0) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: * print("def getScalarList:") # <<<<<<<<<<<<<< * print("Entering 0 for element", i, * "as channel is not connected!") */ - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__77, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4196, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__77, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":4197 + /* "PyCafe.pyx":4287 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: * print("def getScalarList:") * print("Entering 0 for element", i, # <<<<<<<<<<<<<< * "as channel is not connected!") * */ - __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4197, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_kp_u_Entering_0_for_element); __Pyx_GIVEREF(__pyx_kp_u_Entering_0_for_element); @@ -83072,12 +85161,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_as_channel_is_not_connected); __Pyx_GIVEREF(__pyx_kp_u_as_channel_is_not_connected); PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_kp_u_as_channel_is_not_connected); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4197, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4195 + /* "PyCafe.pyx":4285 * else: * localList.append(0) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: # <<<<<<<<<<<<<< @@ -83088,7 +85177,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC break; } - /* "PyCafe.pyx":4138 + /* "PyCafe.pyx":4228 * * * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -83098,19 +85187,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC } __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; - /* "PyCafe.pyx":4203 + /* "PyCafe.pyx":4293 * * # free(pvd) * if (cacheFlag == True): # <<<<<<<<<<<<<< * return localList, statusLocal, statusList * */ - __pyx_t_23 = PyObject_RichCompare(__pyx_v_cacheFlag, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_23); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4203, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_23); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4203, __pyx_L1_error) + __pyx_t_23 = PyObject_RichCompare(__pyx_v_cacheFlag, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_23); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4293, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_23); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4293, __pyx_L1_error) __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; if (__pyx_t_2) { - /* "PyCafe.pyx":4204 + /* "PyCafe.pyx":4294 * # free(pvd) * if (cacheFlag == True): * return localList, statusLocal, statusList # <<<<<<<<<<<<<< @@ -83118,7 +85207,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC * # use vstatus instead of statusList (as cache is NoWait) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_23 = PyTuple_New(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4204, __pyx_L1_error) + __pyx_t_23 = PyTuple_New(3); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -83133,7 +85222,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_23 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4203 + /* "PyCafe.pyx":4293 * * # free(pvd) * if (cacheFlag == True): # <<<<<<<<<<<<<< @@ -83142,7 +85231,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4207 + /* "PyCafe.pyx":4297 * * # use vstatus instead of statusList (as cache is NoWait) * return localList, statusNoWait, vStatus # <<<<<<<<<<<<<< @@ -83150,11 +85239,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_23 = __Pyx_PyInt_From_int(__pyx_v_statusNoWait); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4207, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_From_int(__pyx_v_statusNoWait); if (unlikely(!__pyx_t_23)) __PYX_ERR(3, 4297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_23); - __pyx_t_6 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4207, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4207, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 4297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -83169,7 +85258,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC __pyx_t_11 = 0; goto __pyx_L0; - /* "PyCafe.pyx":3892 + /* "PyCafe.pyx":3982 * * ################################################################################## * def getScalarList(self, handleList, dt: str = 'native', # <<<<<<<<<<<<<< @@ -83203,7 +85292,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_292getScalarList(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":4215 +/* "PyCafe.pyx":4305 * * * def getDictionary(self, pvhandleList, dt: str = 'native', cacheFlag: bool = False, # <<<<<<<<<<<<<< @@ -83227,7 +85316,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_295getDictionary(PyObject *__pyx_v_sel values[1] = ((PyObject*)__pyx_n_u_native); values[2] = ((PyObject *)Py_False); - /* "PyCafe.pyx":4216 + /* "PyCafe.pyx":4306 * * def getDictionary(self, pvhandleList, dt: str = 'native', cacheFlag: bool = False, * scalarOnly: bool = False): # <<<<<<<<<<<<<< @@ -83275,7 +85364,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_295getDictionary(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getDictionary") < 0)) __PYX_ERR(3, 4215, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getDictionary") < 0)) __PYX_ERR(3, 4305, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -83297,16 +85386,16 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_295getDictionary(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getDictionary", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4215, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getDictionary", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4305, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getDictionary", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4215, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4305, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_294getDictionary(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_pvhandleList, __pyx_v_dt, __pyx_v_cacheFlag, __pyx_v_scalarOnly); - /* "PyCafe.pyx":4215 + /* "PyCafe.pyx":4305 * * * def getDictionary(self, pvhandleList, dt: str = 'native', cacheFlag: bool = False, # <<<<<<<<<<<<<< @@ -83351,7 +85440,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC unsigned int __pyx_t_14; __Pyx_RefNannySetupContext("getDictionary", 0); - /* "PyCafe.pyx":4217 + /* "PyCafe.pyx":4307 * def getDictionary(self, pvhandleList, dt: str = 'native', cacheFlag: bool = False, * scalarOnly: bool = False): * cdef str _METHOD = "getDictionary(handleList, dt, cacheFlag )" # <<<<<<<<<<<<<< @@ -83361,7 +85450,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_getDictionary_handleList_dt_cach); __pyx_v__METHOD = __pyx_kp_u_getDictionary_handleList_dt_cach; - /* "PyCafe.pyx":4219 + /* "PyCafe.pyx":4309 * cdef str _METHOD = "getDictionary(handleList, dt, cacheFlag )" * * pvList = None # <<<<<<<<<<<<<< @@ -83371,7 +85460,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_INCREF(Py_None); __pyx_v_pvList = Py_None; - /* "PyCafe.pyx":4220 + /* "PyCafe.pyx":4310 * * pvList = None * handleList = pvhandleList # <<<<<<<<<<<<<< @@ -83381,7 +85470,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_v_pvhandleList); __pyx_v_handleList = __pyx_v_pvhandleList; - /* "PyCafe.pyx":4222 + /* "PyCafe.pyx":4312 * handleList = pvhandleList * * if isinstance(handleList, (str)): # <<<<<<<<<<<<<< @@ -83392,14 +85481,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4223 + /* "PyCafe.pyx":4313 * * if isinstance(handleList, (str)): * handleList = self.getHandlesFromWithinGroup(handleList) # <<<<<<<<<<<<<< * if not handleList: * raise Exception(("EXCEPTION RAISED IN PyCafe def getDictionary. \n" + */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4223, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -83413,37 +85502,37 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_handleList) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_handleList); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4223, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4224 + /* "PyCafe.pyx":4314 * if isinstance(handleList, (str)): * handleList = self.getHandlesFromWithinGroup(handleList) * if not handleList: # <<<<<<<<<<<<<< * raise Exception(("EXCEPTION RAISED IN PyCafe def getDictionary. \n" + * "First input argument should be " + */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_handleList); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4224, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_handleList); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4314, __pyx_L1_error) __pyx_t_1 = ((!__pyx_t_2) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4225 + /* "PyCafe.pyx":4315 * handleList = self.getHandlesFromWithinGroup(handleList) * if not handleList: * raise Exception(("EXCEPTION RAISED IN PyCafe def getDictionary. \n" + # <<<<<<<<<<<<<< * "First input argument should be " + * "of handles or PVs\nelse for " + */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4225, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 4225, __pyx_L1_error) + __PYX_ERR(3, 4315, __pyx_L1_error) - /* "PyCafe.pyx":4224 + /* "PyCafe.pyx":4314 * if isinstance(handleList, (str)): * handleList = self.getHandlesFromWithinGroup(handleList) * if not handleList: # <<<<<<<<<<<<<< @@ -83452,7 +85541,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4222 + /* "PyCafe.pyx":4312 * handleList = pvhandleList * * if isinstance(handleList, (str)): # <<<<<<<<<<<<<< @@ -83462,7 +85551,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":4230 + /* "PyCafe.pyx":4320 * "CAFE 'group' name")) * else: * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -83474,20 +85563,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4231 + /* "PyCafe.pyx":4321 * else: * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def getCompoundList. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4231, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 4231, __pyx_L1_error) + __PYX_ERR(3, 4321, __pyx_L1_error) - /* "PyCafe.pyx":4230 + /* "PyCafe.pyx":4320 * "CAFE 'group' name")) * else: * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -83496,21 +85585,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4234 + /* "PyCafe.pyx":4324 * First input argument, should be of handles or PVs") * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< * pvList = handleList * handleList = self.checkForHandleList(handleList) */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4234, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyUnicode_Check(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4235 + /* "PyCafe.pyx":4325 * * if isinstance(handleList[0], (str)): * pvList = handleList # <<<<<<<<<<<<<< @@ -83520,20 +85609,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_v_handleList); __Pyx_DECREF_SET(__pyx_v_pvList, __pyx_v_handleList); - /* "PyCafe.pyx":4236 + /* "PyCafe.pyx":4326 * if isinstance(handleList[0], (str)): * pvList = handleList * handleList = self.checkForHandleList(handleList) # <<<<<<<<<<<<<< * elif not isinstance(handleList[0], (int, long)): * raise Exception("EXCEPTION RAISED IN PyCafe def getCompoundList. \n\ */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 4236, __pyx_L1_error) - __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4236, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 4326, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4234 + /* "PyCafe.pyx":4324 * First input argument, should be of handles or PVs") * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -83543,14 +85632,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC goto __pyx_L6; } - /* "PyCafe.pyx":4237 + /* "PyCafe.pyx":4327 * pvList = handleList * 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 of type if handles or if PVs") */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4237, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyInt_Check(__pyx_t_3); __pyx_t_6 = (__pyx_t_2 != 0); @@ -83567,20 +85656,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4238 + /* "PyCafe.pyx":4328 * 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 of type if handles or if PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4238, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 4238, __pyx_L1_error) + __PYX_ERR(3, 4328, __pyx_L1_error) - /* "PyCafe.pyx":4237 + /* "PyCafe.pyx":4327 * pvList = handleList * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -83590,24 +85679,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC } __pyx_L6:; - /* "PyCafe.pyx":4241 + /* "PyCafe.pyx":4331 * First input argument, should be a 'list' of of type if handles or if PVs") * * if scalarOnly: # <<<<<<<<<<<<<< * value, statusOverall, status =self.getScalarList(handleList, dt, cacheFlag) * else: */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_scalarOnly); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4241, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_scalarOnly); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4331, __pyx_L1_error) if (__pyx_t_2) { - /* "PyCafe.pyx":4242 + /* "PyCafe.pyx":4332 * * if scalarOnly: * value, statusOverall, status =self.getScalarList(handleList, dt, cacheFlag) # <<<<<<<<<<<<<< * else: * value, statusOverall, status =self.getCompoundList(handleList, dt, cacheFlag) */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getScalarList); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4242, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getScalarList); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_7 = 0; @@ -83624,7 +85713,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_v_handleList, __pyx_v_dt, __pyx_v_cacheFlag}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4242, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4332, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else @@ -83632,13 +85721,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_v_handleList, __pyx_v_dt, __pyx_v_cacheFlag}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4242, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4332, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { - __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4242, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -83652,7 +85741,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_v_cacheFlag); __Pyx_GIVEREF(__pyx_v_cacheFlag); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_v_cacheFlag); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4242, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } @@ -83663,7 +85752,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(3, 4242, __pyx_L1_error) + __PYX_ERR(3, 4332, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -83679,17 +85768,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_5); #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4242, __pyx_L1_error) + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4242, __pyx_L1_error) + __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4242, __pyx_L1_error) + __pyx_t_5 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { Py_ssize_t index = -1; - __pyx_t_9 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 4242, __pyx_L1_error) + __pyx_t_9 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 4332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; @@ -83699,7 +85788,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_GOTREF(__pyx_t_8); index = 2; __pyx_t_5 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_5)) goto __pyx_L10_unpacking_failed; __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 3) < 0) __PYX_ERR(3, 4242, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 3) < 0) __PYX_ERR(3, 4332, __pyx_L1_error) __pyx_t_10 = NULL; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L11_unpacking_done; @@ -83707,7 +85796,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_10 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(3, 4242, __pyx_L1_error) + __PYX_ERR(3, 4332, __pyx_L1_error) __pyx_L11_unpacking_done:; } __pyx_v_value = __pyx_t_4; @@ -83717,7 +85806,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __pyx_v_status = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":4241 + /* "PyCafe.pyx":4331 * First input argument, should be a 'list' of of type if handles or if PVs") * * if scalarOnly: # <<<<<<<<<<<<<< @@ -83727,7 +85816,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC goto __pyx_L9; } - /* "PyCafe.pyx":4244 + /* "PyCafe.pyx":4334 * value, statusOverall, status =self.getScalarList(handleList, dt, cacheFlag) * else: * value, statusOverall, status =self.getCompoundList(handleList, dt, cacheFlag) # <<<<<<<<<<<<<< @@ -83735,7 +85824,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC * pvdict = OrderedDict() */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCompoundList); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4244, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCompoundList); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_8 = NULL; __pyx_t_7 = 0; @@ -83752,7 +85841,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_handleList, __pyx_v_dt, __pyx_v_cacheFlag}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4244, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4334, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_3); } else @@ -83760,13 +85849,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_handleList, __pyx_v_dt, __pyx_v_cacheFlag}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4244, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4334, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { - __pyx_t_4 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4244, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -83780,7 +85869,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_v_cacheFlag); __Pyx_GIVEREF(__pyx_v_cacheFlag); PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_7, __pyx_v_cacheFlag); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4244, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } @@ -83791,7 +85880,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(3, 4244, __pyx_L1_error) + __PYX_ERR(3, 4334, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -83807,17 +85896,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4244, __pyx_L1_error) + __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4244, __pyx_L1_error) + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4244, __pyx_L1_error) + __pyx_t_8 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { Py_ssize_t index = -1; - __pyx_t_9 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 4244, __pyx_L1_error) + __pyx_t_9 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 4334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; @@ -83827,7 +85916,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_GOTREF(__pyx_t_4); index = 2; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L12_unpacking_failed; __Pyx_GOTREF(__pyx_t_8); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 3) < 0) __PYX_ERR(3, 4244, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 3) < 0) __PYX_ERR(3, 4334, __pyx_L1_error) __pyx_t_10 = NULL; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L13_unpacking_done; @@ -83835,7 +85924,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_10 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(3, 4244, __pyx_L1_error) + __PYX_ERR(3, 4334, __pyx_L1_error) __pyx_L13_unpacking_done:; } __pyx_v_value = __pyx_t_5; @@ -83847,14 +85936,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC } __pyx_L9:; - /* "PyCafe.pyx":4246 + /* "PyCafe.pyx":4336 * value, statusOverall, status =self.getCompoundList(handleList, dt, cacheFlag) * * pvdict = OrderedDict() # <<<<<<<<<<<<<< * for i in range(0, len(handleList)): * _val = value[i] */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4246, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { @@ -83868,55 +85957,55 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC } __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_8); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4246, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_pvdict = __pyx_t_3; __pyx_t_3 = 0; - /* "PyCafe.pyx":4247 + /* "PyCafe.pyx":4337 * * pvdict = OrderedDict() * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * _val = value[i] * if status[i] != ICAFE_NORMAL: */ - __pyx_t_11 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4247, __pyx_L1_error) + __pyx_t_11 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4337, __pyx_L1_error) __pyx_t_12 = __pyx_t_11; for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { __pyx_v_i = __pyx_t_13; - /* "PyCafe.pyx":4248 + /* "PyCafe.pyx":4338 * pvdict = OrderedDict() * for i in range(0, len(handleList)): * _val = value[i] # <<<<<<<<<<<<<< * if status[i] != ICAFE_NORMAL: * _val = None */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_value, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4248, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_value, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v__val, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4249 + /* "PyCafe.pyx":4339 * for i in range(0, len(handleList)): * _val = value[i] * if status[i] != ICAFE_NORMAL: # <<<<<<<<<<<<<< * _val = None * pvdict[self._c_cafe.getPVFromHandle(handleList[i])] = _val */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_status, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4249, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_status, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4249, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4249, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4339, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4249, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4339, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_2) { - /* "PyCafe.pyx":4250 + /* "PyCafe.pyx":4340 * _val = value[i] * if status[i] != ICAFE_NORMAL: * _val = None # <<<<<<<<<<<<<< @@ -83926,7 +86015,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v__val, Py_None); - /* "PyCafe.pyx":4249 + /* "PyCafe.pyx":4339 * for i in range(0, len(handleList)): * _val = value[i] * if status[i] != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -83935,24 +86024,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4251 + /* "PyCafe.pyx":4341 * if status[i] != ICAFE_NORMAL: * _val = None * pvdict[self._c_cafe.getPVFromHandle(handleList[i])] = _val # <<<<<<<<<<<<<< * * return pvdict, statusOverall, status */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4251, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_14 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_14 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4251, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_14 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4341, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_t_14)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4251, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_t_14)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (unlikely(PyObject_SetItem(__pyx_v_pvdict, __pyx_t_4, __pyx_v__val) < 0)) __PYX_ERR(3, 4251, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_pvdict, __pyx_t_4, __pyx_v__val) < 0)) __PYX_ERR(3, 4341, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":4253 + /* "PyCafe.pyx":4343 * pvdict[self._c_cafe.getPVFromHandle(handleList[i])] = _val * * return pvdict, statusOverall, status # <<<<<<<<<<<<<< @@ -83960,7 +86049,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC * # int alarmStatus=None, int alarmSev=None): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4253, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_pvdict); __Pyx_GIVEREF(__pyx_v_pvdict); @@ -83977,7 +86066,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC } __pyx_L3:; - /* "PyCafe.pyx":4215 + /* "PyCafe.pyx":4305 * * * def getDictionary(self, pvhandleList, dt: str = 'native', cacheFlag: bool = False, # <<<<<<<<<<<<<< @@ -84010,7 +86099,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_294getDictionary(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":4257 +/* "PyCafe.pyx":4347 * # int alarmStatus=None, int alarmSev=None): * ################################################################################## * def getCompoundList(self, handleList, str dt='native', bint cacheFlag=False): # <<<<<<<<<<<<<< @@ -84063,7 +86152,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_297getCompoundList(PyObject *__pyx_v_s } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCompoundList") < 0)) __PYX_ERR(3, 4257, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCompoundList") < 0)) __PYX_ERR(3, 4347, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -84079,20 +86168,20 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_297getCompoundList(PyObject *__pyx_v_s __pyx_v_handleList = values[0]; __pyx_v_dt = ((PyObject*)values[1]); if (values[2]) { - __pyx_v_cacheFlag = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_cacheFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4257, __pyx_L3_error) + __pyx_v_cacheFlag = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_cacheFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4347, __pyx_L3_error) } else { __pyx_v_cacheFlag = ((int)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getCompoundList", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4257, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getCompoundList", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4347, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getCompoundList", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4257, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4347, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_296getCompoundList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handleList, __pyx_v_dt, __pyx_v_cacheFlag); /* function exit code */ @@ -84154,7 +86243,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_RefNannySetupContext("getCompoundList", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":4259 + /* "PyCafe.pyx":4349 * def getCompoundList(self, handleList, str dt='native', bint cacheFlag=False): * ################################################################################## * cdef str _METHOD = "getCompoundList(handleList, str dt='native')" # <<<<<<<<<<<<<< @@ -84164,7 +86253,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_INCREF(__pyx_kp_u_getCompoundList_handleList_str_d); __pyx_v__METHOD = __pyx_kp_u_getCompoundList_handleList_str_d; - /* "PyCafe.pyx":4261 + /* "PyCafe.pyx":4351 * cdef str _METHOD = "getCompoundList(handleList, str dt='native')" * * if isinstance(handleList, (str)): # <<<<<<<<<<<<<< @@ -84175,14 +86264,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4262 + /* "PyCafe.pyx":4352 * * if isinstance(handleList, (str)): * handleList = self.getHandlesFromWithinGroup(handleList) # <<<<<<<<<<<<<< * if not handleList: * raise Exception(("EXCEPTION RAISED IN PyCafe def getCompoundList. \n" + */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4262, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -84196,37 +86285,37 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_handleList) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_handleList); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4262, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4263 + /* "PyCafe.pyx":4353 * if isinstance(handleList, (str)): * handleList = self.getHandlesFromWithinGroup(handleList) * if not handleList: # <<<<<<<<<<<<<< * raise Exception(("EXCEPTION RAISED IN PyCafe def getCompoundList. \n" + * "First input argument should be " + */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_handleList); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4263, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_handleList); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4353, __pyx_L1_error) __pyx_t_1 = ((!__pyx_t_2) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4264 + /* "PyCafe.pyx":4354 * handleList = self.getHandlesFromWithinGroup(handleList) * if not handleList: * raise Exception(("EXCEPTION RAISED IN PyCafe def getCompoundList. \n" + # <<<<<<<<<<<<<< * "First input argument should be " + * "of handles or PVs\nelse for " + */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4264, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4354, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 4264, __pyx_L1_error) + __PYX_ERR(3, 4354, __pyx_L1_error) - /* "PyCafe.pyx":4263 + /* "PyCafe.pyx":4353 * if isinstance(handleList, (str)): * handleList = self.getHandlesFromWithinGroup(handleList) * if not handleList: # <<<<<<<<<<<<<< @@ -84235,7 +86324,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4261 + /* "PyCafe.pyx":4351 * cdef str _METHOD = "getCompoundList(handleList, str dt='native')" * * if isinstance(handleList, (str)): # <<<<<<<<<<<<<< @@ -84245,7 +86334,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L3; } - /* "PyCafe.pyx":4269 + /* "PyCafe.pyx":4359 * "CAFE 'group' name")) * else: * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -84257,20 +86346,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4270 + /* "PyCafe.pyx":4360 * else: * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def getCompoundList. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4270, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 4270, __pyx_L1_error) + __PYX_ERR(3, 4360, __pyx_L1_error) - /* "PyCafe.pyx":4269 + /* "PyCafe.pyx":4359 * "CAFE 'group' name")) * else: * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -84279,34 +86368,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4273 + /* "PyCafe.pyx":4363 * 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)): */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4273, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4363, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyUnicode_Check(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4274 + /* "PyCafe.pyx":4364 * * 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\ */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 4274, __pyx_L1_error) - __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4274, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 4364, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4364, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4273 + /* "PyCafe.pyx":4363 * First input argument, should be of handles or PVs") * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -84316,14 +86405,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L6; } - /* "PyCafe.pyx":4275 + /* "PyCafe.pyx":4365 * 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 of type if handles or if PVs") */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4275, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyInt_Check(__pyx_t_3); __pyx_t_6 = (__pyx_t_2 != 0); @@ -84340,20 +86429,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4276 + /* "PyCafe.pyx":4366 * 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 of type if handles or if PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4276, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 4276, __pyx_L1_error) + __PYX_ERR(3, 4366, __pyx_L1_error) - /* "PyCafe.pyx":4275 + /* "PyCafe.pyx":4365 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -84365,27 +86454,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P } __pyx_L3:; - /* "PyCafe.pyx":4285 + /* "PyCafe.pyx":4375 * cdef vector[int] vRB * * v.reserve(len(handleList)) # <<<<<<<<<<<<<< * vStatus.reserve(len(handleList)) * */ - __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4285, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4375, __pyx_L1_error) __pyx_v_v.reserve(__pyx_t_7); - /* "PyCafe.pyx":4286 + /* "PyCafe.pyx":4376 * * v.reserve(len(handleList)) * vStatus.reserve(len(handleList)) # <<<<<<<<<<<<<< * * cdef bint flagCompound = False */ - __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4286, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4376, __pyx_L1_error) __pyx_v_vStatus.reserve(__pyx_t_7); - /* "PyCafe.pyx":4288 + /* "PyCafe.pyx":4378 * vStatus.reserve(len(handleList)) * * cdef bint flagCompound = False # <<<<<<<<<<<<<< @@ -84394,7 +86483,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_flagCompound = 0; - /* "PyCafe.pyx":4290 + /* "PyCafe.pyx":4380 * cdef bint flagCompound = False * * cdef unsigned int nelemLocal = 1 # <<<<<<<<<<<<<< @@ -84403,37 +86492,37 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_nelemLocal = 1; - /* "PyCafe.pyx":4292 + /* "PyCafe.pyx":4382 * cdef unsigned int nelemLocal = 1 * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) */ - __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4292, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4382, __pyx_L1_error) __pyx_t_8 = __pyx_t_7; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":4294 + /* "PyCafe.pyx":4384 * for i in range(0, len(handleList)): * # do this copy to avoid compiler warning messages * v.push_back(handleList[i]) # <<<<<<<<<<<<<< * * if (nelemLocal == 1): */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4294, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4294, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4384, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; try { __pyx_v_v.push_back(__pyx_t_10); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 4294, __pyx_L1_error) + __PYX_ERR(3, 4384, __pyx_L1_error) } - /* "PyCafe.pyx":4296 + /* "PyCafe.pyx":4386 * v.push_back(handleList[i]) * * if (nelemLocal == 1): # <<<<<<<<<<<<<< @@ -84443,20 +86532,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((__pyx_v_nelemLocal == 1) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4297 + /* "PyCafe.pyx":4387 * * if (nelemLocal == 1): * nelemLocal = self.hh.getNelemNative(handleList[i]) # <<<<<<<<<<<<<< * if nelemLocal > 1: * flagCompound = True */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4297, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4297, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4387, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_nelemLocal = __pyx_v_self->hh.getNelemNative(__pyx_t_10); - /* "PyCafe.pyx":4298 + /* "PyCafe.pyx":4388 * if (nelemLocal == 1): * nelemLocal = self.hh.getNelemNative(handleList[i]) * if nelemLocal > 1: # <<<<<<<<<<<<<< @@ -84466,7 +86555,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((__pyx_v_nelemLocal > 1) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4299 + /* "PyCafe.pyx":4389 * nelemLocal = self.hh.getNelemNative(handleList[i]) * if nelemLocal > 1: * flagCompound = True # <<<<<<<<<<<<<< @@ -84475,7 +86564,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_flagCompound = 1; - /* "PyCafe.pyx":4298 + /* "PyCafe.pyx":4388 * if (nelemLocal == 1): * nelemLocal = self.hh.getNelemNative(handleList[i]) * if nelemLocal > 1: # <<<<<<<<<<<<<< @@ -84484,7 +86573,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4296 + /* "PyCafe.pyx":4386 * v.push_back(handleList[i]) * * if (nelemLocal == 1): # <<<<<<<<<<<<<< @@ -84494,7 +86583,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P } } - /* "PyCafe.pyx":4301 + /* "PyCafe.pyx":4391 * flagCompound = True * * status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -84503,7 +86592,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":4303 + /* "PyCafe.pyx":4393 * status = ICAFE_NORMAL * * if not cacheFlag: # <<<<<<<<<<<<<< @@ -84513,7 +86602,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((!(__pyx_v_cacheFlag != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4307 + /* "PyCafe.pyx":4397 * # Need to copy to a vector since * # Coercion from Python not allowed without the GIL * with nogil: # <<<<<<<<<<<<<< @@ -84528,7 +86617,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":4308 + /* "PyCafe.pyx":4398 * # Coercion from Python not allowed without the GIL * with nogil: * status = self._c_cafe.getV(v, vStatus) # <<<<<<<<<<<<<< @@ -84538,7 +86627,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_v_status = __pyx_v_self->_c_cafe->getV(__pyx_v_v, __pyx_v_vStatus); } - /* "PyCafe.pyx":4307 + /* "PyCafe.pyx":4397 * # Need to copy to a vector since * # Coercion from Python not allowed without the GIL * with nogil: # <<<<<<<<<<<<<< @@ -84557,7 +86646,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P } } - /* "PyCafe.pyx":4314 + /* "PyCafe.pyx":4404 * # Wait for bundle * * with nogil: # <<<<<<<<<<<<<< @@ -84572,7 +86661,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":4315 + /* "PyCafe.pyx":4405 * * with nogil: * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) # <<<<<<<<<<<<<< @@ -84582,7 +86671,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_v_statusBundle = __pyx_v_self->_c_cafe->waitForBundledEvents(__pyx_v_v, __pyx_v_vRB); } - /* "PyCafe.pyx":4314 + /* "PyCafe.pyx":4404 * # Wait for bundle * * with nogil: # <<<<<<<<<<<<<< @@ -84601,7 +86690,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P } } - /* "PyCafe.pyx":4317 + /* "PyCafe.pyx":4407 * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) * * if (statusBundle != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -84611,7 +86700,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((__pyx_v_statusBundle != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4318 + /* "PyCafe.pyx":4408 * * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -84621,18 +86710,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4319 + /* "PyCafe.pyx":4409 * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def getCompoundList: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(statusBundle) * */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4319, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4320 + /* "PyCafe.pyx":4410 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def getCompoundList: ") * self._c_cafe.printStatusMessage(statusBundle) # <<<<<<<<<<<<<< @@ -84641,7 +86730,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_statusBundle); - /* "PyCafe.pyx":4318 + /* "PyCafe.pyx":4408 * * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -84650,7 +86739,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4317 + /* "PyCafe.pyx":4407 * statusBundle = self._c_cafe.waitForBundledEvents(v, vRB) * * if (statusBundle != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -84659,7 +86748,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4303 + /* "PyCafe.pyx":4393 * status = ICAFE_NORMAL * * if not cacheFlag: # <<<<<<<<<<<<<< @@ -84668,7 +86757,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4322 + /* "PyCafe.pyx":4412 * self._c_cafe.printStatusMessage(statusBundle) * * cdef int dtcheck = CAFE_NOT_REQUESTED # native type not yet know # <<<<<<<<<<<<<< @@ -84677,35 +86766,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_dtcheck = CAFE_NOT_REQUESTED; - /* "PyCafe.pyx":4323 + /* "PyCafe.pyx":4413 * * cdef int dtcheck = CAFE_NOT_REQUESTED # native type not yet know * dtcheck = getMatchedDataType(dt, dtcheck) # <<<<<<<<<<<<<< * * cdef bytes bytesVal */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dtcheck); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4323, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dtcheck); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4323, __pyx_L1_error) + __pyx_t_4 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4323, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4413, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_dtcheck = __pyx_t_11; - /* "PyCafe.pyx":4326 + /* "PyCafe.pyx":4416 * * cdef bytes bytesVal * localList = [] # <<<<<<<<<<<<<< * * */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4326, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_localList = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":4330 + /* "PyCafe.pyx":4420 * * # Use Scalar * if not flagCompound: # <<<<<<<<<<<<<< @@ -84715,7 +86804,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((!(__pyx_v_flagCompound != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4332 + /* "PyCafe.pyx":4422 * if not flagCompound: * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -84725,7 +86814,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":4334 + /* "PyCafe.pyx":4424 * if dtcheck in [CAFE_STRING]: * * self.vStr.clear() # <<<<<<<<<<<<<< @@ -84734,17 +86823,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_self->vStr.clear(); - /* "PyCafe.pyx":4335 + /* "PyCafe.pyx":4425 * * self.vStr.clear() * self.vStr.reserve(len(handleList)) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4335, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4425, __pyx_L1_error) __pyx_v_self->vStr.reserve(__pyx_t_7); - /* "PyCafe.pyx":4337 + /* "PyCafe.pyx":4427 * self.vStr.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -84759,7 +86848,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":4338 + /* "PyCafe.pyx":4428 * * with nogil: * status = self._c_cafe.getCacheVStr(v, self.vStr, vStatus) # <<<<<<<<<<<<<< @@ -84769,7 +86858,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_v_status = __pyx_v_self->_c_cafe->getCacheVStr(__pyx_v_v, __pyx_v_self->vStr, __pyx_v_vStatus); } - /* "PyCafe.pyx":4337 + /* "PyCafe.pyx":4427 * self.vStr.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -84788,29 +86877,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P } } - /* "PyCafe.pyx":4341 + /* "PyCafe.pyx":4431 * * #warning: __pyx_v_i may be used uninitialized in this function * for i in range(0, len(v)): # <<<<<<<<<<<<<< * bytesVal = ( self.vStr[i] ) * encoding = False */ - __pyx_t_4 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_v); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4341, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_v); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4341, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4431, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_8 = __pyx_t_7; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":4342 + /* "PyCafe.pyx":4432 * #warning: __pyx_v_i may be used uninitialized in this function * for i in range(0, len(v)): * bytesVal = ( self.vStr[i] ) # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): */ - __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_v_i]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4342, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_v_i]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_t_4; __Pyx_INCREF(__pyx_t_3); @@ -84818,7 +86907,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "PyCafe.pyx":4343 + /* "PyCafe.pyx":4433 * for i in range(0, len(v)): * bytesVal = ( self.vStr[i] ) * encoding = False # <<<<<<<<<<<<<< @@ -84827,21 +86916,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":4344 + /* "PyCafe.pyx":4434 * bytesVal = ( self.vStr[i] ) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4344, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4344, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4434, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4345 + /* "PyCafe.pyx":4435 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -84857,7 +86946,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":4346 + /* "PyCafe.pyx":4436 * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -84866,14 +86955,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4346, __pyx_L29_error) + __PYX_ERR(3, 4436, __pyx_L29_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4346, __pyx_L29_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4436, __pyx_L29_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4347 + /* "PyCafe.pyx":4437 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -84882,7 +86971,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4345 + /* "PyCafe.pyx":4435 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -84899,7 +86988,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4348 + /* "PyCafe.pyx":4438 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -84914,7 +87003,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L31_except_error; __pyx_L31_except_error:; - /* "PyCafe.pyx":4345 + /* "PyCafe.pyx":4435 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -84934,7 +87023,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_L36_try_end:; } - /* "PyCafe.pyx":4344 + /* "PyCafe.pyx":4434 * bytesVal = ( self.vStr[i] ) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< @@ -84943,7 +87032,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4350 + /* "PyCafe.pyx":4440 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -84953,7 +87042,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4351 + /* "PyCafe.pyx":4441 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -84969,7 +87058,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "PyCafe.pyx":4352 + /* "PyCafe.pyx":4442 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -84978,14 +87067,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4352, __pyx_L38_error) + __PYX_ERR(3, 4442, __pyx_L38_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4352, __pyx_L38_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4442, __pyx_L38_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4353 + /* "PyCafe.pyx":4443 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -84994,7 +87083,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4351 + /* "PyCafe.pyx":4441 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -85011,7 +87100,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4354 + /* "PyCafe.pyx":4444 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -85026,7 +87115,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L40_except_error; __pyx_L40_except_error:; - /* "PyCafe.pyx":4351 + /* "PyCafe.pyx":4441 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -85046,7 +87135,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_L45_try_end:; } - /* "PyCafe.pyx":4350 + /* "PyCafe.pyx":4440 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -85055,7 +87144,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4356 + /* "PyCafe.pyx":4446 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -85065,7 +87154,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4357 + /* "PyCafe.pyx":4447 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -85081,7 +87170,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":4358 + /* "PyCafe.pyx":4448 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -85090,14 +87179,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4358, __pyx_L47_error) + __PYX_ERR(3, 4448, __pyx_L47_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4358, __pyx_L47_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4448, __pyx_L47_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4359 + /* "PyCafe.pyx":4449 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -85106,7 +87195,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4357 + /* "PyCafe.pyx":4447 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -85123,7 +87212,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4360 + /* "PyCafe.pyx":4450 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -85138,7 +87227,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L49_except_error; __pyx_L49_except_error:; - /* "PyCafe.pyx":4357 + /* "PyCafe.pyx":4447 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -85158,7 +87247,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_L54_try_end:; } - /* "PyCafe.pyx":4356 + /* "PyCafe.pyx":4446 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -85167,7 +87256,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4362 + /* "PyCafe.pyx":4452 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -85177,19 +87266,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4363 + /* "PyCafe.pyx":4453 * pass * if not encoding: * strVal = self.vStr[i] # <<<<<<<<<<<<<< * * localList.append(strVal) */ - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_v_i]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4363, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string(((std::string)(__pyx_v_self->vStr[__pyx_v_i]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4362 + /* "PyCafe.pyx":4452 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -85198,18 +87287,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4365 + /* "PyCafe.pyx":4455 * strVal = self.vStr[i] * * localList.append(strVal) # <<<<<<<<<<<<<< * * return localList, status, vStatus */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4365, __pyx_L1_error) } - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4365, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4455, __pyx_L1_error) } + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4455, __pyx_L1_error) } - /* "PyCafe.pyx":4367 + /* "PyCafe.pyx":4457 * localList.append(strVal) * * return localList, status, vStatus # <<<<<<<<<<<<<< @@ -85217,11 +87306,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4367, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4367, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4367, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -85236,7 +87325,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4332 + /* "PyCafe.pyx":4422 * if not flagCompound: * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -85246,7 +87335,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_SHORT: - /* "PyCafe.pyx":4369 + /* "PyCafe.pyx":4459 * return localList, status, vStatus * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -85256,7 +87345,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P case CAFE_CHAR: case CAFE_LONG: - /* "PyCafe.pyx":4371 + /* "PyCafe.pyx":4461 * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: * * self.vInt.clear() # <<<<<<<<<<<<<< @@ -85265,17 +87354,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_self->vInt.clear(); - /* "PyCafe.pyx":4372 + /* "PyCafe.pyx":4462 * * self.vInt.clear() * self.vInt.reserve(len(handleList)) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4372, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4462, __pyx_L1_error) __pyx_v_self->vInt.reserve(__pyx_t_7); - /* "PyCafe.pyx":4374 + /* "PyCafe.pyx":4464 * self.vInt.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -85290,7 +87379,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":4375 + /* "PyCafe.pyx":4465 * * with nogil: * status = self._c_cafe.getCacheVLong(v, self.vInt, vStatus) # <<<<<<<<<<<<<< @@ -85300,7 +87389,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_v_status = __pyx_v_self->_c_cafe->getCacheVLong(__pyx_v_v, __pyx_v_self->vInt, __pyx_v_vStatus); } - /* "PyCafe.pyx":4374 + /* "PyCafe.pyx":4464 * self.vInt.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -85319,7 +87408,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P } } - /* "PyCafe.pyx":4377 + /* "PyCafe.pyx":4467 * status = self._c_cafe.getCacheVLong(v, self.vInt, vStatus) * #print("getCompound", status, vStatus) * return self.vInt, status, vStatus # <<<<<<<<<<<<<< @@ -85327,13 +87416,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __pyx_convert_vector_to_py_dbr_long_t(__pyx_v_self->vInt); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4377, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_vector_to_py_dbr_long_t(__pyx_v_self->vInt); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4377, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4377, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_16 = PyTuple_New(3); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 4377, __pyx_L1_error) + __pyx_t_16 = PyTuple_New(3); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 4467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_5); @@ -85348,7 +87437,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_16 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4369 + /* "PyCafe.pyx":4459 * return localList, status, vStatus * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -85358,7 +87447,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_FLOAT: - /* "PyCafe.pyx":4379 + /* "PyCafe.pyx":4469 * return self.vInt, status, vStatus * * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -85367,7 +87456,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ case CAFE_DOUBLE: - /* "PyCafe.pyx":4381 + /* "PyCafe.pyx":4471 * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: * * self.vFloat.clear() # <<<<<<<<<<<<<< @@ -85376,17 +87465,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_self->vFloat.clear(); - /* "PyCafe.pyx":4382 + /* "PyCafe.pyx":4472 * * self.vFloat.clear() * self.vFloat.reserve(len(handleList)) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4382, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4472, __pyx_L1_error) __pyx_v_self->vFloat.reserve(__pyx_t_7); - /* "PyCafe.pyx":4384 + /* "PyCafe.pyx":4474 * self.vFloat.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -85401,7 +87490,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":4385 + /* "PyCafe.pyx":4475 * * with nogil: * status = self._c_cafe.getCacheVDouble( # <<<<<<<<<<<<<< @@ -85411,7 +87500,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_v_status = __pyx_v_self->_c_cafe->getCacheVDouble(__pyx_v_v, __pyx_v_self->vFloat, __pyx_v_vStatus); } - /* "PyCafe.pyx":4384 + /* "PyCafe.pyx":4474 * self.vFloat.reserve(len(handleList)) * * with nogil: # <<<<<<<<<<<<<< @@ -85430,7 +87519,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P } } - /* "PyCafe.pyx":4388 + /* "PyCafe.pyx":4478 * v, self.vFloat, vStatus) * * return self.vFloat, status, vStatus # <<<<<<<<<<<<<< @@ -85438,13 +87527,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_16 = __pyx_convert_vector_to_py_double(__pyx_v_self->vFloat); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 4388, __pyx_L1_error) + __pyx_t_16 = __pyx_convert_vector_to_py_double(__pyx_v_self->vFloat); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 4478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4388, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4388, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4388, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_16); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_16); @@ -85459,7 +87548,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4379 + /* "PyCafe.pyx":4469 * return self.vInt, status, vStatus * * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -85470,7 +87559,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P default: break; } - /* "PyCafe.pyx":4330 + /* "PyCafe.pyx":4420 * * # Use Scalar * if not flagCompound: # <<<<<<<<<<<<<< @@ -85479,7 +87568,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4396 + /* "PyCafe.pyx":4486 * # Does group exist? * * cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) # <<<<<<<<<<<<<< @@ -85488,7 +87577,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_pvd = __pyx_v_self->_c_cafe->getPVData(__pyx_v_v); - /* "PyCafe.pyx":4399 + /* "PyCafe.pyx":4489 * * # Required to allocate memory for shared pointer * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -85500,21 +87589,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_17; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "PyCafe.pyx":4400 + /* "PyCafe.pyx":4490 * # Required to allocate memory for shared pointer * for i in range(0, v.size()): #len(handleList)): * pvd[i].setNelem(self.hh.getNelemClient(handleList[i])) # <<<<<<<<<<<<<< * * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4400, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4400, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4490, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; (void)((__pyx_v_pvd[__pyx_v_i]).setNelem(__pyx_v_self->hh.getNelemClient(__pyx_t_10))); } - /* "PyCafe.pyx":4402 + /* "PyCafe.pyx":4492 * pvd[i].setNelem(self.hh.getNelemClient(handleList[i])) * * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) # <<<<<<<<<<<<<< @@ -85523,19 +87612,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_statusNoWait = __pyx_v_self->_c_cafe->getCachePVArrayNoWait(__pyx_v_v, __pyx_v_pvd); - /* "PyCafe.pyx":4404 + /* "PyCafe.pyx":4494 * statusNoWait = self._c_cafe.getCachePVArrayNoWait(v, pvd) * * statusList = [] # <<<<<<<<<<<<<< * statusFlag = True * statusLocal = ICAFE_NORMAL */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4404, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_statusList = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4405 + /* "PyCafe.pyx":4495 * * statusList = [] * statusFlag = True # <<<<<<<<<<<<<< @@ -85544,7 +87633,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_statusFlag = 1; - /* "PyCafe.pyx":4406 + /* "PyCafe.pyx":4496 * statusList = [] * statusFlag = True * statusLocal = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -85553,7 +87642,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_statusLocal = ICAFE_NORMAL; - /* "PyCafe.pyx":4408 + /* "PyCafe.pyx":4498 * statusLocal = ICAFE_NORMAL * * if cacheFlag: # <<<<<<<<<<<<<< @@ -85563,7 +87652,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = (__pyx_v_cacheFlag != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4409 + /* "PyCafe.pyx":4499 * * if cacheFlag: * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -85575,19 +87664,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_17; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "PyCafe.pyx":4410 + /* "PyCafe.pyx":4500 * if cacheFlag: * for i in range(0, v.size()): #len(handleList)): * statusList.append(pvd[i].getStatus()) # <<<<<<<<<<<<<< * if pvd[i].getStatus() != ICAFE_NORMAL: * print("Error in Element ", i, " from ", len( */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4410, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4410, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4500, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4411 + /* "PyCafe.pyx":4501 * for i in range(0, v.size()): #len(handleList)): * statusList.append(pvd[i].getStatus()) * if pvd[i].getStatus() != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -85597,35 +87686,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = (((__pyx_v_pvd[__pyx_v_i]).getStatus() != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4412 + /* "PyCafe.pyx":4502 * 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=", */ - __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4412, __pyx_L1_error) + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - /* "PyCafe.pyx":4413 + /* "PyCafe.pyx":4503 * 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])) */ - __pyx_t_8 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4412, __pyx_L1_error) + __pyx_t_8 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4502, __pyx_L1_error) - /* "PyCafe.pyx":4412 + /* "PyCafe.pyx":4502 * 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=", */ - __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4412, __pyx_L1_error) + __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4412, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_kp_u_Error_in_Element); __Pyx_GIVEREF(__pyx_kp_u_Error_in_Element); @@ -85642,43 +87731,43 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_kp_u_in_PyCafe_def_getCompundList); __pyx_t_5 = 0; __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4412, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":4414 + /* "PyCafe.pyx":4504 * 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()) */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4414, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "PyCafe.pyx":4415 + /* "PyCafe.pyx":4505 * 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()) */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4415, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4415, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4505, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_10)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4415, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_10)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "PyCafe.pyx":4414 + /* "PyCafe.pyx":4504 * 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()) */ - __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4414, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_kp_u_Handle_2); __Pyx_GIVEREF(__pyx_kp_u_Handle_2); @@ -85692,21 +87781,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3); __pyx_t_4 = 0; __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4414, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4416 + /* "PyCafe.pyx":4506 * 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: */ - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4416, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4416, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_kp_u_with_error_status); __Pyx_GIVEREF(__pyx_kp_u_with_error_status); @@ -85714,12 +87803,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4416, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4417 + /* "PyCafe.pyx":4507 * self.hh.getPVFromHandle(handleList[i])) * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) # <<<<<<<<<<<<<< @@ -85728,7 +87817,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_self->_c_cafe->printStatusMessage((__pyx_v_pvd[__pyx_v_i]).getStatus()); - /* "PyCafe.pyx":4418 + /* "PyCafe.pyx":4508 * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * if statusFlag: # <<<<<<<<<<<<<< @@ -85738,7 +87827,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = (__pyx_v_statusFlag != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4419 + /* "PyCafe.pyx":4509 * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * if statusFlag: * statusLocal = pvd[i].getStatus() # <<<<<<<<<<<<<< @@ -85747,7 +87836,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_statusLocal = (__pyx_v_pvd[__pyx_v_i]).getStatus(); - /* "PyCafe.pyx":4420 + /* "PyCafe.pyx":4510 * if statusFlag: * statusLocal = pvd[i].getStatus() * statusFlag = False # <<<<<<<<<<<<<< @@ -85756,7 +87845,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_statusFlag = 0; - /* "PyCafe.pyx":4418 + /* "PyCafe.pyx":4508 * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * if statusFlag: # <<<<<<<<<<<<<< @@ -85765,7 +87854,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4411 + /* "PyCafe.pyx":4501 * for i in range(0, v.size()): #len(handleList)): * statusList.append(pvd[i].getStatus()) * if pvd[i].getStatus() != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -85775,7 +87864,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P } } - /* "PyCafe.pyx":4408 + /* "PyCafe.pyx":4498 * statusLocal = ICAFE_NORMAL * * if cacheFlag: # <<<<<<<<<<<<<< @@ -85784,19 +87873,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4424 + /* "PyCafe.pyx":4514 * cdef unsigned int dtn * * localList = [] # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4424, __pyx_L1_error) + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_localList, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "PyCafe.pyx":4427 + /* "PyCafe.pyx":4517 * * * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -85808,7 +87897,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_17; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "PyCafe.pyx":4429 + /* "PyCafe.pyx":4519 * for i in range(0, v.size()): #len(handleList)): * * dtn = pvd[i].getDataType() # <<<<<<<<<<<<<< @@ -85817,23 +87906,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_dtn = (__pyx_v_pvd[__pyx_v_i]).getDataType(); - /* "PyCafe.pyx":4430 + /* "PyCafe.pyx":4520 * * dtn = pvd[i].getDataType() * dtcheck = getMatchedDataType(dt, dtn) # <<<<<<<<<<<<<< * * if pvd[i].getNelem() == 1: */ - __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4430, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4430, __pyx_L1_error) + __pyx_t_5 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4430, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4520, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_dtcheck = __pyx_t_18; - /* "PyCafe.pyx":4432 + /* "PyCafe.pyx":4522 * dtcheck = getMatchedDataType(dt, dtn) * * if pvd[i].getNelem() == 1: # <<<<<<<<<<<<<< @@ -85843,7 +87932,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = (((__pyx_v_pvd[__pyx_v_i]).getNelem() == 1) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4433 + /* "PyCafe.pyx":4523 * * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -85853,14 +87942,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":4434 + /* "PyCafe.pyx":4524 * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: * bytesVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): */ - __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4434, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = __pyx_t_5; __Pyx_INCREF(__pyx_t_3); @@ -85868,7 +87957,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "PyCafe.pyx":4435 + /* "PyCafe.pyx":4525 * if dtcheck == CAFE_STRING: * bytesVal = pvd[i].getAsString() * encoding = False # <<<<<<<<<<<<<< @@ -85877,21 +87966,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":4436 + /* "PyCafe.pyx":4526 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4436, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4526, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4436, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4526, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4437 + /* "PyCafe.pyx":4527 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -85907,7 +87996,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "PyCafe.pyx":4438 + /* "PyCafe.pyx":4528 * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -85916,14 +88005,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4438, __pyx_L73_error) + __PYX_ERR(3, 4528, __pyx_L73_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4438, __pyx_L73_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4528, __pyx_L73_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4439 + /* "PyCafe.pyx":4529 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -85932,7 +88021,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4437 + /* "PyCafe.pyx":4527 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -85950,7 +88039,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4440 + /* "PyCafe.pyx":4530 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -85965,7 +88054,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L75_except_error; __pyx_L75_except_error:; - /* "PyCafe.pyx":4437 + /* "PyCafe.pyx":4527 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -85985,7 +88074,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_L80_try_end:; } - /* "PyCafe.pyx":4436 + /* "PyCafe.pyx":4526 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< @@ -85994,7 +88083,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4442 + /* "PyCafe.pyx":4532 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86004,7 +88093,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4443 + /* "PyCafe.pyx":4533 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86020,7 +88109,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":4444 + /* "PyCafe.pyx":4534 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -86029,14 +88118,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4444, __pyx_L82_error) + __PYX_ERR(3, 4534, __pyx_L82_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4444, __pyx_L82_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4534, __pyx_L82_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4445 + /* "PyCafe.pyx":4535 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -86045,7 +88134,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4443 + /* "PyCafe.pyx":4533 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86063,7 +88152,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4446 + /* "PyCafe.pyx":4536 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -86078,7 +88167,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L84_except_error; __pyx_L84_except_error:; - /* "PyCafe.pyx":4443 + /* "PyCafe.pyx":4533 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86098,7 +88187,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_L89_try_end:; } - /* "PyCafe.pyx":4442 + /* "PyCafe.pyx":4532 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86107,7 +88196,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4448 + /* "PyCafe.pyx":4538 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86117,7 +88206,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4449 + /* "PyCafe.pyx":4539 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86133,7 +88222,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "PyCafe.pyx":4450 + /* "PyCafe.pyx":4540 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -86142,14 +88231,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4450, __pyx_L91_error) + __PYX_ERR(3, 4540, __pyx_L91_error) } - __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4450, __pyx_L91_error) + __pyx_t_3 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4540, __pyx_L91_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4451 + /* "PyCafe.pyx":4541 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -86158,7 +88247,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4449 + /* "PyCafe.pyx":4539 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86176,7 +88265,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4452 + /* "PyCafe.pyx":4542 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -86191,7 +88280,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L93_except_error; __pyx_L93_except_error:; - /* "PyCafe.pyx":4449 + /* "PyCafe.pyx":4539 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86211,7 +88300,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_L98_try_end:; } - /* "PyCafe.pyx":4448 + /* "PyCafe.pyx":4538 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86220,7 +88309,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4454 + /* "PyCafe.pyx":4544 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86230,19 +88319,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4455 + /* "PyCafe.pyx":4545 * pass * if not encoding: * strVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * * localList.append(strVal) */ - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4455, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4454 + /* "PyCafe.pyx":4544 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86251,17 +88340,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4457 + /* "PyCafe.pyx":4547 * strVal = pvd[i].getAsString() * * localList.append(strVal) # <<<<<<<<<<<<<< * * #localList.append(pvd[i].getAsString()) */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4457, __pyx_L1_error) } - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4457, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4547, __pyx_L1_error) } + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4547, __pyx_L1_error) - /* "PyCafe.pyx":4433 + /* "PyCafe.pyx":4523 * * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -86271,19 +88360,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_SHORT: - /* "PyCafe.pyx":4461 + /* "PyCafe.pyx":4551 * #localList.append(pvd[i].getAsString()) * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4461, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4461, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4551, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4460 + /* "PyCafe.pyx":4550 * * #localList.append(pvd[i].getAsString()) * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -86293,19 +88382,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_FLOAT: - /* "PyCafe.pyx":4463 + /* "PyCafe.pyx":4553 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native */ - __pyx_t_3 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4463, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4463, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4553, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4462 + /* "PyCafe.pyx":4552 * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -86315,33 +88404,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_ENUM: - /* "PyCafe.pyx":4466 + /* "PyCafe.pyx":4556 * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native * if self._c_cafe.isEnum(handleList[i]) == 1: # <<<<<<<<<<<<<< * localList.append(pvd[i].getAsString()) * else: */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4466, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4466, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_3); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4556, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = ((__pyx_v_self->_c_cafe->isEnum(__pyx_t_10) == 1) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4467 + /* "PyCafe.pyx":4557 * # 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()) */ - __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4467, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4467, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4557, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4466 + /* "PyCafe.pyx":4556 * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native * if self._c_cafe.isEnum(handleList[i]) == 1: # <<<<<<<<<<<<<< @@ -86351,7 +88440,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L100; } - /* "PyCafe.pyx":4469 + /* "PyCafe.pyx":4559 * localList.append(pvd[i].getAsString()) * else: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< @@ -86359,14 +88448,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P * elif dtcheck == CAFE_CHAR: */ /*else*/ { - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4469, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4469, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4559, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L100:; - /* "PyCafe.pyx":4464 + /* "PyCafe.pyx":4554 * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -86376,19 +88465,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_CHAR: - /* "PyCafe.pyx":4472 + /* "PyCafe.pyx":4562 * * elif dtcheck == CAFE_CHAR: * localList.append(< unsigned char > pvd[i].getAsChar()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_3 = __Pyx_PyInt_From_unsigned_char(((unsigned char)(__pyx_v_pvd[__pyx_v_i]).getAsChar())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4472, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_unsigned_char(((unsigned char)(__pyx_v_pvd[__pyx_v_i]).getAsChar())); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4562, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4472, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4562, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4471 + /* "PyCafe.pyx":4561 * localList.append(pvd[i].getAsLong()) * * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -86398,19 +88487,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_LONG: - /* "PyCafe.pyx":4474 + /* "PyCafe.pyx":4564 * localList.append(< unsigned char > pvd[i].getAsChar()) * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4474, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4564, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4474, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4564, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4473 + /* "PyCafe.pyx":4563 * elif dtcheck == CAFE_CHAR: * localList.append(< unsigned char > pvd[i].getAsChar()) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -86420,19 +88509,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_DOUBLE: - /* "PyCafe.pyx":4476 + /* "PyCafe.pyx":4566 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * else: * localList.append(0) # no data */ - __pyx_t_3 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4476, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4476, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_3); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4566, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":4475 + /* "PyCafe.pyx":4565 * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -86442,18 +88531,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; default: - /* "PyCafe.pyx":4478 + /* "PyCafe.pyx":4568 * localList.append(pvd[i].getAsDouble()) * else: * localList.append(0) # no data # <<<<<<<<<<<<<< * else: * localListInner = [] */ - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4478, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_int_0); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4568, __pyx_L1_error) break; } - /* "PyCafe.pyx":4432 + /* "PyCafe.pyx":4522 * dtcheck = getMatchedDataType(dt, dtn) * * if pvd[i].getNelem() == 1: # <<<<<<<<<<<<<< @@ -86463,7 +88552,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L71; } - /* "PyCafe.pyx":4480 + /* "PyCafe.pyx":4570 * localList.append(0) # no data * else: * localListInner = [] # <<<<<<<<<<<<<< @@ -86471,12 +88560,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P * for j in range(0, pvd[i].getNelem()): */ /*else*/ { - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4480, __pyx_L1_error) + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4570, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_localListInner, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "PyCafe.pyx":4481 + /* "PyCafe.pyx":4571 * else: * localListInner = [] * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -86486,7 +88575,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":4482 + /* "PyCafe.pyx":4572 * localListInner = [] * if dtcheck == CAFE_STRING: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -86498,14 +88587,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":4484 + /* "PyCafe.pyx":4574 * for j in range(0, pvd[i].getNelem()): * * bytesVal = pvd[i].getAsString(j) # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): */ - __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4484, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __pyx_t_3; __Pyx_INCREF(__pyx_t_5); @@ -86513,7 +88602,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":4485 + /* "PyCafe.pyx":4575 * * bytesVal = pvd[i].getAsString(j) * encoding = False # <<<<<<<<<<<<<< @@ -86522,21 +88611,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":4486 + /* "PyCafe.pyx":4576 * bytesVal = pvd[i].getAsString(j) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4486, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle((__pyx_v_v[__pyx_v_i]))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4486, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4576, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4487 + /* "PyCafe.pyx":4577 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -86552,7 +88641,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":4488 + /* "PyCafe.pyx":4578 * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -86561,14 +88650,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4488, __pyx_L104_error) + __PYX_ERR(3, 4578, __pyx_L104_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4488, __pyx_L104_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4578, __pyx_L104_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4489 + /* "PyCafe.pyx":4579 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -86577,7 +88666,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4487 + /* "PyCafe.pyx":4577 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -86595,7 +88684,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4490 + /* "PyCafe.pyx":4580 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -86610,7 +88699,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L106_except_error; __pyx_L106_except_error:; - /* "PyCafe.pyx":4487 + /* "PyCafe.pyx":4577 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): * try: # <<<<<<<<<<<<<< @@ -86630,7 +88719,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_L111_try_end:; } - /* "PyCafe.pyx":4486 + /* "PyCafe.pyx":4576 * bytesVal = pvd[i].getAsString(j) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(v[i]): # <<<<<<<<<<<<<< @@ -86639,7 +88728,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4492 + /* "PyCafe.pyx":4582 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86649,7 +88738,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4493 + /* "PyCafe.pyx":4583 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86665,7 +88754,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "PyCafe.pyx":4494 + /* "PyCafe.pyx":4584 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -86674,14 +88763,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4494, __pyx_L113_error) + __PYX_ERR(3, 4584, __pyx_L113_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4494, __pyx_L113_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4584, __pyx_L113_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4495 + /* "PyCafe.pyx":4585 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -86690,7 +88779,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4493 + /* "PyCafe.pyx":4583 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86708,7 +88797,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4496 + /* "PyCafe.pyx":4586 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -86723,7 +88812,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L115_except_error; __pyx_L115_except_error:; - /* "PyCafe.pyx":4493 + /* "PyCafe.pyx":4583 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86743,7 +88832,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_L120_try_end:; } - /* "PyCafe.pyx":4492 + /* "PyCafe.pyx":4582 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86752,7 +88841,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4498 + /* "PyCafe.pyx":4588 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86762,7 +88851,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4499 + /* "PyCafe.pyx":4589 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86778,7 +88867,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":4500 + /* "PyCafe.pyx":4590 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -86787,14 +88876,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4500, __pyx_L122_error) + __PYX_ERR(3, 4590, __pyx_L122_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4500, __pyx_L122_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4590, __pyx_L122_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4501 + /* "PyCafe.pyx":4591 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -86803,7 +88892,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4499 + /* "PyCafe.pyx":4589 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86821,7 +88910,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4502 + /* "PyCafe.pyx":4592 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -86836,7 +88925,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L124_except_error; __pyx_L124_except_error:; - /* "PyCafe.pyx":4499 + /* "PyCafe.pyx":4589 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -86856,7 +88945,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_L129_try_end:; } - /* "PyCafe.pyx":4498 + /* "PyCafe.pyx":4588 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86865,7 +88954,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4504 + /* "PyCafe.pyx":4594 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86875,19 +88964,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4505 + /* "PyCafe.pyx":4595 * pass * if not encoding: * strVal = pvd[i].getAsString(j) # <<<<<<<<<<<<<< * * localListInner.append(strVal) */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4505, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4504 + /* "PyCafe.pyx":4594 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -86896,18 +88985,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4507 + /* "PyCafe.pyx":4597 * strVal = pvd[i].getAsString(j) * * localListInner.append(strVal) # <<<<<<<<<<<<<< * #localListInner.append(pvd[i].getAsString(j)) * elif dtcheck == CAFE_SHORT: */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4507, __pyx_L1_error) } - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_v_strVal); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4507, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4597, __pyx_L1_error) } + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_v_strVal); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4597, __pyx_L1_error) } - /* "PyCafe.pyx":4481 + /* "PyCafe.pyx":4571 * else: * localListInner = [] * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -86917,7 +89006,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_SHORT: - /* "PyCafe.pyx":4510 + /* "PyCafe.pyx":4600 * #localListInner.append(pvd[i].getAsString(j)) * elif dtcheck == CAFE_SHORT: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -86929,20 +89018,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":4511 + /* "PyCafe.pyx":4601 * 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()): */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4511, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4511, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4601, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":4509 + /* "PyCafe.pyx":4599 * localListInner.append(strVal) * #localListInner.append(pvd[i].getAsString(j)) * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -86952,7 +89041,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_FLOAT: - /* "PyCafe.pyx":4513 + /* "PyCafe.pyx":4603 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_FLOAT: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -86964,20 +89053,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":4514 + /* "PyCafe.pyx":4604 * elif dtcheck == CAFE_FLOAT: * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsDouble(j)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * */ - __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4514, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4514, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4604, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":4512 + /* "PyCafe.pyx":4602 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -86987,7 +89076,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_ENUM: - /* "PyCafe.pyx":4517 + /* "PyCafe.pyx":4607 * elif dtcheck == CAFE_ENUM: * * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -86999,33 +89088,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":4519 + /* "PyCafe.pyx":4609 * 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: */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4519, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_21 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_21 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4519, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_21 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4609, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_1 = ((__pyx_v_self->_c_cafe->isEnum(__pyx_t_21) == 1) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4520 + /* "PyCafe.pyx":4610 * # 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)) */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4520, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4520, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4610, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4519 + /* "PyCafe.pyx":4609 * for j in range(0, pvd[i].getNelem()): * # if enum, string taken as native * if self._c_cafe.isEnum(handleList[i]) == 1: # <<<<<<<<<<<<<< @@ -87035,7 +89124,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P goto __pyx_L137; } - /* "PyCafe.pyx":4522 + /* "PyCafe.pyx":4612 * localListInner.append(pvd[i].getAsString(j)) * else: * localListInner.append(pvd[i].getAsLong(j)) # <<<<<<<<<<<<<< @@ -87043,15 +89132,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P * elif dtcheck == CAFE_CHAR: */ /*else*/ { - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4522, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4522, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4612, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_L137:; } - /* "PyCafe.pyx":4515 + /* "PyCafe.pyx":4605 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsDouble(j)) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -87061,7 +89150,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_CHAR: - /* "PyCafe.pyx":4525 + /* "PyCafe.pyx":4615 * * elif dtcheck == CAFE_CHAR: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -87073,20 +89162,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":4527 + /* "PyCafe.pyx":4617 * for j in range(0, pvd[i].getNelem()): * # pvd[i].getAsChar(j)) * localListInner.append(pvd[i].getAsLong(j)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * for j in range(0, pvd[i].getNelem()): */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4527, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4527, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4617, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":4524 + /* "PyCafe.pyx":4614 * localListInner.append(pvd[i].getAsLong(j)) * * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -87096,7 +89185,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_LONG: - /* "PyCafe.pyx":4529 + /* "PyCafe.pyx":4619 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_LONG: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -87108,20 +89197,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":4530 + /* "PyCafe.pyx":4620 * 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()): */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4530, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4620, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4530, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4620, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":4528 + /* "PyCafe.pyx":4618 * # pvd[i].getAsChar(j)) * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -87131,7 +89220,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P break; case CAFE_DOUBLE: - /* "PyCafe.pyx":4532 + /* "PyCafe.pyx":4622 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_DOUBLE: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -87143,21 +89232,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":4533 + /* "PyCafe.pyx":4623 * 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()): */ - __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4533, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4623, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4533, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4623, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } /*else*/ { - /* "PyCafe.pyx":4535 + /* "PyCafe.pyx":4625 * localListInner.append(pvd[i].getAsDouble(j)) * else: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -87169,18 +89258,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_22; __pyx_t_20+=1) { __pyx_v_j = __pyx_t_20; - /* "PyCafe.pyx":4536 + /* "PyCafe.pyx":4626 * else: * for j in range(0, pvd[i].getNelem()): * localListInner.append(0) # no data # <<<<<<<<<<<<<< * localList.append(localListInner) * */ - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_int_0); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4536, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_int_0); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4626, __pyx_L1_error) } } - /* "PyCafe.pyx":4531 + /* "PyCafe.pyx":4621 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -87191,19 +89280,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P default: break; } - /* "PyCafe.pyx":4537 + /* "PyCafe.pyx":4627 * for j in range(0, pvd[i].getNelem()): * localListInner.append(0) # no data * localList.append(localListInner) # <<<<<<<<<<<<<< * * # free(pvd) */ - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_localListInner); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4537, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_localListInner); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4627, __pyx_L1_error) } __pyx_L71:; } - /* "PyCafe.pyx":4540 + /* "PyCafe.pyx":4630 * * # free(pvd) * if cacheFlag: # <<<<<<<<<<<<<< @@ -87213,7 +89302,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_1 = (__pyx_v_cacheFlag != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4541 + /* "PyCafe.pyx":4631 * # free(pvd) * if cacheFlag: * return localList, statusLocal, statusList # <<<<<<<<<<<<<< @@ -87221,9 +89310,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P * return localList, status, vStatus */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_statusLocal); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4541, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_statusLocal); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4541, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -87238,7 +89327,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4540 + /* "PyCafe.pyx":4630 * * # free(pvd) * if cacheFlag: # <<<<<<<<<<<<<< @@ -87247,7 +89336,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":4543 + /* "PyCafe.pyx":4633 * return localList, statusLocal, statusList * # use vstatus instead of statusList (as cache is NoWait) * return localList, status, vStatus # <<<<<<<<<<<<<< @@ -87255,11 +89344,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4543, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4543, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4543, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -87274,7 +89363,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4257 + /* "PyCafe.pyx":4347 * # int alarmStatus=None, int alarmSev=None): * ################################################################################## * def getCompoundList(self, handleList, str dt='native', bint cacheFlag=False): # <<<<<<<<<<<<<< @@ -87305,7 +89394,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_296getCompoundList(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":4551 +/* "PyCafe.pyx":4641 * ################################################################################## * * def getCompoundPVGroup(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -87349,7 +89438,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_299getCompoundPVGroup(PyObject *__pyx_ } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCompoundPVGroup") < 0)) __PYX_ERR(3, 4551, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCompoundPVGroup") < 0)) __PYX_ERR(3, 4641, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -87365,13 +89454,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_299getCompoundPVGroup(PyObject *__pyx_ } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getCompoundPVGroup", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4551, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getCompoundPVGroup", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4641, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getCompoundPVGroup", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4551, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4641, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_ghandleName, __pyx_v_dt); /* function exit code */ @@ -87421,7 +89510,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj int __pyx_t_17; __Pyx_RefNannySetupContext("getCompoundPVGroup", 0); - /* "PyCafe.pyx":4553 + /* "PyCafe.pyx":4643 * def getCompoundPVGroup(self, ghandleName, str dt='native'): * ################################################################################## * cdef str _METHOD = "getCompoundPVGroup(ghandleName, str dt='native')" # <<<<<<<<<<<<<< @@ -87431,7 +89520,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __Pyx_INCREF(__pyx_kp_u_getCompoundPVGroup_ghandleName_s); __pyx_v__METHOD = __pyx_kp_u_getCompoundPVGroup_ghandleName_s; - /* "PyCafe.pyx":4555 + /* "PyCafe.pyx":4645 * cdef str _METHOD = "getCompoundPVGroup(ghandleName, str dt='native')" * * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -87440,7 +89529,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":4556 + /* "PyCafe.pyx":4646 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -87461,17 +89550,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4557 + /* "PyCafe.pyx":4647 * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4557, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4647, __pyx_L1_error) __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":4556 + /* "PyCafe.pyx":4646 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -87481,7 +89570,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj goto __pyx_L3; } - /* "PyCafe.pyx":4558 + /* "PyCafe.pyx":4648 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -87492,21 +89581,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4559 + /* "PyCafe.pyx":4649 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) # <<<<<<<<<<<<<< * else: * */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 4559, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4559, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 4649, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4649, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4559, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4649, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":4558 + /* "PyCafe.pyx":4648 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -87516,7 +89605,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj goto __pyx_L3; } - /* "PyCafe.pyx":4562 + /* "PyCafe.pyx":4652 * else: * * raise Exception("EXCEPTION RAISED IN PyCafe def getCompoundPVGroup. \n\ # <<<<<<<<<<<<<< @@ -87524,36 +89613,36 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj * */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4562, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4652, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 4562, __pyx_L1_error) + __PYX_ERR(3, 4652, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":4565 + /* "PyCafe.pyx":4655 * First input argument, should be of type if group handle, else if group name") * * handleList = [] # <<<<<<<<<<<<<< * handleList = self.getHandlesFromWithinGroup(ghandle) * */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4565, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4655, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_handleList = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":4566 + /* "PyCafe.pyx":4656 * * handleList = [] * handleList = self.getHandlesFromWithinGroup(ghandle) # <<<<<<<<<<<<<< * * localList = [] */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4566, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4566, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -87568,68 +89657,68 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4566, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4568 + /* "PyCafe.pyx":4658 * handleList = self.getHandlesFromWithinGroup(ghandle) * * localList = [] # <<<<<<<<<<<<<< * statusList = [] * */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4568, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_localList = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":4569 + /* "PyCafe.pyx":4659 * * localList = [] * statusList = [] # <<<<<<<<<<<<<< * * cdef vector[unsigned int] hV */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4569, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4659, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_statusList = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":4573 + /* "PyCafe.pyx":4663 * cdef vector[unsigned int] hV * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * hV.push_back(handleList[i]) * */ - __pyx_t_9 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4573, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(3, 4663, __pyx_L1_error) __pyx_t_10 = __pyx_t_9; for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_i = __pyx_t_11; - /* "PyCafe.pyx":4574 + /* "PyCafe.pyx":4664 * * for i in range(0, len(handleList)): * hV.push_back(handleList[i]) # <<<<<<<<<<<<<< * * self.hh.setCafeDbrTypeV(hV, DBR_TIME) */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4574, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4664, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4574, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4664, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; try { __pyx_v_hV.push_back(__pyx_t_4); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 4574, __pyx_L1_error) + __PYX_ERR(3, 4664, __pyx_L1_error) } } - /* "PyCafe.pyx":4576 + /* "PyCafe.pyx":4666 * hV.push_back(handleList[i]) * * self.hh.setCafeDbrTypeV(hV, DBR_TIME) # <<<<<<<<<<<<<< @@ -87638,14 +89727,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ (void)(__pyx_v_self->hh.setCafeDbrTypeV(__pyx_v_hV, DBR_TIME)); - /* "PyCafe.pyx":4578 + /* "PyCafe.pyx":4668 * self.hh.setCafeDbrTypeV(hV, DBR_TIME) * * localList, status, statusList = self.getCompoundList(handleList, dt) # <<<<<<<<<<<<<< * * cdef PVGroup pvg */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCompoundList); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4578, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCompoundList); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_12 = 0; @@ -87662,7 +89751,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_handleList, __pyx_v_dt}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4578, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4668, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -87670,13 +89759,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_handleList, __pyx_v_dt}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4578, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4668, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_8 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4578, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -87687,7 +89776,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __Pyx_INCREF(__pyx_v_dt); __Pyx_GIVEREF(__pyx_v_dt); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_12, __pyx_v_dt); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4578, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } @@ -87698,7 +89787,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(3, 4578, __pyx_L1_error) + __PYX_ERR(3, 4668, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -87714,17 +89803,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); #else - __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4578, __pyx_L1_error) + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4578, __pyx_L1_error) + __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4578, __pyx_L1_error) + __pyx_t_7 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { Py_ssize_t index = -1; - __pyx_t_13 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 4578, __pyx_L1_error) + __pyx_t_13 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 4668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_14 = Py_TYPE(__pyx_t_13)->tp_iternext; @@ -87734,7 +89823,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __Pyx_GOTREF(__pyx_t_8); index = 2; __pyx_t_7 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_7)) goto __pyx_L8_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 3) < 0) __PYX_ERR(3, 4578, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 3) < 0) __PYX_ERR(3, 4668, __pyx_L1_error) __pyx_t_14 = NULL; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L9_unpacking_done; @@ -87742,7 +89831,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_14 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(3, 4578, __pyx_L1_error) + __PYX_ERR(3, 4668, __pyx_L1_error) __pyx_L9_unpacking_done:; } __Pyx_DECREF_SET(__pyx_v_localList, __pyx_t_6); @@ -87752,7 +89841,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __Pyx_DECREF_SET(__pyx_v_statusList, __pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":4582 + /* "PyCafe.pyx":4672 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -87767,7 +89856,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj #endif /*try:*/ { - /* "PyCafe.pyx":4583 + /* "PyCafe.pyx":4673 * * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) # <<<<<<<<<<<<<< @@ -87777,7 +89866,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj (void)(__pyx_v_self->_c_cafe->groupAttach(__pyx_v_ghandle, __pyx_v_pvg)); } - /* "PyCafe.pyx":4582 + /* "PyCafe.pyx":4672 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -87796,7 +89885,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj } } - /* "PyCafe.pyx":4586 + /* "PyCafe.pyx":4676 * * cdef PVDataHolder * pvd * pvd = pvg.getPVData() # <<<<<<<<<<<<<< @@ -87805,19 +89894,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ __pyx_v_pvd = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":4590 + /* "PyCafe.pyx":4680 * cdef pvdata p1 * * localListToStruct = [] # <<<<<<<<<<<<<< * * cdef int groupStatus = ICAFE_NORMAL */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4590, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4680, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_localListToStruct = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4592 + /* "PyCafe.pyx":4682 * localListToStruct = [] * * cdef int groupStatus = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -87826,7 +89915,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ __pyx_v_groupStatus = ICAFE_NORMAL; - /* "PyCafe.pyx":4594 + /* "PyCafe.pyx":4684 * cdef int groupStatus = ICAFE_NORMAL * * for i in range(0, pvg.getNPV()): # <<<<<<<<<<<<<< @@ -87838,19 +89927,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_15; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":4595 + /* "PyCafe.pyx":4685 * * for i in range(0, pvg.getNPV()): * p1 = pvdata() # <<<<<<<<<<<<<< * * # pvd[i].setDouble(localList[i]) */ - __pyx_t_5 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvdata)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4595, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvdata)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_p1, ((struct __pyx_obj_6PyCafe_pvdata *)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":4598 + /* "PyCafe.pyx":4688 * * # pvd[i].setDouble(localList[i]) * p1 = PVDataHolderToStruct(pvd[i], dt) # <<<<<<<<<<<<<< @@ -87859,50 +89948,50 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ __pyx_t_16.__pyx_n = 1; __pyx_t_16.dt = __pyx_v_dt; - __pyx_t_5 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct((__pyx_v_pvd[__pyx_v_i]), &__pyx_t_16)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4598, __pyx_L1_error) + __pyx_t_5 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct((__pyx_v_pvd[__pyx_v_i]), &__pyx_t_16)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4688, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_p1, ((struct __pyx_obj_6PyCafe_pvdata *)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":4600 + /* "PyCafe.pyx":4690 * p1 = PVDataHolderToStruct(pvd[i], dt) * * if not isinstance(localList[i], (list)): # <<<<<<<<<<<<<< * ll = [] * ll.append(localList[i]) */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_localList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4600, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_localList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4690, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = PyList_Check(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4601 + /* "PyCafe.pyx":4691 * * if not isinstance(localList[i], (list)): * ll = [] # <<<<<<<<<<<<<< * ll.append(localList[i]) * p1.value = ll */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4601, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_ll, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":4602 + /* "PyCafe.pyx":4692 * if not isinstance(localList[i], (list)): * ll = [] * ll.append(localList[i]) # <<<<<<<<<<<<<< * p1.value = ll * else: */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_localList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4602, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_localList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_17 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_5); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 4602, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyList_Append(__pyx_v_ll, __pyx_t_5); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 4692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4603 + /* "PyCafe.pyx":4693 * ll = [] * ll.append(localList[i]) * p1.value = ll # <<<<<<<<<<<<<< @@ -87915,7 +90004,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __Pyx_DECREF(__pyx_v_p1->value); __pyx_v_p1->value = __pyx_v_ll; - /* "PyCafe.pyx":4600 + /* "PyCafe.pyx":4690 * p1 = PVDataHolderToStruct(pvd[i], dt) * * if not isinstance(localList[i], (list)): # <<<<<<<<<<<<<< @@ -87925,7 +90014,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj goto __pyx_L15; } - /* "PyCafe.pyx":4605 + /* "PyCafe.pyx":4695 * p1.value = ll * else: * p1.value = localList[i] # put into List! # <<<<<<<<<<<<<< @@ -87933,9 +90022,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj * p1.status = statusList[i] */ /*else*/ { - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_localList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4605, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_localList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(3, 4605, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(3, 4695, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_5); __Pyx_GOTREF(__pyx_v_p1->value); __Pyx_DECREF(__pyx_v_p1->value); @@ -87944,20 +90033,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj } __pyx_L15:; - /* "PyCafe.pyx":4607 + /* "PyCafe.pyx":4697 * p1.value = localList[i] # put into List! * * p1.status = statusList[i] # <<<<<<<<<<<<<< * * if groupStatus == ICAFE_NORMAL: */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_statusList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4607, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_statusList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4607, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4697, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_p1->status = __pyx_t_12; - /* "PyCafe.pyx":4609 + /* "PyCafe.pyx":4699 * p1.status = statusList[i] * * if groupStatus == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -87967,20 +90056,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __pyx_t_2 = ((__pyx_v_groupStatus == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4610 + /* "PyCafe.pyx":4700 * * if groupStatus == ICAFE_NORMAL: * groupStatus = statusList[i] # <<<<<<<<<<<<<< * * aStatSev = [] */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_statusList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4610, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_statusList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4610, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4700, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_groupStatus = __pyx_t_12; - /* "PyCafe.pyx":4609 + /* "PyCafe.pyx":4699 * p1.status = statusList[i] * * if groupStatus == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -87989,28 +90078,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ } - /* "PyCafe.pyx":4612 + /* "PyCafe.pyx":4702 * groupStatus = statusList[i] * * aStatSev = [] # <<<<<<<<<<<<<< * aStatSev = self.getAlarmStatusSeverity(handleList[i]) * p1.alarmStatus = aStatSev[0] */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4612, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4702, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_aStatSev, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4613 + /* "PyCafe.pyx":4703 * * aStatSev = [] * aStatSev = self.getAlarmStatusSeverity(handleList[i]) # <<<<<<<<<<<<<< * p1.alarmStatus = aStatSev[0] * p1.alarmSeverity = aStatSev[1] */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getAlarmStatusSeverity); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4613, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getAlarmStatusSeverity); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4613, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { @@ -88025,48 +90114,48 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4613, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF_SET(__pyx_v_aStatSev, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4614 + /* "PyCafe.pyx":4704 * aStatSev = [] * aStatSev = self.getAlarmStatusSeverity(handleList[i]) * p1.alarmStatus = aStatSev[0] # <<<<<<<<<<<<<< * p1.alarmSeverity = aStatSev[1] * */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_aStatSev, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4614, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_aStatSev, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4614, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4704, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_p1->alarmStatus = __pyx_t_12; - /* "PyCafe.pyx":4615 + /* "PyCafe.pyx":4705 * aStatSev = self.getAlarmStatusSeverity(handleList[i]) * p1.alarmStatus = aStatSev[0] * p1.alarmSeverity = aStatSev[1] # <<<<<<<<<<<<<< * * p1.ts = self.getTimeStamp(handleList[i]) */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_aStatSev, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4615, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_aStatSev, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4615, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4705, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_p1->alarmSeverity = __pyx_t_12; - /* "PyCafe.pyx":4617 + /* "PyCafe.pyx":4707 * p1.alarmSeverity = aStatSev[1] * * p1.ts = self.getTimeStamp(handleList[i]) # <<<<<<<<<<<<<< * p1.tsDate = self.getTimeStampAsDate(handleList[i]) * */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTimeStamp); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4617, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTimeStamp); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4707, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4617, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4707, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { @@ -88081,26 +90170,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4617, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4707, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(3, 4617, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(3, 4707, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_5); __Pyx_GOTREF(__pyx_v_p1->ts); __Pyx_DECREF(__pyx_v_p1->ts); __pyx_v_p1->ts = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4618 + /* "PyCafe.pyx":4708 * * p1.ts = self.getTimeStamp(handleList[i]) * p1.tsDate = self.getTimeStampAsDate(handleList[i]) # <<<<<<<<<<<<<< * * localListToStruct.append(p1) */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTimeStampAsDate); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4618, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTimeStampAsDate); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4618, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 4708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { @@ -88115,39 +90204,39 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4618, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(3, 4618, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(3, 4708, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_5); __Pyx_GOTREF(__pyx_v_p1->tsDate); __Pyx_DECREF(__pyx_v_p1->tsDate); __pyx_v_p1->tsDate = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4620 + /* "PyCafe.pyx":4710 * p1.tsDate = self.getTimeStampAsDate(handleList[i]) * * localListToStruct.append(p1) # <<<<<<<<<<<<<< * * cpdef pvgroup pg */ - __pyx_t_17 = __Pyx_PyList_Append(__pyx_v_localListToStruct, ((PyObject *)__pyx_v_p1)); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 4620, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyList_Append(__pyx_v_localListToStruct, ((PyObject *)__pyx_v_p1)); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(3, 4710, __pyx_L1_error) } - /* "PyCafe.pyx":4624 + /* "PyCafe.pyx":4714 * cpdef pvgroup pg * * pg = pvgroup() # <<<<<<<<<<<<<< * * pg.pvdata = localListToStruct */ - __pyx_t_5 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvgroup)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4624, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvgroup)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4714, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_pg = ((struct __pyx_obj_6PyCafe_pvgroup *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4626 + /* "PyCafe.pyx":4716 * pg = pvgroup() * * pg.pvdata = localListToStruct # <<<<<<<<<<<<<< @@ -88160,7 +90249,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __Pyx_DECREF(__pyx_v_pg->pvdata); __pyx_v_pg->pvdata = __pyx_v_localListToStruct; - /* "PyCafe.pyx":4629 + /* "PyCafe.pyx":4719 * # pg.pvdata[0].showMax(10) * * pg.npv = pvg.getNPV() # <<<<<<<<<<<<<< @@ -88169,7 +90258,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ __pyx_v_pg->npv = __pyx_v_pvg.getNPV(); - /* "PyCafe.pyx":4630 + /* "PyCafe.pyx":4720 * * pg.npv = pvg.getNPV() * pg.name = pvg.getNameAsString() # <<<<<<<<<<<<<< @@ -88178,7 +90267,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ __pyx_v_pg->name = __pyx_v_pvg.getNameAsString(); - /* "PyCafe.pyx":4631 + /* "PyCafe.pyx":4721 * pg.npv = pvg.getNPV() * pg.name = pvg.getNameAsString() * pg.groupStatus = groupStatus # pvg.getStatusGroup() # <<<<<<<<<<<<<< @@ -88187,7 +90276,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ __pyx_v_pg->groupStatus = __pyx_v_groupStatus; - /* "PyCafe.pyx":4632 + /* "PyCafe.pyx":4722 * pg.name = pvg.getNameAsString() * pg.groupStatus = groupStatus # pvg.getStatusGroup() * pg.groupHandle = pvg.getGroupHandle() # <<<<<<<<<<<<<< @@ -88196,14 +90285,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj */ __pyx_v_pg->groupHandle = __pyx_v_pvg.getGroupHandle(); - /* "PyCafe.pyx":4634 + /* "PyCafe.pyx":4724 * pg.groupHandle = pvg.getGroupHandle() * * pg.showMax(1) # <<<<<<<<<<<<<< * * return pg */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pg), __pyx_n_s_showMax); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4634, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pg), __pyx_n_s_showMax); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 4724, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { @@ -88217,12 +90306,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj } __pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_int_1) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_int_1); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4634, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4724, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4636 + /* "PyCafe.pyx":4726 * pg.showMax(1) * * return pg # <<<<<<<<<<<<<< @@ -88234,7 +90323,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj __pyx_r = ((PyObject *)__pyx_v_pg); goto __pyx_L0; - /* "PyCafe.pyx":4551 + /* "PyCafe.pyx":4641 * ################################################################################## * * def getCompoundPVGroup(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -88269,7 +90358,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_298getCompoundPVGroup(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":4644 +/* "PyCafe.pyx":4734 * ################################################################################## * * def getStrCache(self, handlePV): # <<<<<<<<<<<<<< @@ -88300,7 +90389,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_300getStrCache(struct __pyx_obj_6PyCaf PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getStrCache", 0); - /* "PyCafe.pyx":4645 + /* "PyCafe.pyx":4735 * * def getStrCache(self, handlePV): * return self.getCache(handlePV, 'str') # <<<<<<<<<<<<<< @@ -88308,7 +90397,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_300getStrCache(struct __pyx_obj_6PyCaf * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4645, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -88325,7 +90414,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_300getStrCache(struct __pyx_obj_6PyCaf #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4645, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4735, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -88333,13 +90422,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_300getStrCache(struct __pyx_obj_6PyCaf #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4645, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4735, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4645, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -88350,7 +90439,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_300getStrCache(struct __pyx_obj_6PyCaf __Pyx_INCREF(__pyx_n_u_str); __Pyx_GIVEREF(__pyx_n_u_str); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_str); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4645, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -88359,7 +90448,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_300getStrCache(struct __pyx_obj_6PyCaf __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4644 + /* "PyCafe.pyx":4734 * ################################################################################## * * def getStrCache(self, handlePV): # <<<<<<<<<<<<<< @@ -88383,7 +90472,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_300getStrCache(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":4649 +/* "PyCafe.pyx":4739 * * ################################################################################## * def getIntCache(self, handlePV): # <<<<<<<<<<<<<< @@ -88414,7 +90503,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_302getIntCache(struct __pyx_obj_6PyCaf PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getIntCache", 0); - /* "PyCafe.pyx":4650 + /* "PyCafe.pyx":4740 * ################################################################################## * def getIntCache(self, handlePV): * return self.getCache(handlePV, 'int') # <<<<<<<<<<<<<< @@ -88422,7 +90511,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_302getIntCache(struct __pyx_obj_6PyCaf * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4650, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -88439,7 +90528,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_302getIntCache(struct __pyx_obj_6PyCaf #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4650, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4740, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -88447,13 +90536,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_302getIntCache(struct __pyx_obj_6PyCaf #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4650, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4740, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4650, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -88464,7 +90553,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_302getIntCache(struct __pyx_obj_6PyCaf __Pyx_INCREF(__pyx_n_u_int); __Pyx_GIVEREF(__pyx_n_u_int); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_int); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4650, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -88473,7 +90562,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_302getIntCache(struct __pyx_obj_6PyCaf __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4649 + /* "PyCafe.pyx":4739 * * ################################################################################## * def getIntCache(self, handlePV): # <<<<<<<<<<<<<< @@ -88497,7 +90586,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_302getIntCache(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":4654 +/* "PyCafe.pyx":4744 * * ################################################################################## * def getFloatCache(self, handlePV): # <<<<<<<<<<<<<< @@ -88528,7 +90617,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_304getFloatCache(struct __pyx_obj_6PyC PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getFloatCache", 0); - /* "PyCafe.pyx":4655 + /* "PyCafe.pyx":4745 * ################################################################################## * def getFloatCache(self, handlePV): * return self.getCache(handlePV, 'float') # <<<<<<<<<<<<<< @@ -88536,7 +90625,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_304getFloatCache(struct __pyx_obj_6PyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4655, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -88553,7 +90642,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_304getFloatCache(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4655, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4745, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -88561,13 +90650,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_304getFloatCache(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4655, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4745, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4655, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -88578,7 +90667,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_304getFloatCache(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_float); __Pyx_GIVEREF(__pyx_n_u_float); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_float); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4655, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -88587,7 +90676,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_304getFloatCache(struct __pyx_obj_6PyC __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4654 + /* "PyCafe.pyx":4744 * * ################################################################################## * def getFloatCache(self, handlePV): # <<<<<<<<<<<<<< @@ -88611,7 +90700,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_304getFloatCache(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":4660 +/* "PyCafe.pyx":4750 * ################################################################################## * * def getCache(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -88655,7 +90744,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_307getCache(PyObject *__pyx_v_self, Py } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCache") < 0)) __PYX_ERR(3, 4660, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCache") < 0)) __PYX_ERR(3, 4750, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -88671,13 +90760,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_307getCache(PyObject *__pyx_v_self, Py } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4660, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4750, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4660, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4750, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_306getCache(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_dt); /* function exit code */ @@ -88713,7 +90802,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C PyObject *__pyx_t_10 = NULL; __Pyx_RefNannySetupContext("getCache", 0); - /* "PyCafe.pyx":4661 + /* "PyCafe.pyx":4751 * * def getCache(self, handlePV, str dt='native'): * cdef str _METHOD = "getCache(handlePV, str dt='native')" # <<<<<<<<<<<<<< @@ -88723,7 +90812,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_kp_u_getCache_handlePV_str_dt_native); __pyx_v__METHOD = __pyx_kp_u_getCache_handlePV_str_dt_native; - /* "PyCafe.pyx":4663 + /* "PyCafe.pyx":4753 * cdef str _METHOD = "getCache(handlePV, str dt='native')" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -88732,7 +90821,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ __pyx_v_handle = 0; - /* "PyCafe.pyx":4665 + /* "PyCafe.pyx":4755 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -88753,17 +90842,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4666 + /* "PyCafe.pyx":4756 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4666, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4756, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":4665 + /* "PyCafe.pyx":4755 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -88773,7 +90862,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C goto __pyx_L3; } - /* "PyCafe.pyx":4667 + /* "PyCafe.pyx":4757 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -88784,21 +90873,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4668 + /* "PyCafe.pyx":4758 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getCache. \n\ */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 4668, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4668, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 4758, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4668, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4758, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":4667 + /* "PyCafe.pyx":4757 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -88808,7 +90897,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C goto __pyx_L3; } - /* "PyCafe.pyx":4670 + /* "PyCafe.pyx":4760 * handle = self.checkForHandle(handlePV) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getCache. \n\ # <<<<<<<<<<<<<< @@ -88816,15 +90905,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4670, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4760, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 4670, __pyx_L1_error) + __PYX_ERR(3, 4760, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":4673 + /* "PyCafe.pyx":4763 * First input argument, should be of type if handle, else if PV") * * cdef long dtr = 0 # <<<<<<<<<<<<<< @@ -88833,34 +90922,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ __pyx_v_dtr = 0; - /* "PyCafe.pyx":4674 + /* "PyCafe.pyx":4764 * * cdef long dtr = 0 * status = self.hh.getDataTypeNative(handle, dtr) # <<<<<<<<<<<<<< * * if status != ICAFE_NORMAL: */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->hh.getDataTypeNative(__pyx_v_handle, __pyx_v_dtr)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4674, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->hh.getDataTypeNative(__pyx_v_handle, __pyx_v_dtr)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_status = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":4676 + /* "PyCafe.pyx":4766 * status = self.hh.getDataTypeNative(handle, dtr) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: */ - __pyx_t_5 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4676, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyObject_RichCompare(__pyx_v_status, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4676, __pyx_L1_error) + __pyx_t_6 = PyObject_RichCompare(__pyx_v_status, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4766, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4676, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4766, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_1) { - /* "PyCafe.pyx":4677 + /* "PyCafe.pyx":4767 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -88870,7 +90959,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4678 + /* "PyCafe.pyx":4768 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -88880,17 +90969,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4679 + /* "PyCafe.pyx":4769 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< * else: * self._c_cafe.printStatus(handle, status) */ - __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4679, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4769, __pyx_L1_error) __pyx_v_self->_c_cafe->printStatusMessage(__pyx_t_7); - /* "PyCafe.pyx":4678 + /* "PyCafe.pyx":4768 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -88900,7 +90989,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C goto __pyx_L8; } - /* "PyCafe.pyx":4681 + /* "PyCafe.pyx":4771 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -88908,12 +90997,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * raise Exception( */ /*else*/ { - __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4681, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4771, __pyx_L1_error) __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, __pyx_t_7); } __pyx_L8:; - /* "PyCafe.pyx":4677 + /* "PyCafe.pyx":4767 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -88922,7 +91011,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4682 + /* "PyCafe.pyx":4772 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -88932,31 +91021,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4684 + /* "PyCafe.pyx":4774 * if self._enable_exceptions: * raise Exception( * "EXCEPTION RAISED in PyCafe def getCache. Status = %d" % status) # <<<<<<<<<<<<<< * return None * */ - __pyx_t_6 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_g_3, __pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4684, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_g_3, __pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4774, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":4683 + /* "PyCafe.pyx":4773 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def getCache. Status = %d" % status) * return None */ - __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4683, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4773, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 4683, __pyx_L1_error) + __PYX_ERR(3, 4773, __pyx_L1_error) - /* "PyCafe.pyx":4682 + /* "PyCafe.pyx":4772 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -88965,7 +91054,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4685 + /* "PyCafe.pyx":4775 * raise Exception( * "EXCEPTION RAISED in PyCafe def getCache. Status = %d" % status) * return None # <<<<<<<<<<<<<< @@ -88976,7 +91065,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":4676 + /* "PyCafe.pyx":4766 * status = self.hh.getDataTypeNative(handle, dtr) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -88986,7 +91075,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C goto __pyx_L6; } - /* "PyCafe.pyx":4687 + /* "PyCafe.pyx":4777 * return None * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -89005,7 +91094,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4688 + /* "PyCafe.pyx":4778 * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if self._c_cafe.isChannelConnected(handle) is False: # <<<<<<<<<<<<<< @@ -89015,7 +91104,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_self->_c_cafe->isChannelConnected(__pyx_v_handle) == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4689 + /* "PyCafe.pyx":4779 * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if self._c_cafe.isChannelConnected(handle) is False: * self._c_cafe.getChannelInfo(handle, self.channelInfo) # <<<<<<<<<<<<<< @@ -89024,7 +91113,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ (void)(__pyx_v_self->_c_cafe->getChannelInfo(__pyx_v_handle, __pyx_v_self->channelInfo)); - /* "PyCafe.pyx":4690 + /* "PyCafe.pyx":4780 * if self._c_cafe.isChannelConnected(handle) is False: * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -89034,7 +91123,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4691 + /* "PyCafe.pyx":4781 * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus( # <<<<<<<<<<<<<< @@ -89043,7 +91132,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, __pyx_v_self->channelInfo.getCafeConnectionState()); - /* "PyCafe.pyx":4690 + /* "PyCafe.pyx":4780 * if self._c_cafe.isChannelConnected(handle) is False: * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -89052,7 +91141,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4693 + /* "PyCafe.pyx":4783 * self._c_cafe.printStatus( * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -89062,84 +91151,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4695 + /* "PyCafe.pyx":4785 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4695, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4695, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4695, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4695, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4785, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4785, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 4695, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 4785, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4696 + /* "PyCafe.pyx":4786 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=self.channelInfo.getCafeConnectionState(), * _error_text=self.cs.code( */ - __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4696, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 4695, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 4785, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4697 + /* "PyCafe.pyx":4787 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), # <<<<<<<<<<<<<< * _error_text=self.cs.code( * self.channelInfo.getCafeConnectionState()), */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->channelInfo.getCafeConnectionState()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4697, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->channelInfo.getCafeConnectionState()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 4695, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 4785, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4698 + /* "PyCafe.pyx":4788 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), * _error_text=self.cs.code( # <<<<<<<<<<<<<< * self.channelInfo.getCafeConnectionState()), * _error_info=self.cs.info( */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4698, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 4695, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 4785, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4700 + /* "PyCafe.pyx":4790 * _error_text=self.cs.code( * self.channelInfo.getCafeConnectionState()), * _error_info=self.cs.info( # <<<<<<<<<<<<<< * self.channelInfo.getCafeConnectionState())) * raise _cafeException */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4700, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 4695, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 4785, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4694 + /* "PyCafe.pyx":4784 * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4694, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4702 + /* "PyCafe.pyx":4792 * _error_info=self.cs.info( * self.channelInfo.getCafeConnectionState())) * raise _cafeException # <<<<<<<<<<<<<< @@ -89147,9 +91236,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 4702, __pyx_L1_error) + __PYX_ERR(3, 4792, __pyx_L1_error) - /* "PyCafe.pyx":4693 + /* "PyCafe.pyx":4783 * self._c_cafe.printStatus( * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -89158,7 +91247,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4703 + /* "PyCafe.pyx":4793 * self.channelInfo.getCafeConnectionState())) * raise _cafeException * return None # <<<<<<<<<<<<<< @@ -89169,7 +91258,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":4688 + /* "PyCafe.pyx":4778 * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if self._c_cafe.isChannelConnected(handle) is False: # <<<<<<<<<<<<<< @@ -89178,7 +91267,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4706 + /* "PyCafe.pyx":4796 * * # Likely to be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -89188,7 +91277,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4707 + /* "PyCafe.pyx":4797 * # Likely to be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) # <<<<<<<<<<<<<< @@ -89197,7 +91286,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, ICAFE_TYPENOTCONN); - /* "PyCafe.pyx":4706 + /* "PyCafe.pyx":4796 * * # Likely to be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -89206,7 +91295,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4708 + /* "PyCafe.pyx":4798 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -89216,84 +91305,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4710 + /* "PyCafe.pyx":4800 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4710, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4710, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4710, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4710, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4800, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4800, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 4710, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 4800, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4711 + /* "PyCafe.pyx":4801 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), */ - __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4711, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4801, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 4710, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 4800, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4712 + /* "PyCafe.pyx":4802 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, # <<<<<<<<<<<<<< * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) */ - __pyx_t_5 = __Pyx_PyInt_From_CAFE_CFT_STATE(ICAFE_TYPENOTCONN); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4712, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_CAFE_CFT_STATE(ICAFE_TYPENOTCONN); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4802, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 4710, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 4800, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4713 + /* "PyCafe.pyx":4803 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), # <<<<<<<<<<<<<< * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4713, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4803, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 4710, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 4800, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4714 + /* "PyCafe.pyx":4804 * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) # <<<<<<<<<<<<<< * raise _cafeException * return None */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4714, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4804, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 4710, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 4800, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4709 + /* "PyCafe.pyx":4799 * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4709, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4799, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4715 + /* "PyCafe.pyx":4805 * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException # <<<<<<<<<<<<<< @@ -89301,9 +91390,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 4715, __pyx_L1_error) + __PYX_ERR(3, 4805, __pyx_L1_error) - /* "PyCafe.pyx":4708 + /* "PyCafe.pyx":4798 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -89312,7 +91401,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4716 + /* "PyCafe.pyx":4806 * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException * return None # <<<<<<<<<<<<<< @@ -89323,7 +91412,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":4687 + /* "PyCafe.pyx":4777 * return None * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -89333,7 +91422,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C } __pyx_L6:; - /* "PyCafe.pyx":4718 + /* "PyCafe.pyx":4808 * return None * * cdef int dtcheck = dtr # <<<<<<<<<<<<<< @@ -89342,23 +91431,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ __pyx_v_dtcheck = __pyx_v_dtr; - /* "PyCafe.pyx":4719 + /* "PyCafe.pyx":4809 * * cdef int dtcheck = dtr * dtcheck = getMatchedDataType(dt, dtr) # <<<<<<<<<<<<<< * * cdef bytes bVal */ - __pyx_t_5 = __Pyx_PyInt_From_long(__pyx_v_dtr); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4719, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_long(__pyx_v_dtr); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4809, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4719, __pyx_L1_error) + __pyx_t_6 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4809, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4719, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4809, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_dtcheck = __pyx_t_7; - /* "PyCafe.pyx":4723 + /* "PyCafe.pyx":4813 * cdef bytes bVal * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -89368,41 +91457,41 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":4724 + /* "PyCafe.pyx":4814 * * if dtcheck in [CAFE_STRING]: * status = self._c_cafe.getCacheString(handle, self.valStr) # <<<<<<<<<<<<<< * if status == ICAFE_NORMAL: * bVal = self.valStr */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheString(__pyx_v_handle, __pyx_v_self->valStr)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4724, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheString(__pyx_v_handle, __pyx_v_self->valStr)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_status, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4725 + /* "PyCafe.pyx":4815 * if dtcheck in [CAFE_STRING]: * status = self._c_cafe.getCacheString(handle, self.valStr) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * bVal = self.valStr * encoding = False */ - __pyx_t_6 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4725, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4815, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyObject_RichCompare(__pyx_v_status, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4725, __pyx_L1_error) + __pyx_t_5 = PyObject_RichCompare(__pyx_v_status, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4815, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4725, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4815, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_2) { - /* "PyCafe.pyx":4726 + /* "PyCafe.pyx":4816 * status = self._c_cafe.getCacheString(handle, self.valStr) * if status == ICAFE_NORMAL: * bVal = self.valStr # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): */ - __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4726, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __pyx_t_5; __Pyx_INCREF(__pyx_t_6); @@ -89410,7 +91499,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_v_bVal = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4727 + /* "PyCafe.pyx":4817 * if status == ICAFE_NORMAL: * bVal = self.valStr * encoding = False # <<<<<<<<<<<<<< @@ -89419,21 +91508,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":4728 + /* "PyCafe.pyx":4818 * bVal = self.valStr * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): # <<<<<<<<<<<<<< * try: * strVal = (bVal).decode('latin-1') */ - __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4728, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_6, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4728, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_6, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4818, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4729 + /* "PyCafe.pyx":4819 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -89449,7 +91538,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_10); /*try:*/ { - /* "PyCafe.pyx":4730 + /* "PyCafe.pyx":4820 * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: * strVal = (bVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -89458,14 +91547,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4730, __pyx_L17_error) + __PYX_ERR(3, 4820, __pyx_L17_error) } - __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4730, __pyx_L17_error) + __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4820, __pyx_L17_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_strVal = __pyx_t_6; __pyx_t_6 = 0; - /* "PyCafe.pyx":4731 + /* "PyCafe.pyx":4821 * try: * strVal = (bVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -89474,7 +91563,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4729 + /* "PyCafe.pyx":4819 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -89490,7 +91579,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4732 + /* "PyCafe.pyx":4822 * strVal = (bVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -89505,7 +91594,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C goto __pyx_L19_except_error; __pyx_L19_except_error:; - /* "PyCafe.pyx":4729 + /* "PyCafe.pyx":4819 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -89525,7 +91614,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_L22_try_end:; } - /* "PyCafe.pyx":4728 + /* "PyCafe.pyx":4818 * bVal = self.valStr * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): # <<<<<<<<<<<<<< @@ -89534,7 +91623,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4734 + /* "PyCafe.pyx":4824 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -89544,7 +91633,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4735 + /* "PyCafe.pyx":4825 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -89560,7 +91649,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_8); /*try:*/ { - /* "PyCafe.pyx":4736 + /* "PyCafe.pyx":4826 * if not encoding: * try: * strVal = (bVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -89569,14 +91658,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4736, __pyx_L24_error) + __PYX_ERR(3, 4826, __pyx_L24_error) } - __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4736, __pyx_L24_error) + __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4826, __pyx_L24_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4737 + /* "PyCafe.pyx":4827 * try: * strVal = (bVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -89585,7 +91674,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4735 + /* "PyCafe.pyx":4825 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -89601,7 +91690,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4738 + /* "PyCafe.pyx":4828 * strVal = (bVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -89616,7 +91705,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C goto __pyx_L26_except_error; __pyx_L26_except_error:; - /* "PyCafe.pyx":4735 + /* "PyCafe.pyx":4825 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -89636,7 +91725,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_L29_try_end:; } - /* "PyCafe.pyx":4734 + /* "PyCafe.pyx":4824 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -89645,7 +91734,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4740 + /* "PyCafe.pyx":4830 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -89655,7 +91744,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4741 + /* "PyCafe.pyx":4831 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -89671,7 +91760,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_10); /*try:*/ { - /* "PyCafe.pyx":4742 + /* "PyCafe.pyx":4832 * if not encoding: * try: * strVal = (bVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -89680,14 +91769,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4742, __pyx_L31_error) + __PYX_ERR(3, 4832, __pyx_L31_error) } - __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4742, __pyx_L31_error) + __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4832, __pyx_L31_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4743 + /* "PyCafe.pyx":4833 * try: * strVal = (bVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -89696,7 +91785,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4741 + /* "PyCafe.pyx":4831 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -89712,7 +91801,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4744 + /* "PyCafe.pyx":4834 * strVal = (bVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -89727,7 +91816,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C goto __pyx_L33_except_error; __pyx_L33_except_error:; - /* "PyCafe.pyx":4741 + /* "PyCafe.pyx":4831 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -89747,7 +91836,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_L36_try_end:; } - /* "PyCafe.pyx":4740 + /* "PyCafe.pyx":4830 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -89756,7 +91845,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4746 + /* "PyCafe.pyx":4836 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -89766,19 +91855,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4747 + /* "PyCafe.pyx":4837 * pass * if not encoding: * strVal = self.valStr # <<<<<<<<<<<<<< * * return strVal */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4747, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4837, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4746 + /* "PyCafe.pyx":4836 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -89787,7 +91876,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4749 + /* "PyCafe.pyx":4839 * strVal = self.valStr * * return strVal # <<<<<<<<<<<<<< @@ -89795,12 +91884,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * */ __Pyx_XDECREF(__pyx_r); - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4749, __pyx_L1_error) } + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 4839, __pyx_L1_error) } __Pyx_INCREF(__pyx_v_strVal); __pyx_r = __pyx_v_strVal; goto __pyx_L0; - /* "PyCafe.pyx":4725 + /* "PyCafe.pyx":4815 * if dtcheck in [CAFE_STRING]: * status = self._c_cafe.getCacheString(handle, self.valStr) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -89809,7 +91898,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4723 + /* "PyCafe.pyx":4813 * cdef bytes bVal * * if dtcheck in [CAFE_STRING]: # <<<<<<<<<<<<<< @@ -89819,7 +91908,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C break; case CAFE_SHORT: - /* "PyCafe.pyx":4752 + /* "PyCafe.pyx":4842 * * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -89829,34 +91918,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C case CAFE_CHAR: case CAFE_LONG: - /* "PyCafe.pyx":4753 + /* "PyCafe.pyx":4843 * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: * status = self._c_cafe.getCacheLong(handle, self.valInt) # <<<<<<<<<<<<<< * if status == ICAFE_NORMAL: * return self.valInt */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheLong(__pyx_v_handle, __pyx_v_self->valInt)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4753, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheLong(__pyx_v_handle, __pyx_v_self->valInt)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_status, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4754 + /* "PyCafe.pyx":4844 * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: * status = self._c_cafe.getCacheLong(handle, self.valInt) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * return self.valInt * */ - __pyx_t_6 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4754, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4844, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyObject_RichCompare(__pyx_v_status, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4754, __pyx_L1_error) + __pyx_t_5 = PyObject_RichCompare(__pyx_v_status, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4754, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_1) { - /* "PyCafe.pyx":4755 + /* "PyCafe.pyx":4845 * status = self._c_cafe.getCacheLong(handle, self.valInt) * if status == ICAFE_NORMAL: * return self.valInt # <<<<<<<<<<<<<< @@ -89864,13 +91953,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_dbr_long_t(__pyx_v_self->valInt); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4755, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_dbr_long_t(__pyx_v_self->valInt); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4754 + /* "PyCafe.pyx":4844 * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: * status = self._c_cafe.getCacheLong(handle, self.valInt) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -89879,7 +91968,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4752 + /* "PyCafe.pyx":4842 * * * elif dtcheck in [CAFE_SHORT, CAFE_CHAR, CAFE_LONG]: # <<<<<<<<<<<<<< @@ -89889,7 +91978,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C break; case CAFE_FLOAT: - /* "PyCafe.pyx":4757 + /* "PyCafe.pyx":4847 * return self.valInt * * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -89898,34 +91987,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ case CAFE_DOUBLE: - /* "PyCafe.pyx":4758 + /* "PyCafe.pyx":4848 * * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: * status = self._c_cafe.getCacheDouble(handle, self.valFloat) # <<<<<<<<<<<<<< * if status == ICAFE_NORMAL: * return self.valFloat */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheDouble(__pyx_v_handle, __pyx_v_self->valFloat)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4758, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheDouble(__pyx_v_handle, __pyx_v_self->valFloat)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_status, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4759 + /* "PyCafe.pyx":4849 * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: * status = self._c_cafe.getCacheDouble(handle, self.valFloat) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * return self.valFloat * */ - __pyx_t_5 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4759, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyObject_RichCompare(__pyx_v_status, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4759, __pyx_L1_error) + __pyx_t_6 = PyObject_RichCompare(__pyx_v_status, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4849, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4759, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4849, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_1) { - /* "PyCafe.pyx":4760 + /* "PyCafe.pyx":4850 * status = self._c_cafe.getCacheDouble(handle, self.valFloat) * if status == ICAFE_NORMAL: * return self.valFloat # <<<<<<<<<<<<<< @@ -89933,13 +92022,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * elif dtcheck == CAFE_ENUM: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->valFloat); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4760, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_self->valFloat); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4850, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4759 + /* "PyCafe.pyx":4849 * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: * status = self._c_cafe.getCacheDouble(handle, self.valFloat) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -89948,7 +92037,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4757 + /* "PyCafe.pyx":4847 * return self.valInt * * elif dtcheck in [CAFE_FLOAT, CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -89958,7 +92047,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C break; case CAFE_ENUM: - /* "PyCafe.pyx":4764 + /* "PyCafe.pyx":4854 * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native * if self._c_cafe.isEnum(handle): # <<<<<<<<<<<<<< @@ -89968,34 +92057,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (__pyx_v_self->_c_cafe->isEnum(__pyx_v_handle) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4765 + /* "PyCafe.pyx":4855 * # 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 */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheString(__pyx_v_handle, __pyx_v_self->valStr)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4765, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheString(__pyx_v_handle, __pyx_v_self->valStr)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_status, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4766 + /* "PyCafe.pyx":4856 * if self._c_cafe.isEnum(handle): * status = self._c_cafe.getCacheString(handle, self.valStr) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * return self.valStr * else: */ - __pyx_t_6 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4766, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyObject_RichCompare(__pyx_v_status, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4766, __pyx_L1_error) + __pyx_t_5 = PyObject_RichCompare(__pyx_v_status, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4856, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4766, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4856, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_1) { - /* "PyCafe.pyx":4767 + /* "PyCafe.pyx":4857 * status = self._c_cafe.getCacheString(handle, self.valStr) * if status == ICAFE_NORMAL: * return self.valStr # <<<<<<<<<<<<<< @@ -90003,13 +92092,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * status = self._c_cafe.getCacheLong(handle, self.valInt) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4767, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->valStr); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4766 + /* "PyCafe.pyx":4856 * if self._c_cafe.isEnum(handle): * status = self._c_cafe.getCacheString(handle, self.valStr) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -90018,7 +92107,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4764 + /* "PyCafe.pyx":4854 * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native * if self._c_cafe.isEnum(handle): # <<<<<<<<<<<<<< @@ -90028,7 +92117,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C goto __pyx_L40; } - /* "PyCafe.pyx":4769 + /* "PyCafe.pyx":4859 * return self.valStr * else: * status = self._c_cafe.getCacheLong(handle, self.valInt) # <<<<<<<<<<<<<< @@ -90036,27 +92125,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * return self.valInt */ /*else*/ { - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheLong(__pyx_v_handle, __pyx_v_self->valInt)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4769, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->getCacheLong(__pyx_v_handle, __pyx_v_self->valInt)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4859, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_status, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4770 + /* "PyCafe.pyx":4860 * else: * status = self._c_cafe.getCacheLong(handle, self.valInt) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * return self.valInt * */ - __pyx_t_5 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4770, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyObject_RichCompare(__pyx_v_status, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4770, __pyx_L1_error) + __pyx_t_6 = PyObject_RichCompare(__pyx_v_status, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4860, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4770, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4860, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_1) { - /* "PyCafe.pyx":4771 + /* "PyCafe.pyx":4861 * status = self._c_cafe.getCacheLong(handle, self.valInt) * if status == ICAFE_NORMAL: * return self.valInt # <<<<<<<<<<<<<< @@ -90064,13 +92153,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * else: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_dbr_long_t(__pyx_v_self->valInt); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4771, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_dbr_long_t(__pyx_v_self->valInt); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4861, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4770 + /* "PyCafe.pyx":4860 * else: * status = self._c_cafe.getCacheLong(handle, self.valInt) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -90081,7 +92170,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C } __pyx_L40:; - /* "PyCafe.pyx":4762 + /* "PyCafe.pyx":4852 * return self.valFloat * * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -90091,56 +92180,56 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C break; default: - /* "PyCafe.pyx":4774 + /* "PyCafe.pyx":4864 * * else: * status = self.hh.getStatus(handle) # <<<<<<<<<<<<<< * if status == ICAFE_NORMAL: * print("This line in PyCafe def getCache should never appear!") */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->hh.getStatus(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4774, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->hh.getStatus(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4864, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_status, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4775 + /* "PyCafe.pyx":4865 * 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") */ - __pyx_t_6 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4775, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4865, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyObject_RichCompare(__pyx_v_status, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4775, __pyx_L1_error) + __pyx_t_5 = PyObject_RichCompare(__pyx_v_status, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4865, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4775, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4865, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_1) { - /* "PyCafe.pyx":4776 + /* "PyCafe.pyx":4866 * 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 */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4776, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4777 + /* "PyCafe.pyx":4867 * if status == ICAFE_NORMAL: * print("This line in PyCafe def getCache should never appear!") * print("Datatype unknown, returning value 0") # <<<<<<<<<<<<<< * return 0 * */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4777, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4867, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4778 + /* "PyCafe.pyx":4868 * print("This line in PyCafe def getCache should never appear!") * print("Datatype unknown, returning value 0") * return 0 # <<<<<<<<<<<<<< @@ -90152,7 +92241,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_r = __pyx_int_0; goto __pyx_L0; - /* "PyCafe.pyx":4775 + /* "PyCafe.pyx":4865 * else: * status = self.hh.getStatus(handle) * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -90163,22 +92252,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C break; } - /* "PyCafe.pyx":4780 + /* "PyCafe.pyx":4870 * return 0 * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: */ - __pyx_t_5 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4780, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyObject_RichCompare(__pyx_v_status, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4780, __pyx_L1_error) + __pyx_t_6 = PyObject_RichCompare(__pyx_v_status, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4780, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 4870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_1) { - /* "PyCafe.pyx":4781 + /* "PyCafe.pyx":4871 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -90188,7 +92277,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4782 + /* "PyCafe.pyx":4872 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -90198,17 +92287,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4783 + /* "PyCafe.pyx":4873 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< * else: * self._c_cafe.printStatus(handle, status) */ - __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4783, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4873, __pyx_L1_error) __pyx_v_self->_c_cafe->printStatusMessage(__pyx_t_7); - /* "PyCafe.pyx":4782 + /* "PyCafe.pyx":4872 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -90218,7 +92307,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C goto __pyx_L46; } - /* "PyCafe.pyx":4785 + /* "PyCafe.pyx":4875 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -90226,12 +92315,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * if self._enable_exceptions: */ /*else*/ { - __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4785, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4875, __pyx_L1_error) __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, __pyx_t_7); } __pyx_L46:; - /* "PyCafe.pyx":4781 + /* "PyCafe.pyx":4871 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -90240,7 +92329,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4787 + /* "PyCafe.pyx":4877 * self._c_cafe.printStatus(handle, status) * * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -90250,75 +92339,75 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4789 + /* "PyCafe.pyx":4879 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4789, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4879, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4789, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4789, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4789, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4879, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4879, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4879, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 4789, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 4879, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4790 + /* "PyCafe.pyx":4880 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4790, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 4789, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 4879, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4791 + /* "PyCafe.pyx":4881 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_v_status) < 0) __PYX_ERR(3, 4789, __pyx_L1_error) - __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4791, __pyx_L1_error) - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_t_7)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4791, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_v_status) < 0) __PYX_ERR(3, 4879, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4881, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_t_7)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 4789, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 4879, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4792 + /* "PyCafe.pyx":4882 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4792, __pyx_L1_error) - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_t_7)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4792, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_status); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4882, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_t_7)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 4789, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 4879, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4788 + /* "PyCafe.pyx":4878 * * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4788, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4793 + /* "PyCafe.pyx":4883 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -90326,9 +92415,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C * ################################################################################## */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 4793, __pyx_L1_error) + __PYX_ERR(3, 4883, __pyx_L1_error) - /* "PyCafe.pyx":4787 + /* "PyCafe.pyx":4877 * self._c_cafe.printStatus(handle, status) * * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -90337,7 +92426,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4780 + /* "PyCafe.pyx":4870 * return 0 * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -90346,7 +92435,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":4660 + /* "PyCafe.pyx":4750 * ################################################################################## * * def getCache(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -90373,7 +92462,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_306getCache(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":4799 +/* "PyCafe.pyx":4889 * ################################################################################## * * def getStrArrayCache(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -90417,7 +92506,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_309getStrArrayCache(PyObject *__pyx_v_ } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getStrArrayCache") < 0)) __PYX_ERR(3, 4799, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getStrArrayCache") < 0)) __PYX_ERR(3, 4889, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -90433,13 +92522,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_309getStrArrayCache(PyObject *__pyx_v_ } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getStrArrayCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4799, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getStrArrayCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4889, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getStrArrayCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 4799, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 4889, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_308getStrArrayCache(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_art); /* function exit code */ @@ -90460,7 +92549,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_308getStrArrayCache(struct __pyx_obj_6 PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getStrArrayCache", 0); - /* "PyCafe.pyx":4800 + /* "PyCafe.pyx":4890 * * def getStrArrayCache(self, handlePV, str art='numpy'): * return self.getArrayCache(handlePV, dt='str', art=art) # <<<<<<<<<<<<<< @@ -90468,18 +92557,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_308getStrArrayCache(struct __pyx_obj_6 * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArrayCache); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4800, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArrayCache); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4800, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4800, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 4800, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 4800, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4800, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 4890, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 4890, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -90488,7 +92577,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_308getStrArrayCache(struct __pyx_obj_6 __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4799 + /* "PyCafe.pyx":4889 * ################################################################################## * * def getStrArrayCache(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -90512,7 +92601,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_308getStrArrayCache(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":4804 +/* "PyCafe.pyx":4894 * * ################################################################################## * def getIntArrayCache(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -90556,7 +92645,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_311getIntArrayCache(PyObject *__pyx_v_ } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getIntArrayCache") < 0)) __PYX_ERR(3, 4804, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getIntArrayCache") < 0)) __PYX_ERR(3, 4894, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -90572,13 +92661,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_311getIntArrayCache(PyObject *__pyx_v_ } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getIntArrayCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4804, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getIntArrayCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4894, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getIntArrayCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 4804, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 4894, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_310getIntArrayCache(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_art); /* function exit code */ @@ -90599,7 +92688,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_310getIntArrayCache(struct __pyx_obj_6 PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getIntArrayCache", 0); - /* "PyCafe.pyx":4805 + /* "PyCafe.pyx":4895 * ################################################################################## * def getIntArrayCache(self, handlePV, str art='numpy'): * return self.getArrayCache(handlePV, dt='int', art=art) # <<<<<<<<<<<<<< @@ -90607,18 +92696,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_310getIntArrayCache(struct __pyx_obj_6 * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArrayCache); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4805, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArrayCache); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4805, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4805, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 4805, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 4805, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4805, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 4895, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 4895, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -90627,7 +92716,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_310getIntArrayCache(struct __pyx_obj_6 __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4804 + /* "PyCafe.pyx":4894 * * ################################################################################## * def getIntArrayCache(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -90651,7 +92740,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_310getIntArrayCache(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":4809 +/* "PyCafe.pyx":4899 * * ################################################################################## * def getFloatArrayCache(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -90695,7 +92784,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_313getFloatArrayCache(PyObject *__pyx_ } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getFloatArrayCache") < 0)) __PYX_ERR(3, 4809, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getFloatArrayCache") < 0)) __PYX_ERR(3, 4899, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -90711,13 +92800,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_313getFloatArrayCache(PyObject *__pyx_ } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getFloatArrayCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4809, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getFloatArrayCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4899, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getFloatArrayCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 4809, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 4899, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_312getFloatArrayCache(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_art); /* function exit code */ @@ -90738,7 +92827,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_312getFloatArrayCache(struct __pyx_obj PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getFloatArrayCache", 0); - /* "PyCafe.pyx":4810 + /* "PyCafe.pyx":4900 * ################################################################################## * def getFloatArrayCache(self, handlePV, str art='numpy'): * return self.getArrayCache(handlePV, dt='float', art=art) # <<<<<<<<<<<<<< @@ -90746,18 +92835,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_312getFloatArrayCache(struct __pyx_obj * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArrayCache); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4810, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getArrayCache); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4900, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4810, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4900, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_handlePV); - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4810, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4900, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 4810, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 4810, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4810, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 4900, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_art, __pyx_v_art) < 0) __PYX_ERR(3, 4900, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4900, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -90766,7 +92855,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_312getFloatArrayCache(struct __pyx_obj __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4809 + /* "PyCafe.pyx":4899 * * ################################################################################## * def getFloatArrayCache(self, handlePV, str art='numpy'): # <<<<<<<<<<<<<< @@ -90790,7 +92879,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_312getFloatArrayCache(struct __pyx_obj return __pyx_r; } -/* "PyCafe.pyx":4814 +/* "PyCafe.pyx":4904 * * ################################################################################## * def getArrayCache(self, handlePV, str dt='native', str art='numpy'): # <<<<<<<<<<<<<< @@ -90844,7 +92933,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_315getArrayCache(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getArrayCache") < 0)) __PYX_ERR(3, 4814, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getArrayCache") < 0)) __PYX_ERR(3, 4904, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -90863,14 +92952,14 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_315getArrayCache(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getArrayCache", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4814, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getArrayCache", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4904, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getArrayCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4814, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 4814, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 4904, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_art), (&PyUnicode_Type), 1, "art", 1))) __PYX_ERR(3, 4904, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_314getArrayCache(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_dt, __pyx_v_art); /* function exit code */ @@ -90885,6 +92974,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_315getArrayCache(PyObject *__pyx_v_sel static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyCafe_CyCafe *__pyx_v_self, PyObject *__pyx_v_handlePV, PyObject *__pyx_v_dt, PyObject *__pyx_v_art) { PyObject *__pyx_v__METHOD = 0; unsigned int __pyx_v_handle; + dbr_char_t *__pyx_v_ui8val; short *__pyx_v_i16val; int *__pyx_v_ival; double *__pyx_v_dval; @@ -90907,7 +92997,8 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC CYTHON_UNUSED PyObject *__pyx_v_strVal = NULL; PyObject *__pyx_v_valStr = NULL; CYTHON_UNUSED int __pyx_v_encoded; - PyObject *__pyx_v_mvShortNP = NULL; + PyObject *__pyx_v_mvInt8 = NULL; + PyObject *__pyx_v_mvUInt8 = NULL; PyObject *__pyx_v_arrayArray = NULL; PyObject *__pyx_v_ctypesArray = NULL; PyObject *__pyx_v_mvIntNP = NULL; @@ -90935,18 +93026,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_memviewslice __pyx_t_18 = { 0, 0, { 0 }, { 0 }, { 0 } }; size_t __pyx_t_19; size_t __pyx_t_20; - __Pyx_memviewslice __pyx_t_21 = { 0, 0, { 0 }, { 0 }, { 0 } }; + size_t __pyx_t_21; size_t __pyx_t_22; size_t __pyx_t_23; - __Pyx_memviewslice __pyx_t_24 = { 0, 0, { 0 }, { 0 }, { 0 } }; - size_t __pyx_t_25; + size_t __pyx_t_24; + __Pyx_memviewslice __pyx_t_25 = { 0, 0, { 0 }, { 0 }, { 0 } }; size_t __pyx_t_26; - __Pyx_memviewslice __pyx_t_27 = { 0, 0, { 0 }, { 0 }, { 0 } }; - size_t __pyx_t_28; + size_t __pyx_t_27; + __Pyx_memviewslice __pyx_t_28 = { 0, 0, { 0 }, { 0 }, { 0 } }; size_t __pyx_t_29; + size_t __pyx_t_30; + __Pyx_memviewslice __pyx_t_31 = { 0, 0, { 0 }, { 0 }, { 0 } }; + size_t __pyx_t_32; + size_t __pyx_t_33; __Pyx_RefNannySetupContext("getArrayCache", 0); - /* "PyCafe.pyx":4825 + /* "PyCafe.pyx":4915 * # allowing sharing of data buffers without copying * * cdef str _METHOD = "getArrayCache" # <<<<<<<<<<<<<< @@ -90956,7 +93051,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_getArrayCache); __pyx_v__METHOD = __pyx_n_u_getArrayCache; - /* "PyCafe.pyx":4827 + /* "PyCafe.pyx":4917 * cdef str _METHOD = "getArrayCache" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -90965,7 +93060,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_handle = 0; - /* "PyCafe.pyx":4829 + /* "PyCafe.pyx":4919 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -90986,17 +93081,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4830 + /* "PyCafe.pyx":4920 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4830, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4920, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":4829 + /* "PyCafe.pyx":4919 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -91006,7 +93101,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":4831 + /* "PyCafe.pyx":4921 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -91017,21 +93112,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4832 + /* "PyCafe.pyx":4922 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("{} {} {}".format(self._exception_text, _METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 4832, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4832, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 4922, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4922, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4832, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4922, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":4831 + /* "PyCafe.pyx":4921 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -91041,7 +93136,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":4834 + /* "PyCafe.pyx":4924 * handle = self.checkForHandle(handlePV) * else: * raise Exception("{} {} {}".format(self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -91049,7 +93144,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4834, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__39, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -91066,7 +93161,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_4}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4834, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4924, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -91074,13 +93169,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_input_argument_should_be_o_4}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4834, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4924, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 4834, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 4924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -91094,21 +93189,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_First_input_argument_should_be_o_4); __Pyx_GIVEREF(__pyx_kp_u_First_input_argument_should_be_o_4); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_input_argument_should_be_o_4); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4834, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4834, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 4834, __pyx_L1_error) + __PYX_ERR(3, 4924, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":4849 + /* "PyCafe.pyx":4940 * # str [:,::1] mvStr * cnp.ndarray arr * long dtr = 0 # <<<<<<<<<<<<<< @@ -91117,7 +93212,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_dtr = 0; - /* "PyCafe.pyx":4854 + /* "PyCafe.pyx":4945 * unsigned int ij * * status = self.hh.getDataTypeNative(handle, dtr) # <<<<<<<<<<<<<< @@ -91126,7 +93221,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_status = __pyx_v_self->hh.getDataTypeNative(__pyx_v_handle, __pyx_v_dtr); - /* "PyCafe.pyx":4856 + /* "PyCafe.pyx":4947 * status = self.hh.getDataTypeNative(handle, dtr) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -91136,7 +93231,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4857 + /* "PyCafe.pyx":4948 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -91146,7 +93241,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4858 + /* "PyCafe.pyx":4949 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -91156,7 +93251,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4859 + /* "PyCafe.pyx":4950 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -91165,7 +93260,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":4858 + /* "PyCafe.pyx":4949 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -91175,7 +93270,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC goto __pyx_L8; } - /* "PyCafe.pyx":4861 + /* "PyCafe.pyx":4952 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -91187,7 +93282,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC } __pyx_L8:; - /* "PyCafe.pyx":4857 + /* "PyCafe.pyx":4948 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -91196,7 +93291,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4862 + /* "PyCafe.pyx":4953 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -91206,76 +93301,76 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_1 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4864 + /* "PyCafe.pyx":4955 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4864, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4955, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4864, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4864, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4864, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4955, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4955, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4955, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 4864, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 4955, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4865 + /* "PyCafe.pyx":4956 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4865, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4956, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 4864, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 4955, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4866 + /* "PyCafe.pyx":4957 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4866, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4957, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 4864, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 4955, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4866, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4957, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 4864, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 4955, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4867 + /* "PyCafe.pyx":4958 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4867, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4958, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 4864, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 4955, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4863 + /* "PyCafe.pyx":4954 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4863, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4954, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4868 + /* "PyCafe.pyx":4959 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -91283,9 +93378,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * return [None] */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 4868, __pyx_L1_error) + __PYX_ERR(3, 4959, __pyx_L1_error) - /* "PyCafe.pyx":4862 + /* "PyCafe.pyx":4953 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -91294,7 +93389,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4870 + /* "PyCafe.pyx":4961 * raise _cafeException * * return [None] # <<<<<<<<<<<<<< @@ -91302,7 +93397,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4870, __pyx_L1_error) + __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4961, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); @@ -91311,7 +93406,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4856 + /* "PyCafe.pyx":4947 * status = self.hh.getDataTypeNative(handle, dtr) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -91321,7 +93416,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC goto __pyx_L6; } - /* "PyCafe.pyx":4872 + /* "PyCafe.pyx":4963 * return [None] * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -91340,7 +93435,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4873 + /* "PyCafe.pyx":4964 * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if self._c_cafe.isChannelConnected(handle) is False: # <<<<<<<<<<<<<< @@ -91350,7 +93445,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_self->_c_cafe->isChannelConnected(__pyx_v_handle) == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4874 + /* "PyCafe.pyx":4965 * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if self._c_cafe.isChannelConnected(handle) is False: * self._c_cafe.getChannelInfo(handle, self.channelInfo) # <<<<<<<<<<<<<< @@ -91359,7 +93454,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ (void)(__pyx_v_self->_c_cafe->getChannelInfo(__pyx_v_handle, __pyx_v_self->channelInfo)); - /* "PyCafe.pyx":4875 + /* "PyCafe.pyx":4966 * if self._c_cafe.isChannelConnected(handle) is False: * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -91369,7 +93464,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4876 + /* "PyCafe.pyx":4967 * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus( # <<<<<<<<<<<<<< @@ -91378,7 +93473,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, __pyx_v_self->channelInfo.getCafeConnectionState()); - /* "PyCafe.pyx":4875 + /* "PyCafe.pyx":4966 * if self._c_cafe.isChannelConnected(handle) is False: * self._c_cafe.getChannelInfo(handle, self.channelInfo) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -91387,7 +93482,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4878 + /* "PyCafe.pyx":4969 * self._c_cafe.printStatus( * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -91397,84 +93492,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4880 + /* "PyCafe.pyx":4971 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4880, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4880, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4880, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4880, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4971, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4971, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 4880, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 4971, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4881 + /* "PyCafe.pyx":4972 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=self.channelInfo.getCafeConnectionState(), * _error_text=self.cs.code( */ - __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4881, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4972, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 4880, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 4971, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4882 + /* "PyCafe.pyx":4973 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), # <<<<<<<<<<<<<< * _error_text=self.cs.code( * self.channelInfo.getCafeConnectionState()), */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->channelInfo.getCafeConnectionState()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4882, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->channelInfo.getCafeConnectionState()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 4880, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 4971, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4883 + /* "PyCafe.pyx":4974 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=self.channelInfo.getCafeConnectionState(), * _error_text=self.cs.code( # <<<<<<<<<<<<<< * self.channelInfo.getCafeConnectionState()), * _error_info=self.cs.info( */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4883, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 4880, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 4971, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4885 + /* "PyCafe.pyx":4976 * _error_text=self.cs.code( * self.channelInfo.getCafeConnectionState()), * _error_info=self.cs.info( # <<<<<<<<<<<<<< * self.channelInfo.getCafeConnectionState())) * raise _cafeException */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4885, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_self->channelInfo.getCafeConnectionState())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 4880, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 4971, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4879 + /* "PyCafe.pyx":4970 * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4879, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4970, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4887 + /* "PyCafe.pyx":4978 * _error_info=self.cs.info( * self.channelInfo.getCafeConnectionState())) * raise _cafeException # <<<<<<<<<<<<<< @@ -91482,9 +93577,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 4887, __pyx_L1_error) + __PYX_ERR(3, 4978, __pyx_L1_error) - /* "PyCafe.pyx":4878 + /* "PyCafe.pyx":4969 * self._c_cafe.printStatus( * handle, self.channelInfo.getCafeConnectionState()) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -91493,7 +93588,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4888 + /* "PyCafe.pyx":4979 * self.channelInfo.getCafeConnectionState())) * raise _cafeException * return [None] # <<<<<<<<<<<<<< @@ -91501,7 +93596,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * # Likely to be superfluous */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4888, __pyx_L1_error) + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); @@ -91510,7 +93605,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4873 + /* "PyCafe.pyx":4964 * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: * if self._c_cafe.isChannelConnected(handle) is False: # <<<<<<<<<<<<<< @@ -91519,7 +93614,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4891 + /* "PyCafe.pyx":4982 * * # Likely to be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -91529,7 +93624,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4892 + /* "PyCafe.pyx":4983 * # Likely to be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) # <<<<<<<<<<<<<< @@ -91538,7 +93633,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, ICAFE_TYPENOTCONN); - /* "PyCafe.pyx":4891 + /* "PyCafe.pyx":4982 * * # Likely to be superfluous * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -91547,7 +93642,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4893 + /* "PyCafe.pyx":4984 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -91557,84 +93652,84 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4895 + /* "PyCafe.pyx":4986 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4895, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4986, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4895, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4895, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4895, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 4986, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 4986, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4986, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 4895, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 4986, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4896 + /* "PyCafe.pyx":4987 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), */ - __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4896, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4987, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 4895, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_t_5) < 0) __PYX_ERR(3, 4986, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4897 + /* "PyCafe.pyx":4988 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, # <<<<<<<<<<<<<< * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) */ - __pyx_t_5 = __Pyx_PyInt_From_CAFE_CFT_STATE(ICAFE_TYPENOTCONN); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4897, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_CAFE_CFT_STATE(ICAFE_TYPENOTCONN); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4988, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 4895, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 4986, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4898 + /* "PyCafe.pyx":4989 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), # <<<<<<<<<<<<<< * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4898, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4989, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 4895, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 4986, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4899 + /* "PyCafe.pyx":4990 * _error_code=ICAFE_TYPENOTCONN, * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) # <<<<<<<<<<<<<< * raise _cafeException * return [None] */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4899, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ICAFE_TYPENOTCONN)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4990, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 4895, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 4986, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4894 + /* "PyCafe.pyx":4985 * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4894, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4900 + /* "PyCafe.pyx":4991 * _error_text=self.cs.code(ICAFE_TYPENOTCONN), * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException # <<<<<<<<<<<<<< @@ -91642,9 +93737,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 4900, __pyx_L1_error) + __PYX_ERR(3, 4991, __pyx_L1_error) - /* "PyCafe.pyx":4893 + /* "PyCafe.pyx":4984 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatus(handle, ICAFE_TYPENOTCONN) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -91653,7 +93748,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4901 + /* "PyCafe.pyx":4992 * _error_info=self.cs.info(ICAFE_TYPENOTCONN)) * raise _cafeException * return [None] # <<<<<<<<<<<<<< @@ -91661,7 +93756,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * cdef unsigned int nelemToRetrieveFromCache = self.hh.getNelemToRetrieveFromCache(handle) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4901, __pyx_L1_error) + __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4992, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); @@ -91670,7 +93765,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":4872 + /* "PyCafe.pyx":4963 * return [None] * * elif dtr in [CAFE_NO_ACCESS, CAFE_TYPENOTCONN]: # <<<<<<<<<<<<<< @@ -91680,7 +93775,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC } __pyx_L6:; - /* "PyCafe.pyx":4903 + /* "PyCafe.pyx":4994 * return [None] * * cdef unsigned int nelemToRetrieveFromCache = self.hh.getNelemToRetrieveFromCache(handle) # <<<<<<<<<<<<<< @@ -91689,7 +93784,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_nelemToRetrieveFromCache = __pyx_v_self->hh.getNelemToRetrieveFromCache(__pyx_v_handle); - /* "PyCafe.pyx":4905 + /* "PyCafe.pyx":4996 * cdef unsigned int nelemToRetrieveFromCache = self.hh.getNelemToRetrieveFromCache(handle) * * cdef unsigned int dtcheck = dtr # <<<<<<<<<<<<<< @@ -91698,23 +93793,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_dtcheck = __pyx_v_dtr; - /* "PyCafe.pyx":4906 + /* "PyCafe.pyx":4997 * * cdef unsigned int dtcheck = dtr * dtcheck = getMatchedDataType(dt, dtr) # <<<<<<<<<<<<<< * * # The element type of a typed memoryview may be a numeric scalar type (int, float) */ - __pyx_t_5 = __Pyx_PyInt_From_long(__pyx_v_dtr); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4906, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_long(__pyx_v_dtr); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4906, __pyx_L1_error) + __pyx_t_6 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4906, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4997, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_dtcheck = __pyx_t_4; - /* "PyCafe.pyx":4911 + /* "PyCafe.pyx":5002 * # 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]: # <<<<<<<<<<<<<< @@ -91725,7 +93820,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC case CAFE_STRING: case CAFE_ENUM: - /* "PyCafe.pyx":4912 + /* "PyCafe.pyx":5003 * * if dtcheck in [CAFE_STRING, CAFE_ENUM]: * sval = malloc(nelemToRetrieveFromCache * sizeof(dbr_string_t)) # <<<<<<<<<<<<<< @@ -91734,7 +93829,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_sval = ((char (*)[40])malloc((__pyx_v_nelemToRetrieveFromCache * (sizeof(dbr_string_t))))); - /* "PyCafe.pyx":4914 + /* "PyCafe.pyx":5005 * sval = malloc(nelemToRetrieveFromCache * sizeof(dbr_string_t)) * * status = self._c_cafe.getCacheDbrStringArray(handle, sval) # <<<<<<<<<<<<<< @@ -91743,19 +93838,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_status = __pyx_v_self->_c_cafe->getCacheDbrStringArray(__pyx_v_handle, __pyx_v_sval); - /* "PyCafe.pyx":4916 + /* "PyCafe.pyx":5007 * status = self._c_cafe.getCacheDbrStringArray(handle, sval) * * locallist = [] # <<<<<<<<<<<<<< * * if status == ICAFE_NORMAL: */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4916, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5007, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_locallist = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":4918 + /* "PyCafe.pyx":5009 * locallist = [] * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -91765,7 +93860,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":4920 + /* "PyCafe.pyx":5011 * if status == ICAFE_NORMAL: * * for i in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -91777,14 +93872,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_i = __pyx_t_11; - /* "PyCafe.pyx":4922 + /* "PyCafe.pyx":5013 * for i in range(0, nelemToRetrieveFromCache): * * bVal = ( sval[i]) # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): */ - __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_sval[__pyx_v_i]))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 4922, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(((std::string)(__pyx_v_sval[__pyx_v_i]))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __pyx_t_6; __Pyx_INCREF(__pyx_t_5); @@ -91792,7 +93887,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_bVal, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":4923 + /* "PyCafe.pyx":5014 * * bVal = ( sval[i]) * encoding = False # <<<<<<<<<<<<<< @@ -91801,21 +93896,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":4924 + /* "PyCafe.pyx":5015 * bVal = ( sval[i]) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): # <<<<<<<<<<<<<< * try: * strVal = (bVal).decode('latin-1') */ - __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4924, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 4924, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5015, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4925 + /* "PyCafe.pyx":5016 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -91831,7 +93926,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":4926 + /* "PyCafe.pyx":5017 * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: * strVal = (bVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -91840,14 +93935,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4926, __pyx_L19_error) + __PYX_ERR(3, 5017, __pyx_L19_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4926, __pyx_L19_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5017, __pyx_L19_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4927 + /* "PyCafe.pyx":5018 * try: * strVal = (bVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -91856,7 +93951,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":4925 + /* "PyCafe.pyx":5016 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -91874,7 +93969,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4928 + /* "PyCafe.pyx":5019 * strVal = (bVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -91889,7 +93984,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC goto __pyx_L21_except_error; __pyx_L21_except_error:; - /* "PyCafe.pyx":4925 + /* "PyCafe.pyx":5016 * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): * try: # <<<<<<<<<<<<<< @@ -91909,7 +94004,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_L26_try_end:; } - /* "PyCafe.pyx":4924 + /* "PyCafe.pyx":5015 * bVal = ( sval[i]) * encoding = False * if '.EGU' in self._c_cafe.getPVFromHandle(handle): # <<<<<<<<<<<<<< @@ -91918,7 +94013,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4931 + /* "PyCafe.pyx":5022 * pass * * if not encoding: # <<<<<<<<<<<<<< @@ -91928,7 +94023,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4932 + /* "PyCafe.pyx":5023 * * if not encoding: * try: # <<<<<<<<<<<<<< @@ -91944,7 +94039,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "PyCafe.pyx":4933 + /* "PyCafe.pyx":5024 * if not encoding: * try: * valStr = bVal.decode('utf-8') # <<<<<<<<<<<<<< @@ -91953,14 +94048,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4933, __pyx_L28_error) + __PYX_ERR(3, 5024, __pyx_L28_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4933, __pyx_L28_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5024, __pyx_L28_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_valStr, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4934 + /* "PyCafe.pyx":5025 * try: * valStr = bVal.decode('utf-8') * encoded = True # <<<<<<<<<<<<<< @@ -91969,7 +94064,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_encoded = 1; - /* "PyCafe.pyx":4932 + /* "PyCafe.pyx":5023 * * if not encoding: * try: # <<<<<<<<<<<<<< @@ -91987,7 +94082,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4935 + /* "PyCafe.pyx":5026 * valStr = bVal.decode('utf-8') * encoded = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -92002,7 +94097,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC goto __pyx_L30_except_error; __pyx_L30_except_error:; - /* "PyCafe.pyx":4932 + /* "PyCafe.pyx":5023 * * if not encoding: * try: # <<<<<<<<<<<<<< @@ -92022,7 +94117,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_L35_try_end:; } - /* "PyCafe.pyx":4931 + /* "PyCafe.pyx":5022 * pass * * if not encoding: # <<<<<<<<<<<<<< @@ -92031,7 +94126,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4937 + /* "PyCafe.pyx":5028 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -92041,7 +94136,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4938 + /* "PyCafe.pyx":5029 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -92057,7 +94152,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "PyCafe.pyx":4939 + /* "PyCafe.pyx":5030 * if not encoding: * try: * valStr = bVal.decode('utf-16') # <<<<<<<<<<<<<< @@ -92066,14 +94161,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_bVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 4939, __pyx_L37_error) + __PYX_ERR(3, 5030, __pyx_L37_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4939, __pyx_L37_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5030, __pyx_L37_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_valStr, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4940 + /* "PyCafe.pyx":5031 * try: * valStr = bVal.decode('utf-16') * encoded = True # <<<<<<<<<<<<<< @@ -92082,7 +94177,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_encoded = 1; - /* "PyCafe.pyx":4938 + /* "PyCafe.pyx":5029 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -92100,7 +94195,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4941 + /* "PyCafe.pyx":5032 * valStr = bVal.decode('utf-16') * encoded = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -92115,7 +94210,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC goto __pyx_L39_except_error; __pyx_L39_except_error:; - /* "PyCafe.pyx":4938 + /* "PyCafe.pyx":5029 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -92135,7 +94230,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_L44_try_end:; } - /* "PyCafe.pyx":4937 + /* "PyCafe.pyx":5028 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -92144,7 +94239,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4944 + /* "PyCafe.pyx":5035 * pass * * if not encoding: # <<<<<<<<<<<<<< @@ -92154,19 +94249,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":4945 + /* "PyCafe.pyx":5036 * * if not encoding: * valStr = sval[i] # <<<<<<<<<<<<<< * * */ - __pyx_t_5 = __Pyx_PyObject_FromString((__pyx_v_sval[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 4945, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_FromString((__pyx_v_sval[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5036, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_valStr, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":4944 + /* "PyCafe.pyx":5035 * pass * * if not encoding: # <<<<<<<<<<<<<< @@ -92175,18 +94270,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4948 + /* "PyCafe.pyx":5039 * * * locallist.append(valStr) #sval[i]) # <<<<<<<<<<<<<< * * free(sval) */ - if (unlikely(!__pyx_v_valStr)) { __Pyx_RaiseUnboundLocalError("valStr"); __PYX_ERR(3, 4948, __pyx_L1_error) } - __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_locallist, __pyx_v_valStr); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 4948, __pyx_L1_error) + if (unlikely(!__pyx_v_valStr)) { __Pyx_RaiseUnboundLocalError("valStr"); __PYX_ERR(3, 5039, __pyx_L1_error) } + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_locallist, __pyx_v_valStr); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5039, __pyx_L1_error) } - /* "PyCafe.pyx":4950 + /* "PyCafe.pyx":5041 * locallist.append(valStr) #sval[i]) * * free(sval) # <<<<<<<<<<<<<< @@ -92195,7 +94290,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_sval); - /* "PyCafe.pyx":4951 + /* "PyCafe.pyx":5042 * * free(sval) * return locallist # <<<<<<<<<<<<<< @@ -92207,7 +94302,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_r = __pyx_v_locallist; goto __pyx_L0; - /* "PyCafe.pyx":4918 + /* "PyCafe.pyx":5009 * locallist = [] * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -92216,7 +94311,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4911 + /* "PyCafe.pyx":5002 * # 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]: # <<<<<<<<<<<<<< @@ -92224,33 +94319,1388 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * */ break; - case CAFE_SHORT: - - /* "PyCafe.pyx":5007 - * return mvStr - * ''' - * elif dtcheck in [CAFE_SHORT, CAFE_CHAR]: # <<<<<<<<<<<<<< - * - * i16val = malloc(nelemToRetrieveFromCache * sizeof(np.int16)) - */ case CAFE_CHAR: - /* "PyCafe.pyx":5009 - * elif dtcheck in [CAFE_SHORT, CAFE_CHAR]: + /* "PyCafe.pyx":5100 + * elif dtcheck in [CAFE_CHAR]: + * + * ui8val = malloc(nelemToRetrieveFromCache * sizeof(np.uint8)) # <<<<<<<<<<<<<< + * + * status = self._c_cafe.getCacheCharArray(handle, ui8val) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_uint8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_ui8val = ((dbr_char_t *)malloc((__pyx_v_nelemToRetrieveFromCache * (sizeof(__pyx_t_6))))); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "PyCafe.pyx":5102 + * ui8val = malloc(nelemToRetrieveFromCache * sizeof(np.uint8)) + * + * status = self._c_cafe.getCacheCharArray(handle, ui8val) # <<<<<<<<<<<<<< + * + * if status == ICAFE_NORMAL: + */ + __pyx_v_status = __pyx_v_self->_c_cafe->getCacheCharArray(__pyx_v_handle, __pyx_v_ui8val); + + /* "PyCafe.pyx":5104 + * status = self._c_cafe.getCacheCharArray(handle, ui8val) + * + * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< + * # np.empty preferred, else mvInt does not get correct value for first couple of array elements + * + */ + __pyx_t_1 = ((__pyx_v_status == ICAFE_NORMAL) != 0); + if (__pyx_t_1) { + + /* "PyCafe.pyx":5107 + * # np.empty preferred, else mvInt does not get correct value for first couple of array elements + * + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_16 = __pyx_v_art; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5107, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L48_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5107, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L48_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5107, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L48_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5107, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L48_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5107, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L48_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + + /* "PyCafe.pyx":5109 + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: # <<<<<<<<<<<<<< + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + */ + __Pyx_INCREF(__pyx_v_dt); + __pyx_t_16 = __pyx_v_dt; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_short, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5109, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L54_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_int16, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5109, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L54_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_short, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5109, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L54_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_int16, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5109, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + __pyx_t_3 = __pyx_t_1; + __pyx_L54_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_1 = (__pyx_t_3 != 0); + if (__pyx_t_1) { + + /* "PyCafe.pyx":5110 + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "PyCafe.pyx":5111 + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = ui8val[ij] + */ + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "PyCafe.pyx":5110 + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); + __pyx_t_6 = 0; + + /* "PyCafe.pyx":5111 + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = ui8val[ij] + */ + __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int16); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_17) < 0) __PYX_ERR(3, 5111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5111, __pyx_L1_error) + + /* "PyCafe.pyx":5110 + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_17, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 5110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_v_mvShort = __pyx_t_18; + __pyx_t_18.memview = NULL; + __pyx_t_18.data = NULL; + + /* "PyCafe.pyx":5112 + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvShort[ij] = ui8val[ij] + * free(ui8val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5113 + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) + * return np.array(mvShort) + */ + __pyx_t_19 = __pyx_v_ij; + __pyx_t_8 = -1; + if (unlikely(__pyx_t_19 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_8 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_8); + __PYX_ERR(3, 5113, __pyx_L1_error) + } + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_19)) )) = ((__pyx_t_5numpy_int16_t)(__pyx_v_ui8val[__pyx_v_ij])); + } + + /* "PyCafe.pyx":5114 + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< + * return np.array(mvShort) + * + */ + free(__pyx_v_ui8val); + + /* "PyCafe.pyx":5115 + * mvShort[ij] = ui8val[ij] + * free(ui8val) + * return np.array(mvShort) # <<<<<<<<<<<<<< + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_17 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_r = __pyx_t_17; + __pyx_t_17 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":5109 + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: # <<<<<<<<<<<<<< + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + */ + goto __pyx_L53; + } + + /* "PyCafe.pyx":5117 + * return np.array(mvShort) + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: # <<<<<<<<<<<<<< + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + */ + __Pyx_INCREF(__pyx_v_dt); + __pyx_t_16 = __pyx_v_dt; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_int8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5117, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L60_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_bool, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5117, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L60_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_byte, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5117, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L60_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_bool, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5117, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L60_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_byte, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5117, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L60_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_int8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5117, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L60_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + + /* "PyCafe.pyx":5118 + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + + /* "PyCafe.pyx":5119 + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt8[ij] = ui8val[ij] + */ + __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + + /* "PyCafe.pyx":5118 + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_17); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_17); + __pyx_t_17 = 0; + + /* "PyCafe.pyx":5119 + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt8[ij] = ui8val[ij] + */ + __pyx_t_17 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int8); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(3, 5119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5119, __pyx_L1_error) + + /* "PyCafe.pyx":5118 + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_6, __pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_v_mvInt8 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "PyCafe.pyx":5120 + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvInt8[ij] = ui8val[ij] + * free(ui8val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5121 + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt8[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) + * return np.array(mvInt8) + */ + __pyx_t_7 = __Pyx_PyInt_From_npy_int8(((__pyx_t_5numpy_int8_t)(__pyx_v_ui8val[__pyx_v_ij]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (unlikely(__Pyx_SetItemInt(__pyx_v_mvInt8, __pyx_v_ij, __pyx_t_7, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5121, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + + /* "PyCafe.pyx":5122 + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt8[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< + * return np.array(mvInt8) + * + */ + free(__pyx_v_ui8val); + + /* "PyCafe.pyx":5123 + * mvInt8[ij] = ui8val[ij] + * free(ui8val) + * return np.array(mvInt8) # <<<<<<<<<<<<<< + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_17 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_17)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_17); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_7 = (__pyx_t_17) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_17, __pyx_v_mvInt8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_mvInt8); + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":5117 + * return np.array(mvShort) + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: # <<<<<<<<<<<<<< + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + */ + goto __pyx_L53; + } + + /* "PyCafe.pyx":5125 + * return np.array(mvInt8) + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: # <<<<<<<<<<<<<< + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + */ + __Pyx_INCREF(__pyx_v_dt); + __pyx_t_16 = __pyx_v_dt; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_uchar, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5125, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L68_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_uint8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5125, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L68_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_uint8, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5125, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + __pyx_t_3 = __pyx_t_2; + __pyx_L68_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "PyCafe.pyx":5126 + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "PyCafe.pyx":5127 + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = ui8val[ij] + */ + __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "PyCafe.pyx":5126 + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_7); + __pyx_t_7 = 0; + + /* "PyCafe.pyx":5127 + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = ui8val[ij] + */ + __pyx_t_7 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_uint8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(3, 5127, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5127, __pyx_L1_error) + + /* "PyCafe.pyx":5126 + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_17, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_mvUInt8 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "PyCafe.pyx":5128 + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvUInt8[ij] = ui8val[ij] + * free(ui8val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5129 + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) + * return np.array(mvUInt8) + */ + __pyx_t_5 = __Pyx_PyInt_From_npy_uint8(((__pyx_t_5numpy_uint8_t)(__pyx_v_ui8val[__pyx_v_ij]))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_SetItemInt(__pyx_v_mvUInt8, __pyx_v_ij, __pyx_t_5, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5129, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + + /* "PyCafe.pyx":5130 + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< + * return np.array(mvUInt8) + * + */ + free(__pyx_v_ui8val); + + /* "PyCafe.pyx":5131 + * mvUInt8[ij] = ui8val[ij] + * free(ui8val) + * return np.array(mvUInt8) # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_17))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_17); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_17); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_17, function); + } + } + __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_17, __pyx_t_7, __pyx_v_mvUInt8) : __Pyx_PyObject_CallOneArg(__pyx_t_17, __pyx_v_mvUInt8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":5125 + * return np.array(mvInt8) + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: # <<<<<<<<<<<<<< + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + */ + goto __pyx_L53; + } + + /* "PyCafe.pyx":5135 + * else: + * + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "PyCafe.pyx":5136 + * + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "PyCafe.pyx":5135 + * else: + * + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * + */ + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); + __pyx_t_5 = 0; + + /* "PyCafe.pyx":5136 + * + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 5136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5136, __pyx_L1_error) + + /* "PyCafe.pyx":5135 + * else: + * + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * + */ + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_17, __pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_mvUInt8 = __pyx_t_9; + __pyx_t_9 = 0; + + /* "PyCafe.pyx":5138 + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvUInt8[ij] = ui8val[ij] + * + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5139 + * + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * + * free(ui8val) + */ + __pyx_t_9 = __Pyx_PyInt_From_npy_uint8(((__pyx_t_5numpy_uint8_t)(__pyx_v_ui8val[__pyx_v_ij]))); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (unlikely(__Pyx_SetItemInt(__pyx_v_mvUInt8, __pyx_v_ij, __pyx_t_9, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5139, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + + /* "PyCafe.pyx":5141 + * mvUInt8[ij] = ui8val[ij] + * + * free(ui8val) # <<<<<<<<<<<<<< + * + * return np.array(mvUInt8) + */ + free(__pyx_v_ui8val); + + /* "PyCafe.pyx":5143 + * free(ui8val) + * + * return np.array(mvUInt8) # <<<<<<<<<<<<<< + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_9 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_5, __pyx_v_mvUInt8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_mvUInt8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; + goto __pyx_L0; + } + __pyx_L53:; + + /* "PyCafe.pyx":5107 + * # np.empty preferred, else mvInt does not get correct value for first couple of array elements + * + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + */ + goto __pyx_L47; + } + + /* "PyCafe.pyx":5145 + * return np.array(mvUInt8) + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_16 = __pyx_v_art; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5145, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L75_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5145, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L75_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5145, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L75_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "PyCafe.pyx":5146 + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "PyCafe.pyx":5147 + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "PyCafe.pyx":5146 + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * + */ + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_9); + __pyx_t_9 = 0; + + /* "PyCafe.pyx":5147 + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_int16); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(3, 5147, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5147, __pyx_L1_error) + + /* "PyCafe.pyx":5146 + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_6, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 5146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_mvShort = __pyx_t_18; + __pyx_t_18.memview = NULL; + __pyx_t_18.data = NULL; + + /* "PyCafe.pyx":5149 + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvShort[ij] = ui8val[ij] + * free(ui8val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5150 + * + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) + * + */ + __pyx_t_20 = __pyx_v_ij; + __pyx_t_8 = -1; + if (unlikely(__pyx_t_20 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_8 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_8); + __PYX_ERR(3, 5150, __pyx_L1_error) + } + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_20)) )) = ((short)(__pyx_v_ui8val[__pyx_v_ij])); + } + + /* "PyCafe.pyx":5151 + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< + * + * return mvShort + */ + free(__pyx_v_ui8val); + + /* "PyCafe.pyx":5153 + * free(ui8val) + * + * return mvShort # <<<<<<<<<<<<<< + * + * elif art in ['array', 'array.array']: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":5145 + * return np.array(mvUInt8) + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + */ + goto __pyx_L47; + } + + /* "PyCafe.pyx":5155 + * return mvShort + * + * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< + * arrayArray = array.array('h') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_16 = __pyx_v_art; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5155, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L80_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5155, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L80_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "PyCafe.pyx":5156 + * + * elif art in ['array', 'array.array']: + * arrayArray = array.array('h') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * arrayArray.append( ui8val[ij]) + */ + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_v_arrayArray = __pyx_t_6; + __pyx_t_6 = 0; + + /* "PyCafe.pyx":5157 + * elif art in ['array', 'array.array']: + * arrayArray = array.array('h') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * arrayArray.append( ui8val[ij]) + * free(ui8val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5158 + * arrayArray = array.array('h') + * for ij in range(0, nelemToRetrieveFromCache): + * arrayArray.append( ui8val[ij]) # <<<<<<<<<<<<<< + * free(ui8val) + * return arrayArray + */ + __pyx_t_6 = __Pyx_PyInt_From_dbr_char_t(((dbr_char_t)(__pyx_v_ui8val[__pyx_v_ij]))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_arrayArray, __pyx_t_6); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5158, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + + /* "PyCafe.pyx":5159 + * for ij in range(0, nelemToRetrieveFromCache): + * arrayArray.append( ui8val[ij]) + * free(ui8val) # <<<<<<<<<<<<<< + * return arrayArray + * + */ + free(__pyx_v_ui8val); + + /* "PyCafe.pyx":5160 + * arrayArray.append( ui8val[ij]) + * free(ui8val) + * return arrayArray # <<<<<<<<<<<<<< + * + * elif art in ['ctypes', 'ctype']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_arrayArray); + __pyx_r = __pyx_v_arrayArray; + goto __pyx_L0; + + /* "PyCafe.pyx":5155 + * return mvShort + * + * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< + * arrayArray = array.array('h') + * for ij in range(0, nelemToRetrieveFromCache): + */ + goto __pyx_L47; + } + + /* "PyCafe.pyx":5162 + * return arrayArray + * + * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< + * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_16 = __pyx_v_art; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5162, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L84_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5162, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L84_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "PyCafe.pyx":5163 + * + * elif art in ['ctypes', 'ctype']: + * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * ctypesArray[ij] = ui8val[ij] + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_c_int16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_6 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_ctypesArray = __pyx_t_6; + __pyx_t_6 = 0; + + /* "PyCafe.pyx":5164 + * elif art in ['ctypes', 'ctype']: + * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * ctypesArray[ij] = ui8val[ij] + * free(ui8val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5165 + * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() + * for ij in range(0, nelemToRetrieveFromCache): + * ctypesArray[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) + * return ctypesArray + */ + __pyx_t_6 = __Pyx_PyInt_From_short(((short)(__pyx_v_ui8val[__pyx_v_ij]))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_6, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5165, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + + /* "PyCafe.pyx":5166 + * for ij in range(0, nelemToRetrieveFromCache): + * ctypesArray[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< + * return ctypesArray + * + */ + free(__pyx_v_ui8val); + + /* "PyCafe.pyx":5167 + * ctypesArray[ij] = ui8val[ij] + * free(ui8val) + * return ctypesArray # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_ctypesArray); + __pyx_r = __pyx_v_ctypesArray; + goto __pyx_L0; + + /* "PyCafe.pyx":5162 + * return arrayArray + * + * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< + * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() + * for ij in range(0, nelemToRetrieveFromCache): + */ + goto __pyx_L47; + } + + /* "PyCafe.pyx":5170 + * + * else: + * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") + */ + /*else*/ { + + /* "PyCafe.pyx":5171 + * else: + * print("Unknow array type in user request for art='", + * art, "'. Possible types are:") # <<<<<<<<<<<<<< + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") + */ + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); + __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); + __Pyx_INCREF(__pyx_v_art); + __Pyx_GIVEREF(__pyx_v_art); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_art); + __Pyx_INCREF(__pyx_kp_u_Possible_types_are); + __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_Possible_types_are); + + /* "PyCafe.pyx":5170 + * + * else: + * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") + */ + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "PyCafe.pyx":5172 + * print("Unknow array type in user request for art='", + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") # <<<<<<<<<<<<<< + * print("Returning memoryview") + * mvUInt8 = np.empty( + */ + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "PyCafe.pyx":5173 + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") # <<<<<<<<<<<<<< + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + */ + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "PyCafe.pyx":5174 + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "PyCafe.pyx":5175 + * print("Returning memoryview") + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = ui8val[ij] + */ + __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "PyCafe.pyx":5174 + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); + __pyx_t_7 = 0; + + /* "PyCafe.pyx":5175 + * print("Returning memoryview") + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = ui8val[ij] + */ + __pyx_t_7 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_uint8); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_17) < 0) __PYX_ERR(3, 5175, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5175, __pyx_L1_error) + + /* "PyCafe.pyx":5174 + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, __pyx_t_7); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_mvUInt8 = __pyx_t_17; + __pyx_t_17 = 0; + + /* "PyCafe.pyx":5176 + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvUInt8[ij] = ui8val[ij] + * free(ui8val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5177 + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = ui8val[ij] # <<<<<<<<<<<<<< + * free(ui8val) + * + */ + __pyx_t_17 = __Pyx_PyInt_From_dbr_char_t(((dbr_char_t)(__pyx_v_ui8val[__pyx_v_ij]))); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + if (unlikely(__Pyx_SetItemInt(__pyx_v_mvUInt8, __pyx_v_ij, __pyx_t_17, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5177, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } + + /* "PyCafe.pyx":5178 + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = ui8val[ij] + * free(ui8val) # <<<<<<<<<<<<<< + * + * return mvUInt8 + */ + free(__pyx_v_ui8val); + + /* "PyCafe.pyx":5180 + * free(ui8val) + * + * return mvUInt8 # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_mvUInt8); + __pyx_r = __pyx_v_mvUInt8; + goto __pyx_L0; + } + __pyx_L47:; + + /* "PyCafe.pyx":5104 + * status = self._c_cafe.getCacheCharArray(handle, ui8val) + * + * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< + * # np.empty preferred, else mvInt does not get correct value for first couple of array elements + * + */ + } + + /* "PyCafe.pyx":5098 + * return mvStr + * ''' + * elif dtcheck in [CAFE_CHAR]: # <<<<<<<<<<<<<< + * + * ui8val = malloc(nelemToRetrieveFromCache * sizeof(np.uint8)) + */ + break; + case CAFE_SHORT: + + /* "PyCafe.pyx":5186 + * elif dtcheck in [CAFE_SHORT]: * * i16val = malloc(nelemToRetrieveFromCache * sizeof(np.int16)) # <<<<<<<<<<<<<< * * status = self._c_cafe.getCacheShortArray(handle, i16val) */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5009, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int16); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5009, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_i16val = ((short *)malloc((__pyx_v_nelemToRetrieveFromCache * (sizeof(__pyx_t_6))))); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_int16); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_v_i16val = ((short *)malloc((__pyx_v_nelemToRetrieveFromCache * (sizeof(__pyx_t_7))))); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":5011 + /* "PyCafe.pyx":5188 * i16val = malloc(nelemToRetrieveFromCache * sizeof(np.int16)) * * status = self._c_cafe.getCacheShortArray(handle, i16val) # <<<<<<<<<<<<<< @@ -92259,7 +95709,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_status = __pyx_v_self->_c_cafe->getCacheShortArray(__pyx_v_handle, __pyx_v_i16val); - /* "PyCafe.pyx":5013 + /* "PyCafe.pyx":5190 * status = self._c_cafe.getCacheShortArray(handle, i16val) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -92269,178 +95719,777 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_1 = ((__pyx_v_status == ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5016 + /* "PyCafe.pyx":5193 * # np.empty preferred, else mvInt does not get correct value for first couple of array elements * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< * - * mvShortNP = np.empty( + * if dt in ['np.short', 'np.int16', 'short', 'int16']: */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5016, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != 0); if (!__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; - goto __pyx_L48_bool_binop_done; + goto __pyx_L92_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5016, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) __pyx_t_2 = (__pyx_t_3 != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; - goto __pyx_L48_bool_binop_done; + goto __pyx_L92_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5016, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != 0); if (!__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; - goto __pyx_L48_bool_binop_done; + goto __pyx_L92_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5016, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) __pyx_t_2 = (__pyx_t_3 != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; - goto __pyx_L48_bool_binop_done; + goto __pyx_L92_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5016, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != 0); __pyx_t_1 = __pyx_t_3; - __pyx_L48_bool_binop_done:; + __pyx_L92_bool_binop_done:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":5018 + /* "PyCafe.pyx":5195 * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: * - * mvShortNP = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: # <<<<<<<<<<<<<< + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5018, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5018, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_v_dt); + __pyx_t_16 = __pyx_v_dt; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_short, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5195, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L98_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_int16, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5195, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L98_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_short, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5195, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L98_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_int16, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5195, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + __pyx_t_3 = __pyx_t_1; + __pyx_L98_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_1 = (__pyx_t_3 != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5019 + /* "PyCafe.pyx":5196 * - * mvShortNP = np.empty( - * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< - * - * for ij in range(0, nelemToRetrieveFromCache): + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5019, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - - /* "PyCafe.pyx":5018 - * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: - * - * mvShortNP = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * - */ - __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5018, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); - __pyx_t_6 = 0; - - /* "PyCafe.pyx":5019 - * - * mvShortNP = np.empty( - * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< - * - * for ij in range(0, nelemToRetrieveFromCache): - */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5019, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5019, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int16); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5019, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_17) < 0) __PYX_ERR(3, 5019, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5019, __pyx_L1_error) - - /* "PyCafe.pyx":5018 - * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: - * - * mvShortNP = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * - */ - __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5018, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_mvShortNP = __pyx_t_17; - __pyx_t_17 = 0; - - /* "PyCafe.pyx":5021 - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * - * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< - * mvShortNP[ij] = i16val[ij] - * # arr=np.asarray(mvShort) - */ - __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; - __pyx_t_10 = __pyx_t_4; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_ij = __pyx_t_11; - - /* "PyCafe.pyx":5022 - * - * for ij in range(0, nelemToRetrieveFromCache): - * mvShortNP[ij] = i16val[ij] # <<<<<<<<<<<<<< - * # arr=np.asarray(mvShort) - * - */ - __pyx_t_17 = __Pyx_PyInt_From_npy_int16(((__pyx_t_5numpy_int16_t)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5022, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_empty); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); - if (unlikely(__Pyx_SetItemInt(__pyx_v_mvShortNP, __pyx_v_ij, __pyx_t_17, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5022, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "PyCafe.pyx":5197 + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = i16val[ij] + */ + __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "PyCafe.pyx":5196 + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); + __pyx_t_7 = 0; + + /* "PyCafe.pyx":5197 + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = i16val[ij] + */ + __pyx_t_7 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(3, 5197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5197, __pyx_L1_error) + + /* "PyCafe.pyx":5196 + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_17, __pyx_t_9, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 5196, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_mvShort = __pyx_t_18; + __pyx_t_18.memview = NULL; + __pyx_t_18.data = NULL; + + /* "PyCafe.pyx":5198 + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvShort[ij] = i16val[ij] + * free(i16val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5199 + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * return np.array(mvShort) + */ + __pyx_t_21 = __pyx_v_ij; + __pyx_t_8 = -1; + if (unlikely(__pyx_t_21 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_8 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_8); + __PYX_ERR(3, 5199, __pyx_L1_error) + } + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_21)) )) = ((__pyx_t_5numpy_int16_t)(__pyx_v_i16val[__pyx_v_ij])); + } + + /* "PyCafe.pyx":5200 + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * return np.array(mvShort) + * + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":5201 + * mvShort[ij] = i16val[ij] + * free(i16val) + * return np.array(mvShort) # <<<<<<<<<<<<<< + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_17 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_17)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_17); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_5 = (__pyx_t_17) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_17, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_7); + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":5195 + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: + * + * if dt in ['np.short', 'np.int16', 'short', 'int16']: # <<<<<<<<<<<<<< + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + */ + goto __pyx_L97; } - /* "PyCafe.pyx":5025 - * # arr=np.asarray(mvShort) + /* "PyCafe.pyx":5203 + * return np.array(mvShort) * - * free(i16val) # <<<<<<<<<<<<<< - * - * return mvShortNP # arr + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: # <<<<<<<<<<<<<< + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') */ - free(__pyx_v_i16val); + __Pyx_INCREF(__pyx_v_dt); + __pyx_t_16 = __pyx_v_dt; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_int8, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5203, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L104_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_bool, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5203, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L104_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_byte, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5203, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L104_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_bool, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5203, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L104_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_byte, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5203, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L104_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_int8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5203, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L104_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { - /* "PyCafe.pyx":5027 - * free(i16val) + /* "PyCafe.pyx":5204 * - * return mvShortNP # arr # <<<<<<<<<<<<<< + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "PyCafe.pyx":5205 + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt8[ij] = i16val[ij] + */ + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "PyCafe.pyx":5204 + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); + __pyx_t_5 = 0; + + /* "PyCafe.pyx":5205 + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt8[ij] = i16val[ij] + */ + __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_int8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(3, 5205, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5205, __pyx_L1_error) + + /* "PyCafe.pyx":5204 + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: + * mvInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_mvInt8 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "PyCafe.pyx":5206 + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvInt8[ij] = i16val[ij] + * free(i16val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5207 + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt8[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * return np.array(mvInt8) + */ + __pyx_t_6 = __Pyx_PyInt_From_npy_int8(((__pyx_t_5numpy_int8_t)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_SetItemInt(__pyx_v_mvInt8, __pyx_v_ij, __pyx_t_6, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5207, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + + /* "PyCafe.pyx":5208 + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt8[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * return np.array(mvInt8) + * + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":5209 + * mvInt8[ij] = i16val[ij] + * free(i16val) + * return np.array(mvInt8) # <<<<<<<<<<<<<< + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_6 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_5, __pyx_v_mvInt8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_mvInt8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":5203 + * return np.array(mvShort) + * + * elif dt in ['np.int8', 'np.bool_', 'np.byte', 'bool', 'byte', 'int8']: # <<<<<<<<<<<<<< + * mvInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.int8, order='C') + */ + goto __pyx_L97; + } + + /* "PyCafe.pyx":5211 + * return np.array(mvInt8) + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: # <<<<<<<<<<<<<< + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + */ + __Pyx_INCREF(__pyx_v_dt); + __pyx_t_16 = __pyx_v_dt; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_uchar, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5211, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L112_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_uint8, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5211, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L112_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_uint8, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5211, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + __pyx_t_3 = __pyx_t_2; + __pyx_L112_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "PyCafe.pyx":5212 + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "PyCafe.pyx":5213 + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = i16val[ij] + */ + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "PyCafe.pyx":5212 + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); + __pyx_t_6 = 0; + + /* "PyCafe.pyx":5213 + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = i16val[ij] + */ + __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_uint8); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_17) < 0) __PYX_ERR(3, 5213, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5213, __pyx_L1_error) + + /* "PyCafe.pyx":5212 + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: + * mvUInt8 = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_mvUInt8 = __pyx_t_17; + __pyx_t_17 = 0; + + /* "PyCafe.pyx":5214 + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvUInt8[ij] = i16val[ij] + * free(i16val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5215 + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * return np.array(mvUInt8) + */ + __pyx_t_17 = __Pyx_PyInt_From_npy_uint8(((__pyx_t_5numpy_uint8_t)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + if (unlikely(__Pyx_SetItemInt(__pyx_v_mvUInt8, __pyx_v_ij, __pyx_t_17, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } + + /* "PyCafe.pyx":5216 + * for ij in range(0, nelemToRetrieveFromCache): + * mvUInt8[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * return np.array(mvUInt8) + * + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":5217 + * mvUInt8[ij] = i16val[ij] + * free(i16val) + * return np.array(mvUInt8) # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_17 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_mvUInt8) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_mvUInt8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_17; + __pyx_t_17 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":5211 + * return np.array(mvInt8) + * + * elif dt in ['uchar', 'np.uint8', 'uint8']: # <<<<<<<<<<<<<< + * mvUInt8 = np.empty( + * nelemToRetrieveFromCache, dtype=np.uint8, order='C') + */ + goto __pyx_L97; + } + + /* "PyCafe.pyx":5221 + * else: + * + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + + /* "PyCafe.pyx":5222 + * + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + + /* "PyCafe.pyx":5221 + * else: + * + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * + */ + __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_17); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_17); + __pyx_t_17 = 0; + + /* "PyCafe.pyx":5222 + * + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_17 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 5222, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5222, __pyx_L1_error) + + /* "PyCafe.pyx":5221 + * else: + * + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * + */ + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, __pyx_t_17); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 5221, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_mvShort = __pyx_t_18; + __pyx_t_18.memview = NULL; + __pyx_t_18.data = NULL; + + /* "PyCafe.pyx":5224 + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvShort[ij] = i16val[ij] + * + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5225 + * + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< + * + * free(i16val) + */ + __pyx_t_22 = __pyx_v_ij; + __pyx_t_8 = -1; + if (unlikely(__pyx_t_22 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_8 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_8); + __PYX_ERR(3, 5225, __pyx_L1_error) + } + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_22)) )) = ((__pyx_t_5numpy_int16_t)(__pyx_v_i16val[__pyx_v_ij])); + } + + /* "PyCafe.pyx":5227 + * mvShort[ij] = i16val[ij] + * + * free(i16val) # <<<<<<<<<<<<<< + * + * return np.array(mvShort) # arr + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":5229 + * free(i16val) + * + * return np.array(mvShort) # arr # <<<<<<<<<<<<<< * * elif art in ['memoryview', 'mv', 'memoryviewslice']: */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_mvShortNP); - __pyx_r = __pyx_v_mvShortNP; - goto __pyx_L0; + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_17 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_9 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_5, __pyx_t_17) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_17); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; + goto __pyx_L0; + } + __pyx_L97:; - /* "PyCafe.pyx":5016 + /* "PyCafe.pyx":5193 * # np.empty preferred, else mvInt does not get correct value for first couple of array elements * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< * - * mvShortNP = np.empty( + * if dt in ['np.short', 'np.int16', 'short', 'int16']: */ - goto __pyx_L47; + goto __pyx_L91; } - /* "PyCafe.pyx":5029 - * return mvShortNP # arr + /* "PyCafe.pyx":5231 + * return np.array(mvShort) # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< * mvShort = np.empty( @@ -92448,101 +96497,101 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5029, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_3 = __pyx_t_2; - goto __pyx_L55_bool_binop_done; - } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5029, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5231, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); if (!__pyx_t_1) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L55_bool_binop_done; + __pyx_t_2 = __pyx_t_1; + goto __pyx_L119_bool_binop_done; } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5029, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - __pyx_t_3 = __pyx_t_2; - __pyx_L55_bool_binop_done:; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5231, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L119_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5231, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L119_bool_binop_done:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_2 = (__pyx_t_3 != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5030 + /* "PyCafe.pyx":5232 * * elif art in ['memoryview', 'mv', 'memoryviewslice']: * mvShort = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.int16, order='C') * */ - __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5030, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5030, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - - /* "PyCafe.pyx":5031 - * elif art in ['memoryview', 'mv', 'memoryviewslice']: - * mvShort = np.empty( - * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< - * - * for ij in range(0, nelemToRetrieveFromCache): - */ - __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5031, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - - /* "PyCafe.pyx":5030 - * - * elif art in ['memoryview', 'mv', 'memoryviewslice']: - * mvShort = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * - */ - __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5030, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_GIVEREF(__pyx_t_17); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_17); - __pyx_t_17 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":5031 + /* "PyCafe.pyx":5233 * elif art in ['memoryview', 'mv', 'memoryviewslice']: * mvShort = np.empty( * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< * * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_17 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5031, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "PyCafe.pyx":5232 + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * + */ + __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5031, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_9); + __pyx_t_9 = 0; + + /* "PyCafe.pyx":5233 + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5233, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int16); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5031, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int16); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5233, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(3, 5031, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(3, 5233, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5031, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5233, __pyx_L1_error) - /* "PyCafe.pyx":5030 + /* "PyCafe.pyx":5232 * * elif art in ['memoryview', 'mv', 'memoryviewslice']: * mvShort = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.int16, order='C') * */ - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, __pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5030, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_7, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 5030, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_7, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 5232, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_mvShort = __pyx_t_18; __pyx_t_18.memview = NULL; __pyx_t_18.data = NULL; - /* "PyCafe.pyx":5033 + /* "PyCafe.pyx":5235 * nelemToRetrieveFromCache, dtype=np.int16, order='C') * * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -92554,24 +96603,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5034 + /* "PyCafe.pyx":5236 * * for ij in range(0, nelemToRetrieveFromCache): * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< * free(i16val) * */ - __pyx_t_19 = __pyx_v_ij; + __pyx_t_23 = __pyx_v_ij; __pyx_t_8 = -1; - if (unlikely(__pyx_t_19 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_23 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_8 = 0; if (unlikely(__pyx_t_8 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_8); - __PYX_ERR(3, 5034, __pyx_L1_error) + __PYX_ERR(3, 5236, __pyx_L1_error) } - *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_19)) )) = ((short)(__pyx_v_i16val[__pyx_v_ij])); + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_23)) )) = ((short)(__pyx_v_i16val[__pyx_v_ij])); } - /* "PyCafe.pyx":5035 + /* "PyCafe.pyx":5237 * for ij in range(0, nelemToRetrieveFromCache): * mvShort[ij] = i16val[ij] * free(i16val) # <<<<<<<<<<<<<< @@ -92580,7 +96629,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_i16val); - /* "PyCafe.pyx":5037 + /* "PyCafe.pyx":5239 * free(i16val) * * return mvShort # <<<<<<<<<<<<<< @@ -92588,23 +96637,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * elif art in ['array', 'array.array']: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5037, __pyx_L1_error) + __pyx_t_7 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_r = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5029 - * return mvShortNP # arr + /* "PyCafe.pyx":5231 + * return np.array(mvShort) # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< * mvShort = np.empty( * nelemToRetrieveFromCache, dtype=np.int16, order='C') */ - goto __pyx_L47; + goto __pyx_L91; } - /* "PyCafe.pyx":5039 + /* "PyCafe.pyx":5241 * return mvShort * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< @@ -92613,34 +96662,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5039, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_2 = __pyx_t_1; - goto __pyx_L60_bool_binop_done; - } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5039, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_1 != 0); - __pyx_t_2 = __pyx_t_3; - __pyx_L60_bool_binop_done:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5241, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L124_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5241, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L124_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { - /* "PyCafe.pyx":5040 + /* "PyCafe.pyx":5242 * * elif art in ['array', 'array.array']: * arrayArray = array.array('h') # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * arrayArray.append( < short > i16val[ij]) */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5040, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_v_arrayArray = __pyx_t_7; __pyx_t_7 = 0; - /* "PyCafe.pyx":5041 + /* "PyCafe.pyx":5243 * elif art in ['array', 'array.array']: * arrayArray = array.array('h') * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -92652,20 +96701,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5042 + /* "PyCafe.pyx":5244 * arrayArray = array.array('h') * for ij in range(0, nelemToRetrieveFromCache): * arrayArray.append( < short > i16val[ij]) # <<<<<<<<<<<<<< * free(i16val) * return arrayArray */ - __pyx_t_7 = __Pyx_PyInt_From_short(((short)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5042, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_short(((short)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_arrayArray, __pyx_t_7); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5042, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_arrayArray, __pyx_t_7); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5244, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } - /* "PyCafe.pyx":5043 + /* "PyCafe.pyx":5245 * for ij in range(0, nelemToRetrieveFromCache): * arrayArray.append( < short > i16val[ij]) * free(i16val) # <<<<<<<<<<<<<< @@ -92674,7 +96723,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_i16val); - /* "PyCafe.pyx":5044 + /* "PyCafe.pyx":5246 * arrayArray.append( < short > i16val[ij]) * free(i16val) * return arrayArray # <<<<<<<<<<<<<< @@ -92686,17 +96735,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_r = __pyx_v_arrayArray; goto __pyx_L0; - /* "PyCafe.pyx":5039 + /* "PyCafe.pyx":5241 * return mvShort * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< * arrayArray = array.array('h') * for ij in range(0, nelemToRetrieveFromCache): */ - goto __pyx_L47; + goto __pyx_L91; } - /* "PyCafe.pyx":5046 + /* "PyCafe.pyx":5248 * return arrayArray * * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< @@ -92705,36 +96754,804 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5046, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); - if (!__pyx_t_1) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5248, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (!__pyx_t_3) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L64_bool_binop_done; + __pyx_t_2 = __pyx_t_3; + goto __pyx_L128_bool_binop_done; } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5046, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - __pyx_t_3 = __pyx_t_2; - __pyx_L64_bool_binop_done:; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5248, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L128_bool_binop_done:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_2 = (__pyx_t_3 != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5047 + /* "PyCafe.pyx":5249 * * elif art in ['ctypes', 'ctype']: * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * ctypesArray[ij] = i16val[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5047, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_c_int16); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_c_int16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5047, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = PyNumber_Multiply(__pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_7 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_ctypesArray = __pyx_t_7; + __pyx_t_7 = 0; + + /* "PyCafe.pyx":5250 + * elif art in ['ctypes', 'ctype']: + * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * ctypesArray[ij] = i16val[ij] + * free(i16val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5251 + * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() + * for ij in range(0, nelemToRetrieveFromCache): + * ctypesArray[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * return ctypesArray + */ + __pyx_t_7 = __Pyx_PyInt_From_short(((short)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_7, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5251, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + + /* "PyCafe.pyx":5252 + * for ij in range(0, nelemToRetrieveFromCache): + * ctypesArray[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * return ctypesArray + * + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":5253 + * ctypesArray[ij] = i16val[ij] + * free(i16val) + * return ctypesArray # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_ctypesArray); + __pyx_r = __pyx_v_ctypesArray; + goto __pyx_L0; + + /* "PyCafe.pyx":5248 + * return arrayArray + * + * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< + * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() + * for ij in range(0, nelemToRetrieveFromCache): + */ + goto __pyx_L91; + } + + /* "PyCafe.pyx":5256 + * + * else: + * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") + */ + /*else*/ { + + /* "PyCafe.pyx":5257 + * else: + * print("Unknow array type in user request for art='", + * art, "'. Possible types are:") # <<<<<<<<<<<<<< + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") + */ + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); + __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); + __Pyx_INCREF(__pyx_v_art); + __Pyx_GIVEREF(__pyx_v_art); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_art); + __Pyx_INCREF(__pyx_kp_u_Possible_types_are); + __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_Possible_types_are); + + /* "PyCafe.pyx":5256 + * + * else: + * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "PyCafe.pyx":5258 + * print("Unknow array type in user request for art='", + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") # <<<<<<<<<<<<<< + * print("Returning memoryview") + * mvShort = np.empty( + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "PyCafe.pyx":5259 + * art, "'. Possible types are:") + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") # <<<<<<<<<<<<<< + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "PyCafe.pyx":5260 + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "PyCafe.pyx":5261 + * print("Returning memoryview") + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = i16val[ij] + */ + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "PyCafe.pyx":5260 + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); + __pyx_t_6 = 0; + + /* "PyCafe.pyx":5261 + * print("Returning memoryview") + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = i16val[ij] + */ + __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_int16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(3, 5261, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5261, __pyx_L1_error) + + /* "PyCafe.pyx":5260 + * print("memoryview, numpy, array, ctypes") + * print("Returning memoryview") + * mvShort = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 5260, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_mvShort = __pyx_t_18; + __pyx_t_18.memview = NULL; + __pyx_t_18.data = NULL; + + /* "PyCafe.pyx":5262 + * mvShort = np.empty( + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvShort[ij] = i16val[ij] + * free(i16val) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5263 + * nelemToRetrieveFromCache, dtype=np.int16, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< + * free(i16val) + * + */ + __pyx_t_24 = __pyx_v_ij; + __pyx_t_8 = -1; + if (unlikely(__pyx_t_24 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_8 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_8); + __PYX_ERR(3, 5263, __pyx_L1_error) + } + *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_24)) )) = ((short)(__pyx_v_i16val[__pyx_v_ij])); + } + + /* "PyCafe.pyx":5264 + * for ij in range(0, nelemToRetrieveFromCache): + * mvShort[ij] = i16val[ij] + * free(i16val) # <<<<<<<<<<<<<< + * + * return mvShort + */ + free(__pyx_v_i16val); + + /* "PyCafe.pyx":5266 + * free(i16val) + * + * return mvShort # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + } + __pyx_L91:; + + /* "PyCafe.pyx":5190 + * 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 + * + */ + } + + /* "PyCafe.pyx":5184 + * + * + * elif dtcheck in [CAFE_SHORT]: # <<<<<<<<<<<<<< + * + * i16val = malloc(nelemToRetrieveFromCache * sizeof(np.int16)) + */ + break; + case CAFE_LONG: + + /* "PyCafe.pyx":5273 + * elif dtcheck in [CAFE_LONG]: + * + * ival = malloc(nelemToRetrieveFromCache * sizeof(np.int32)) # <<<<<<<<<<<<<< + * + * status = self._c_cafe.getCacheLongArray(handle, ival) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int32); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_ival = ((int *)malloc((__pyx_v_nelemToRetrieveFromCache * (sizeof(__pyx_t_6))))); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "PyCafe.pyx":5275 + * ival = malloc(nelemToRetrieveFromCache * sizeof(np.int32)) + * + * status = self._c_cafe.getCacheLongArray(handle, ival) # <<<<<<<<<<<<<< + * + * if status == ICAFE_NORMAL: + */ + __pyx_v_status = __pyx_v_self->_c_cafe->getCacheLongArray(__pyx_v_handle, __pyx_v_ival); + + /* "PyCafe.pyx":5277 + * status = self._c_cafe.getCacheLongArray(handle, ival) + * + * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< + * + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: + */ + __pyx_t_1 = ((__pyx_v_status == ICAFE_NORMAL) != 0); + if (__pyx_t_1) { + + /* "PyCafe.pyx":5279 + * if status == ICAFE_NORMAL: + * + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< + * + * mvIntNP = np.empty( + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_16 = __pyx_v_art; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5279, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L136_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5279, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L136_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5279, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L136_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5279, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L136_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5279, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L136_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + + /* "PyCafe.pyx":5281 + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: + * + * mvIntNP = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int32, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "PyCafe.pyx":5282 + * + * mvIntNP = np.empty( + * nelemToRetrieveFromCache, dtype=np.int32, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvIntNP[ij] = ival[ij] + */ + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "PyCafe.pyx":5281 + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: + * + * mvIntNP = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int32, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); + __pyx_t_6 = 0; + + /* "PyCafe.pyx":5282 + * + * mvIntNP = np.empty( + * nelemToRetrieveFromCache, dtype=np.int32, order='C') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvIntNP[ij] = ival[ij] + */ + __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int32); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_17) < 0) __PYX_ERR(3, 5282, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5282, __pyx_L1_error) + + /* "PyCafe.pyx":5281 + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: + * + * mvIntNP = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.int32, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_mvIntNP = __pyx_t_17; + __pyx_t_17 = 0; + + /* "PyCafe.pyx":5283 + * mvIntNP = np.empty( + * nelemToRetrieveFromCache, dtype=np.int32, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvIntNP[ij] = ival[ij] + * free(ival) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5284 + * nelemToRetrieveFromCache, dtype=np.int32, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvIntNP[ij] = ival[ij] # <<<<<<<<<<<<<< + * free(ival) + * return mvIntNP # arr + */ + __pyx_t_17 = __Pyx_PyInt_From_npy_int32(((__pyx_t_5numpy_int32_t)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + if (unlikely(__Pyx_SetItemInt(__pyx_v_mvIntNP, __pyx_v_ij, __pyx_t_17, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5284, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } + + /* "PyCafe.pyx":5285 + * for ij in range(0, nelemToRetrieveFromCache): + * mvIntNP[ij] = ival[ij] + * free(ival) # <<<<<<<<<<<<<< + * return mvIntNP # arr + * + */ + free(__pyx_v_ival); + + /* "PyCafe.pyx":5286 + * mvIntNP[ij] = ival[ij] + * free(ival) + * return mvIntNP # arr # <<<<<<<<<<<<<< + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_mvIntNP); + __pyx_r = __pyx_v_mvIntNP; + goto __pyx_L0; + + /* "PyCafe.pyx":5279 + * if status == ICAFE_NORMAL: + * + * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< + * + * mvIntNP = np.empty( + */ + goto __pyx_L135; + } + + /* "PyCafe.pyx":5288 + * return mvIntNP # arr + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< + * mvInt = np.empty(nelemToRetrieveFromCache, + * dtype=np.int32, order='C') + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_16 = __pyx_v_art; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5288, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L143_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5288, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L143_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5288, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + __pyx_t_3 = __pyx_t_2; + __pyx_L143_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "PyCafe.pyx":5289 + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvInt = np.empty(nelemToRetrieveFromCache, # <<<<<<<<<<<<<< + * dtype=np.int32, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_17); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_17); + __pyx_t_17 = 0; + + /* "PyCafe.pyx":5290 + * 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] + */ + __pyx_t_17 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int32); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(3, 5290, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5290, __pyx_L1_error) + + /* "PyCafe.pyx":5289 + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: + * mvInt = np.empty(nelemToRetrieveFromCache, # <<<<<<<<<<<<<< + * dtype=np.int32, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, __pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_25 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_7, PyBUF_WRITABLE); if (unlikely(!__pyx_t_25.memview)) __PYX_ERR(3, 5289, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_mvInt = __pyx_t_25; + __pyx_t_25.memview = NULL; + __pyx_t_25.data = NULL; + + /* "PyCafe.pyx":5291 + * mvInt = np.empty(nelemToRetrieveFromCache, + * dtype=np.int32, order='C') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * mvInt[ij] = ival[ij] + * free(ival) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5292 + * dtype=np.int32, order='C') + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt[ij] = ival[ij] # <<<<<<<<<<<<<< + * free(ival) + * return mvInt + */ + __pyx_t_26 = __pyx_v_ij; + __pyx_t_8 = -1; + if (unlikely(__pyx_t_26 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_8 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_8); + __PYX_ERR(3, 5292, __pyx_L1_error) + } + *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_26)) )) = ((int)(__pyx_v_ival[__pyx_v_ij])); + } + + /* "PyCafe.pyx":5293 + * for ij in range(0, nelemToRetrieveFromCache): + * mvInt[ij] = ival[ij] + * free(ival) # <<<<<<<<<<<<<< + * return mvInt + * + */ + free(__pyx_v_ival); + + /* "PyCafe.pyx":5294 + * mvInt[ij] = ival[ij] + * free(ival) + * return mvInt # <<<<<<<<<<<<<< + * + * elif art in ['array', 'array.array']: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + + /* "PyCafe.pyx":5288 + * return mvIntNP # arr + * + * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< + * mvInt = np.empty(nelemToRetrieveFromCache, + * dtype=np.int32, order='C') + */ + goto __pyx_L135; + } + + /* "PyCafe.pyx":5296 + * return mvInt + * + * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< + * arrayArray = array.array('h') + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_16 = __pyx_v_art; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5296, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L148_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5296, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + __pyx_t_2 = __pyx_t_3; + __pyx_L148_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "PyCafe.pyx":5297 + * + * elif art in ['array', 'array.array']: + * arrayArray = array.array('h') # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * arrayArray.append( < int > ival[ij]) + */ + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_v_arrayArray = __pyx_t_7; + __pyx_t_7 = 0; + + /* "PyCafe.pyx":5298 + * elif art in ['array', 'array.array']: + * arrayArray = array.array('h') + * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< + * arrayArray.append( < int > ival[ij]) + * free(ival) + */ + __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; + __pyx_t_10 = __pyx_t_4; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_ij = __pyx_t_11; + + /* "PyCafe.pyx":5299 + * arrayArray = array.array('h') + * for ij in range(0, nelemToRetrieveFromCache): + * arrayArray.append( < int > ival[ij]) # <<<<<<<<<<<<<< + * free(ival) + * return arrayArray + */ + __pyx_t_7 = __Pyx_PyInt_From_int(((int)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_arrayArray, __pyx_t_7); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + + /* "PyCafe.pyx":5300 + * for ij in range(0, nelemToRetrieveFromCache): + * arrayArray.append( < int > ival[ij]) + * free(ival) # <<<<<<<<<<<<<< + * return arrayArray + * + */ + free(__pyx_v_ival); + + /* "PyCafe.pyx":5301 + * arrayArray.append( < int > ival[ij]) + * free(ival) + * return arrayArray # <<<<<<<<<<<<<< + * + * elif art in ['ctypes', 'ctype']: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_arrayArray); + __pyx_r = __pyx_v_arrayArray; + goto __pyx_L0; + + /* "PyCafe.pyx":5296 + * return mvInt + * + * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< + * arrayArray = array.array('h') + * for ij in range(0, nelemToRetrieveFromCache): + */ + goto __pyx_L135; + } + + /* "PyCafe.pyx":5303 + * return arrayArray + * + * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< + * ctypesArray = (ctypes.c_int32*nelemToRetrieveFromCache)() + * for ij in range(0, nelemToRetrieveFromCache): + */ + __Pyx_INCREF(__pyx_v_art); + __pyx_t_16 = __pyx_v_art; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5303, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L152_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5303, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + __pyx_t_3 = __pyx_t_2; + __pyx_L152_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "PyCafe.pyx":5304 + * + * elif art in ['ctypes', 'ctype']: + * ctypesArray = (ctypes.c_int32*nelemToRetrieveFromCache)() # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * ctypesArray[ij] = ival[ij] + */ + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_c_int32); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5047, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); - __pyx_t_6 = PyNumber_Multiply(__pyx_t_9, __pyx_t_17); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5047, __pyx_L1_error) + __pyx_t_6 = PyNumber_Multiply(__pyx_t_9, __pyx_t_17); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; @@ -92750,781 +97567,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC } __pyx_t_7 = (__pyx_t_17) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_17) : __Pyx_PyObject_CallNoArg(__pyx_t_6); __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5047, __pyx_L1_error) + if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_ctypesArray = __pyx_t_7; __pyx_t_7 = 0; - /* "PyCafe.pyx":5048 - * elif art in ['ctypes', 'ctype']: - * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() - * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< - * ctypesArray[ij] = i16val[ij] - * free(i16val) - */ - __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; - __pyx_t_10 = __pyx_t_4; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_ij = __pyx_t_11; - - /* "PyCafe.pyx":5049 - * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() - * for ij in range(0, nelemToRetrieveFromCache): - * ctypesArray[ij] = i16val[ij] # <<<<<<<<<<<<<< - * free(i16val) - * return ctypesArray - */ - __pyx_t_7 = __Pyx_PyInt_From_short(((short)(__pyx_v_i16val[__pyx_v_ij]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5049, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_7, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5049, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } - - /* "PyCafe.pyx":5050 - * for ij in range(0, nelemToRetrieveFromCache): - * ctypesArray[ij] = i16val[ij] - * free(i16val) # <<<<<<<<<<<<<< - * return ctypesArray - * - */ - free(__pyx_v_i16val); - - /* "PyCafe.pyx":5051 - * ctypesArray[ij] = i16val[ij] - * free(i16val) - * return ctypesArray # <<<<<<<<<<<<<< - * - * else: - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_ctypesArray); - __pyx_r = __pyx_v_ctypesArray; - goto __pyx_L0; - - /* "PyCafe.pyx":5046 - * return arrayArray - * - * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< - * ctypesArray = (ctypes.c_int16*nelemToRetrieveFromCache)() - * for ij in range(0, nelemToRetrieveFromCache): - */ - goto __pyx_L47; - } - - /* "PyCafe.pyx":5054 - * - * else: - * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< - * art, "'. Possible types are:") - * print("memoryview, numpy, array, ctypes") - */ - /*else*/ { - - /* "PyCafe.pyx":5055 - * else: - * print("Unknow array type in user request for art='", - * art, "'. Possible types are:") # <<<<<<<<<<<<<< - * print("memoryview, numpy, array, ctypes") - * print("Returning memoryview") - */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5054, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); - __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Unknow_array_type_in_user_reques); - __Pyx_INCREF(__pyx_v_art); - __Pyx_GIVEREF(__pyx_v_art); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_art); - __Pyx_INCREF(__pyx_kp_u_Possible_types_are); - __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_Possible_types_are); - - /* "PyCafe.pyx":5054 - * - * else: - * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< - * art, "'. Possible types are:") - * print("memoryview, numpy, array, ctypes") - */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5054, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "PyCafe.pyx":5056 - * print("Unknow array type in user request for art='", - * art, "'. Possible types are:") - * print("memoryview, numpy, array, ctypes") # <<<<<<<<<<<<<< - * print("Returning memoryview") - * mvShort = np.empty( - */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5056, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "PyCafe.pyx":5057 - * art, "'. Possible types are:") - * print("memoryview, numpy, array, ctypes") - * print("Returning memoryview") # <<<<<<<<<<<<<< - * mvShort = np.empty( - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5057, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "PyCafe.pyx":5058 - * print("memoryview, numpy, array, ctypes") - * print("Returning memoryview") - * mvShort = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5058, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5058, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "PyCafe.pyx":5059 - * print("Returning memoryview") - * mvShort = np.empty( - * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< - * for ij in range(0, nelemToRetrieveFromCache): - * mvShort[ij] = i16val[ij] - */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - - /* "PyCafe.pyx":5058 - * print("memoryview, numpy, array, ctypes") - * print("Returning memoryview") - * mvShort = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - */ - __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5058, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_6); - __pyx_t_6 = 0; - - /* "PyCafe.pyx":5059 - * print("Returning memoryview") - * mvShort = np.empty( - * nelemToRetrieveFromCache, dtype=np.int16, order='C') # <<<<<<<<<<<<<< - * for ij in range(0, nelemToRetrieveFromCache): - * mvShort[ij] = i16val[ij] - */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_int16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5059, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(3, 5059, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5059, __pyx_L1_error) - - /* "PyCafe.pyx":5058 - * print("memoryview, numpy, array, ctypes") - * print("Returning memoryview") - * mvShort = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_17, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5058, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_5numpy_int16_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(3, 5058, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_mvShort = __pyx_t_18; - __pyx_t_18.memview = NULL; - __pyx_t_18.data = NULL; - - /* "PyCafe.pyx":5060 - * mvShort = np.empty( - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< - * mvShort[ij] = i16val[ij] - * free(i16val) - */ - __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; - __pyx_t_10 = __pyx_t_4; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_ij = __pyx_t_11; - - /* "PyCafe.pyx":5061 - * nelemToRetrieveFromCache, dtype=np.int16, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - * mvShort[ij] = i16val[ij] # <<<<<<<<<<<<<< - * free(i16val) - * - */ - __pyx_t_20 = __pyx_v_ij; - __pyx_t_8 = -1; - if (unlikely(__pyx_t_20 >= (size_t)__pyx_v_mvShort.shape[0])) __pyx_t_8 = 0; - if (unlikely(__pyx_t_8 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_8); - __PYX_ERR(3, 5061, __pyx_L1_error) - } - *((__pyx_t_5numpy_int16_t *) ( /* dim=0 */ ((char *) (((__pyx_t_5numpy_int16_t *) __pyx_v_mvShort.data) + __pyx_t_20)) )) = ((short)(__pyx_v_i16val[__pyx_v_ij])); - } - - /* "PyCafe.pyx":5062 - * for ij in range(0, nelemToRetrieveFromCache): - * mvShort[ij] = i16val[ij] - * free(i16val) # <<<<<<<<<<<<<< - * - * return mvShort - */ - free(__pyx_v_i16val); - - /* "PyCafe.pyx":5064 - * free(i16val) - * - * return mvShort # <<<<<<<<<<<<<< - * - * elif dtcheck in [CAFE_LONG]: - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __pyx_memoryview_fromslice(__pyx_v_mvShort, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int16_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int16_t, 0);; if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5064, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - } - __pyx_L47:; - - /* "PyCafe.pyx":5013 - * 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 - * - */ - } - - /* "PyCafe.pyx":5007 - * return mvStr - * ''' - * elif dtcheck in [CAFE_SHORT, CAFE_CHAR]: # <<<<<<<<<<<<<< - * - * i16val = malloc(nelemToRetrieveFromCache * sizeof(np.int16)) - */ - break; - case CAFE_LONG: - - /* "PyCafe.pyx":5068 - * elif dtcheck in [CAFE_LONG]: - * - * ival = malloc(nelemToRetrieveFromCache * sizeof(np.int32)) # <<<<<<<<<<<<<< - * - * status = self._c_cafe.getCacheLongArray(handle, ival) - */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5068, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int32); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5068, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_ival = ((int *)malloc((__pyx_v_nelemToRetrieveFromCache * (sizeof(__pyx_t_6))))); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "PyCafe.pyx":5070 - * ival = malloc(nelemToRetrieveFromCache * sizeof(np.int32)) - * - * status = self._c_cafe.getCacheLongArray(handle, ival) # <<<<<<<<<<<<<< - * - * if status == ICAFE_NORMAL: - */ - __pyx_v_status = __pyx_v_self->_c_cafe->getCacheLongArray(__pyx_v_handle, __pyx_v_ival); - - /* "PyCafe.pyx":5072 - * status = self._c_cafe.getCacheLongArray(handle, ival) - * - * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< - * - * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: - */ - __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); - if (__pyx_t_2) { - - /* "PyCafe.pyx":5074 - * if status == ICAFE_NORMAL: - * - * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< - * - * mvIntNP = np.empty( - */ - __Pyx_INCREF(__pyx_v_art); - __pyx_t_16 = __pyx_v_art; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5074, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_2 = __pyx_t_1; - goto __pyx_L72_bool_binop_done; - } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5074, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_1 != 0); - if (!__pyx_t_3) { - } else { - __pyx_t_2 = __pyx_t_3; - goto __pyx_L72_bool_binop_done; - } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5074, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_2 = __pyx_t_1; - goto __pyx_L72_bool_binop_done; - } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5074, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_1 != 0); - if (!__pyx_t_3) { - } else { - __pyx_t_2 = __pyx_t_3; - goto __pyx_L72_bool_binop_done; - } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5074, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 0); - __pyx_t_2 = __pyx_t_1; - __pyx_L72_bool_binop_done:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { - - /* "PyCafe.pyx":5076 - * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: - * - * mvIntNP = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int32, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5076, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5076, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "PyCafe.pyx":5077 - * - * mvIntNP = np.empty( - * nelemToRetrieveFromCache, dtype=np.int32, order='C') # <<<<<<<<<<<<<< - * for ij in range(0, nelemToRetrieveFromCache): - * mvIntNP[ij] = ival[ij] - */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5077, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - - /* "PyCafe.pyx":5076 - * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: - * - * mvIntNP = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int32, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - */ - __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5076, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_6); - __pyx_t_6 = 0; - - /* "PyCafe.pyx":5077 - * - * mvIntNP = np.empty( - * nelemToRetrieveFromCache, dtype=np.int32, order='C') # <<<<<<<<<<<<<< - * for ij in range(0, nelemToRetrieveFromCache): - * mvIntNP[ij] = ival[ij] - */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5077, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5077, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int32); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5077, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 5077, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5077, __pyx_L1_error) - - /* "PyCafe.pyx":5076 - * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: - * - * mvIntNP = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.int32, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - */ - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_17, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5076, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_mvIntNP = __pyx_t_9; - __pyx_t_9 = 0; - - /* "PyCafe.pyx":5078 - * mvIntNP = np.empty( - * nelemToRetrieveFromCache, dtype=np.int32, order='C') - * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< - * mvIntNP[ij] = ival[ij] - * free(ival) - */ - __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; - __pyx_t_10 = __pyx_t_4; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_ij = __pyx_t_11; - - /* "PyCafe.pyx":5079 - * nelemToRetrieveFromCache, dtype=np.int32, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - * mvIntNP[ij] = ival[ij] # <<<<<<<<<<<<<< - * free(ival) - * return mvIntNP # arr - */ - __pyx_t_9 = __Pyx_PyInt_From_npy_int32(((__pyx_t_5numpy_int32_t)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5079, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely(__Pyx_SetItemInt(__pyx_v_mvIntNP, __pyx_v_ij, __pyx_t_9, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5079, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } - - /* "PyCafe.pyx":5080 - * for ij in range(0, nelemToRetrieveFromCache): - * mvIntNP[ij] = ival[ij] - * free(ival) # <<<<<<<<<<<<<< - * return mvIntNP # arr - * - */ - free(__pyx_v_ival); - - /* "PyCafe.pyx":5081 - * mvIntNP[ij] = ival[ij] - * free(ival) - * return mvIntNP # arr # <<<<<<<<<<<<<< - * - * elif art in ['memoryview', 'mv', 'memoryviewslice']: - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_mvIntNP); - __pyx_r = __pyx_v_mvIntNP; - goto __pyx_L0; - - /* "PyCafe.pyx":5074 - * if status == ICAFE_NORMAL: - * - * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< - * - * mvIntNP = np.empty( - */ - goto __pyx_L71; - } - - /* "PyCafe.pyx":5083 - * return mvIntNP # arr - * - * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< - * mvInt = np.empty(nelemToRetrieveFromCache, - * dtype=np.int32, order='C') - */ - __Pyx_INCREF(__pyx_v_art); - __pyx_t_16 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5083, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_2 != 0); - if (!__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L79_bool_binop_done; - } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5083, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_3 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L79_bool_binop_done; - } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5083, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_2 != 0); - __pyx_t_1 = __pyx_t_3; - __pyx_L79_bool_binop_done:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_3 = (__pyx_t_1 != 0); - if (__pyx_t_3) { - - /* "PyCafe.pyx":5084 - * - * elif art in ['memoryview', 'mv', 'memoryviewslice']: - * mvInt = np.empty(nelemToRetrieveFromCache, # <<<<<<<<<<<<<< - * dtype=np.int32, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5084, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5084, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5084, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5084, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_9); - __pyx_t_9 = 0; - - /* "PyCafe.pyx":5085 - * 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] - */ - __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5085, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5085, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int32); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5085, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(3, 5085, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5085, __pyx_L1_error) - - /* "PyCafe.pyx":5084 - * - * elif art in ['memoryview', 'mv', 'memoryviewslice']: - * mvInt = np.empty(nelemToRetrieveFromCache, # <<<<<<<<<<<<<< - * dtype=np.int32, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - */ - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5084, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_21 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_7, PyBUF_WRITABLE); if (unlikely(!__pyx_t_21.memview)) __PYX_ERR(3, 5084, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_mvInt = __pyx_t_21; - __pyx_t_21.memview = NULL; - __pyx_t_21.data = NULL; - - /* "PyCafe.pyx":5086 - * mvInt = np.empty(nelemToRetrieveFromCache, - * dtype=np.int32, order='C') - * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< - * mvInt[ij] = ival[ij] - * free(ival) - */ - __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; - __pyx_t_10 = __pyx_t_4; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_ij = __pyx_t_11; - - /* "PyCafe.pyx":5087 - * dtype=np.int32, order='C') - * for ij in range(0, nelemToRetrieveFromCache): - * mvInt[ij] = ival[ij] # <<<<<<<<<<<<<< - * free(ival) - * return mvInt - */ - __pyx_t_22 = __pyx_v_ij; - __pyx_t_8 = -1; - if (unlikely(__pyx_t_22 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_8 = 0; - if (unlikely(__pyx_t_8 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_8); - __PYX_ERR(3, 5087, __pyx_L1_error) - } - *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_22)) )) = ((int)(__pyx_v_ival[__pyx_v_ij])); - } - - /* "PyCafe.pyx":5088 - * for ij in range(0, nelemToRetrieveFromCache): - * mvInt[ij] = ival[ij] - * free(ival) # <<<<<<<<<<<<<< - * return mvInt - * - */ - free(__pyx_v_ival); - - /* "PyCafe.pyx":5089 - * mvInt[ij] = ival[ij] - * free(ival) - * return mvInt # <<<<<<<<<<<<<< - * - * elif art in ['array', 'array.array']: - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5089, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_r = __pyx_t_7; - __pyx_t_7 = 0; - goto __pyx_L0; - - /* "PyCafe.pyx":5083 - * return mvIntNP # arr - * - * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< - * mvInt = np.empty(nelemToRetrieveFromCache, - * dtype=np.int32, order='C') - */ - goto __pyx_L71; - } - - /* "PyCafe.pyx":5091 - * return mvInt - * - * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< - * arrayArray = array.array('h') - * for ij in range(0, nelemToRetrieveFromCache): - */ - __Pyx_INCREF(__pyx_v_art); - __pyx_t_16 = __pyx_v_art; - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5091, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_3 = __pyx_t_2; - goto __pyx_L84_bool_binop_done; - } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5091, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); - __pyx_t_3 = __pyx_t_1; - __pyx_L84_bool_binop_done:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_1 = (__pyx_t_3 != 0); - if (__pyx_t_1) { - - /* "PyCafe.pyx":5092 - * - * elif art in ['array', 'array.array']: - * arrayArray = array.array('h') # <<<<<<<<<<<<<< - * for ij in range(0, nelemToRetrieveFromCache): - * arrayArray.append( < int > ival[ij]) - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5092, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_v_arrayArray = __pyx_t_7; - __pyx_t_7 = 0; - - /* "PyCafe.pyx":5093 - * elif art in ['array', 'array.array']: - * arrayArray = array.array('h') - * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< - * arrayArray.append( < int > ival[ij]) - * free(ival) - */ - __pyx_t_4 = __pyx_v_nelemToRetrieveFromCache; - __pyx_t_10 = __pyx_t_4; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_ij = __pyx_t_11; - - /* "PyCafe.pyx":5094 - * arrayArray = array.array('h') - * for ij in range(0, nelemToRetrieveFromCache): - * arrayArray.append( < int > ival[ij]) # <<<<<<<<<<<<<< - * free(ival) - * return arrayArray - */ - __pyx_t_7 = __Pyx_PyInt_From_int(((int)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5094, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_arrayArray, __pyx_t_7); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5094, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } - - /* "PyCafe.pyx":5095 - * for ij in range(0, nelemToRetrieveFromCache): - * arrayArray.append( < int > ival[ij]) - * free(ival) # <<<<<<<<<<<<<< - * return arrayArray - * - */ - free(__pyx_v_ival); - - /* "PyCafe.pyx":5096 - * arrayArray.append( < int > ival[ij]) - * free(ival) - * return arrayArray # <<<<<<<<<<<<<< - * - * elif art in ['ctypes', 'ctype']: - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_arrayArray); - __pyx_r = __pyx_v_arrayArray; - goto __pyx_L0; - - /* "PyCafe.pyx":5091 - * return mvInt - * - * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< - * arrayArray = array.array('h') - * for ij in range(0, nelemToRetrieveFromCache): - */ - goto __pyx_L71; - } - - /* "PyCafe.pyx":5098 - * return arrayArray - * - * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< - * ctypesArray = (ctypes.c_int32*nelemToRetrieveFromCache)() - * for ij in range(0, nelemToRetrieveFromCache): - */ - __Pyx_INCREF(__pyx_v_art); - __pyx_t_16 = __pyx_v_art; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5098, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_3 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L88_bool_binop_done; - } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5098, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_2 != 0); - __pyx_t_1 = __pyx_t_3; - __pyx_L88_bool_binop_done:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_3 = (__pyx_t_1 != 0); - if (__pyx_t_3) { - - /* "PyCafe.pyx":5099 - * - * elif art in ['ctypes', 'ctype']: - * ctypesArray = (ctypes.c_int32*nelemToRetrieveFromCache)() # <<<<<<<<<<<<<< - * for ij in range(0, nelemToRetrieveFromCache): - * ctypesArray[ij] = ival[ij] - */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5099, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_c_int32); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5099, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5099, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_6 = PyNumber_Multiply(__pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5099, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - } - } - __pyx_t_7 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5099, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_ctypesArray = __pyx_t_7; - __pyx_t_7 = 0; - - /* "PyCafe.pyx":5100 + /* "PyCafe.pyx":5305 * elif art in ['ctypes', 'ctype']: * ctypesArray = (ctypes.c_int32*nelemToRetrieveFromCache)() * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -93536,20 +97585,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5101 + /* "PyCafe.pyx":5306 * ctypesArray = (ctypes.c_int32*nelemToRetrieveFromCache)() * for ij in range(0, nelemToRetrieveFromCache): * ctypesArray[ij] = ival[ij] # <<<<<<<<<<<<<< * free(ival) * return ctypesArray */ - __pyx_t_7 = __Pyx_PyInt_From_int(((int)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5101, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_int(((int)(__pyx_v_ival[__pyx_v_ij]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_7, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5101, __pyx_L1_error) + if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_7, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5306, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } - /* "PyCafe.pyx":5102 + /* "PyCafe.pyx":5307 * for ij in range(0, nelemToRetrieveFromCache): * ctypesArray[ij] = ival[ij] * free(ival) # <<<<<<<<<<<<<< @@ -93558,7 +97607,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_ival); - /* "PyCafe.pyx":5103 + /* "PyCafe.pyx":5308 * ctypesArray[ij] = ival[ij] * free(ival) * return ctypesArray # <<<<<<<<<<<<<< @@ -93570,17 +97619,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_r = __pyx_v_ctypesArray; goto __pyx_L0; - /* "PyCafe.pyx":5098 + /* "PyCafe.pyx":5303 * return arrayArray * * elif art in ['ctypes', 'ctype']: # <<<<<<<<<<<<<< * ctypesArray = (ctypes.c_int32*nelemToRetrieveFromCache)() * for ij in range(0, nelemToRetrieveFromCache): */ - goto __pyx_L71; + goto __pyx_L135; } - /* "PyCafe.pyx":5106 + /* "PyCafe.pyx":5311 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< @@ -93589,14 +97638,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ /*else*/ { - /* "PyCafe.pyx":5107 + /* "PyCafe.pyx":5312 * else: * print("Unknow array type in user request for art='", * art, "'. Possible types are:") # <<<<<<<<<<<<<< * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5106, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); @@ -93608,97 +97657,97 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_Possible_types_are); - /* "PyCafe.pyx":5106 + /* "PyCafe.pyx":5311 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5106, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5108 + /* "PyCafe.pyx":5313 * 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, */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5108, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5109 + /* "PyCafe.pyx":5314 * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") # <<<<<<<<<<<<<< * mvInt = np.empty(nelemToRetrieveFromCache, * dtype=np.int32, order='C') */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5109, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5110 + /* "PyCafe.pyx":5315 * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") * mvInt = np.empty(nelemToRetrieveFromCache, # <<<<<<<<<<<<<< * dtype=np.int32, order='C') * for ij in range(0, nelemToRetrieveFromCache): */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5110, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5110, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5110, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5111 + /* "PyCafe.pyx":5316 * print("Returning memoryview") * mvInt = np.empty(nelemToRetrieveFromCache, * dtype=np.int32, order='C') # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvInt[ij] = ival[ij] */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5111, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_int32); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5111, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_int32); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(3, 5111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(3, 5316, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5111, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(3, 5316, __pyx_L1_error) - /* "PyCafe.pyx":5110 + /* "PyCafe.pyx":5315 * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") * mvInt = np.empty(nelemToRetrieveFromCache, # <<<<<<<<<<<<<< * dtype=np.int32, order='C') * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5110, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_17, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_21 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_21.memview)) __PYX_ERR(3, 5110, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_25.memview)) __PYX_ERR(3, 5315, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_mvInt = __pyx_t_21; - __pyx_t_21.memview = NULL; - __pyx_t_21.data = NULL; + __pyx_v_mvInt = __pyx_t_25; + __pyx_t_25.memview = NULL; + __pyx_t_25.data = NULL; - /* "PyCafe.pyx":5112 + /* "PyCafe.pyx":5317 * mvInt = np.empty(nelemToRetrieveFromCache, * dtype=np.int32, order='C') * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -93710,24 +97759,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5113 + /* "PyCafe.pyx":5318 * dtype=np.int32, order='C') * for ij in range(0, nelemToRetrieveFromCache): * mvInt[ij] = ival[ij] # <<<<<<<<<<<<<< * free(ival) * return mvInt */ - __pyx_t_23 = __pyx_v_ij; + __pyx_t_27 = __pyx_v_ij; __pyx_t_8 = -1; - if (unlikely(__pyx_t_23 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_27 >= (size_t)__pyx_v_mvInt.shape[0])) __pyx_t_8 = 0; if (unlikely(__pyx_t_8 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_8); - __PYX_ERR(3, 5113, __pyx_L1_error) + __PYX_ERR(3, 5318, __pyx_L1_error) } - *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_23)) )) = ((int)(__pyx_v_ival[__pyx_v_ij])); + *((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_mvInt.data) + __pyx_t_27)) )) = ((int)(__pyx_v_ival[__pyx_v_ij])); } - /* "PyCafe.pyx":5114 + /* "PyCafe.pyx":5319 * for ij in range(0, nelemToRetrieveFromCache): * mvInt[ij] = ival[ij] * free(ival) # <<<<<<<<<<<<<< @@ -93736,7 +97785,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_ival); - /* "PyCafe.pyx":5115 + /* "PyCafe.pyx":5320 * mvInt[ij] = ival[ij] * free(ival) * return mvInt # <<<<<<<<<<<<<< @@ -93744,15 +97793,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * elif dtcheck in [CAFE_FLOAT]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5115, __pyx_L1_error) + __pyx_t_5 = __pyx_memoryview_fromslice(__pyx_v_mvInt, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; } - __pyx_L71:; + __pyx_L135:; - /* "PyCafe.pyx":5072 + /* "PyCafe.pyx":5277 * status = self._c_cafe.getCacheLongArray(handle, ival) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -93761,8 +97810,8 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5066 - * return mvShort + /* "PyCafe.pyx":5271 + * * * elif dtcheck in [CAFE_LONG]: # <<<<<<<<<<<<<< * @@ -93771,7 +97820,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC break; case CAFE_FLOAT: - /* "PyCafe.pyx":5119 + /* "PyCafe.pyx":5324 * elif dtcheck in [CAFE_FLOAT]: * * fval = malloc(nelemToRetrieveFromCache * sizeof(float)) # <<<<<<<<<<<<<< @@ -93780,7 +97829,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_fval = ((float *)malloc((__pyx_v_nelemToRetrieveFromCache * (sizeof(float))))); - /* "PyCafe.pyx":5121 + /* "PyCafe.pyx":5326 * fval = malloc(nelemToRetrieveFromCache * sizeof(float)) * * status = self._c_cafe.getCacheFloatArray(handle, fval) # <<<<<<<<<<<<<< @@ -93789,17 +97838,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_status = __pyx_v_self->_c_cafe->getCacheFloatArray(__pyx_v_handle, __pyx_v_fval); - /* "PyCafe.pyx":5123 + /* "PyCafe.pyx":5328 * status = self._c_cafe.getCacheFloatArray(handle, fval) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: */ - __pyx_t_3 = ((__pyx_v_status == ICAFE_NORMAL) != 0); - if (__pyx_t_3) { + __pyx_t_2 = ((__pyx_v_status == ICAFE_NORMAL) != 0); + if (__pyx_t_2) { - /* "PyCafe.pyx":5125 + /* "PyCafe.pyx":5330 * if status == ICAFE_NORMAL: * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< @@ -93808,111 +97857,111 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5125, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_3 = __pyx_t_2; - goto __pyx_L96_bool_binop_done; - } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5125, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5330, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); if (!__pyx_t_1) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L96_bool_binop_done; + __pyx_t_2 = __pyx_t_1; + goto __pyx_L160_bool_binop_done; } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5125, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - if (!__pyx_t_2) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5330, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (!__pyx_t_3) { } else { - __pyx_t_3 = __pyx_t_2; - goto __pyx_L96_bool_binop_done; + __pyx_t_2 = __pyx_t_3; + goto __pyx_L160_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5125, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5330, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); if (!__pyx_t_1) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L96_bool_binop_done; + __pyx_t_2 = __pyx_t_1; + goto __pyx_L160_bool_binop_done; } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5125, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - __pyx_t_3 = __pyx_t_2; - __pyx_L96_bool_binop_done:; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5330, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L160_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5330, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L160_bool_binop_done:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_2 = (__pyx_t_3 != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5127 + /* "PyCafe.pyx":5332 * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: * * mvFloatNP = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5127, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5127, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5128 + /* "PyCafe.pyx":5333 * * mvFloatNP = np.empty( * nelemToRetrieveFromCache, dtype=np.float32) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvFloatNP[ij] = fval[ij] # pvd.getAsFloat(ij) */ - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5128, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - /* "PyCafe.pyx":5127 + /* "PyCafe.pyx":5332 * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: * * mvFloatNP = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5128 + /* "PyCafe.pyx":5333 * * mvFloatNP = np.empty( * nelemToRetrieveFromCache, dtype=np.float32) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvFloatNP[ij] = fval[ij] # pvd.getAsFloat(ij) */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5128, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5128, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float32); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5128, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float32); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_17) < 0) __PYX_ERR(3, 5128, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 5333, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":5127 + /* "PyCafe.pyx":5332 * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: * * mvFloatNP = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, __pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_17, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_mvFloatNP = __pyx_t_17; - __pyx_t_17 = 0; + __pyx_v_mvFloatNP = __pyx_t_9; + __pyx_t_9 = 0; - /* "PyCafe.pyx":5129 + /* "PyCafe.pyx":5334 * mvFloatNP = np.empty( * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -93924,20 +97973,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5130 + /* "PyCafe.pyx":5335 * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): * mvFloatNP[ij] = fval[ij] # pvd.getAsFloat(ij) # <<<<<<<<<<<<<< * * free(fval) */ - __pyx_t_17 = PyFloat_FromDouble(((float)(__pyx_v_fval[__pyx_v_ij]))); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - if (unlikely(__Pyx_SetItemInt(__pyx_v_mvFloatNP, __pyx_v_ij, __pyx_t_17, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5130, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_9 = PyFloat_FromDouble(((float)(__pyx_v_fval[__pyx_v_ij]))); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (unlikely(__Pyx_SetItemInt(__pyx_v_mvFloatNP, __pyx_v_ij, __pyx_t_9, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5335, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } - /* "PyCafe.pyx":5132 + /* "PyCafe.pyx":5337 * mvFloatNP[ij] = fval[ij] # pvd.getAsFloat(ij) * * free(fval) # <<<<<<<<<<<<<< @@ -93946,7 +97995,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_fval); - /* "PyCafe.pyx":5134 + /* "PyCafe.pyx":5339 * free(fval) * * return mvFloatNP # arr # <<<<<<<<<<<<<< @@ -93958,17 +98007,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_r = __pyx_v_mvFloatNP; goto __pyx_L0; - /* "PyCafe.pyx":5125 + /* "PyCafe.pyx":5330 * if status == ICAFE_NORMAL: * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< * * mvFloatNP = np.empty( */ - goto __pyx_L95; + goto __pyx_L159; } - /* "PyCafe.pyx":5136 + /* "PyCafe.pyx":5341 * return mvFloatNP # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< @@ -93977,100 +98026,100 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5136, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_2 = __pyx_t_1; - goto __pyx_L103_bool_binop_done; - } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5136, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_1 != 0); + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5341, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); if (!__pyx_t_3) { } else { - __pyx_t_2 = __pyx_t_3; - goto __pyx_L103_bool_binop_done; + __pyx_t_1 = __pyx_t_3; + goto __pyx_L167_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5136, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 0); - __pyx_t_2 = __pyx_t_1; - __pyx_L103_bool_binop_done:; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5341, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L167_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5341, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L167_bool_binop_done:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { - /* "PyCafe.pyx":5139 + /* "PyCafe.pyx":5344 * * # Method A to return memory view * mvFloat = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): */ - __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - - /* "PyCafe.pyx":5140 - * # Method A to return memory view - * mvFloat = np.empty( - * nelemToRetrieveFromCache, dtype=np.float32) # <<<<<<<<<<<<<< - * for ij in range(0, nelemToRetrieveFromCache): - * mvFloat[ij] = fval[ij] - */ - __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - - /* "PyCafe.pyx":5139 - * - * # Method A to return memory view - * mvFloat = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.float32) - * for ij in range(0, nelemToRetrieveFromCache): - */ - __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5139, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_GIVEREF(__pyx_t_17); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_17); - __pyx_t_17 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":5140 + /* "PyCafe.pyx":5345 * # Method A to return memory view * mvFloat = np.empty( * nelemToRetrieveFromCache, dtype=np.float32) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvFloat[ij] = fval[ij] */ - __pyx_t_17 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5140, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "PyCafe.pyx":5344 + * + * # Method A to return memory view + * mvFloat = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.float32) + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5140, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_9); + __pyx_t_9 = 0; + + /* "PyCafe.pyx":5345 + * # Method A to return memory view + * mvFloat = np.empty( + * nelemToRetrieveFromCache, dtype=np.float32) # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvFloat[ij] = fval[ij] + */ + __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5140, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(3, 5140, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(3, 5345, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":5139 + /* "PyCafe.pyx":5344 * * # Method A to return memory view * mvFloat = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, __pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5139, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __pyx_t_24 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_7, PyBUF_WRITABLE); if (unlikely(!__pyx_t_24.memview)) __PYX_ERR(3, 5139, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_28 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_7, PyBUF_WRITABLE); if (unlikely(!__pyx_t_28.memview)) __PYX_ERR(3, 5344, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_mvFloat = __pyx_t_24; - __pyx_t_24.memview = NULL; - __pyx_t_24.data = NULL; + __pyx_v_mvFloat = __pyx_t_28; + __pyx_t_28.memview = NULL; + __pyx_t_28.data = NULL; - /* "PyCafe.pyx":5141 + /* "PyCafe.pyx":5346 * mvFloat = np.empty( * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -94082,24 +98131,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5142 + /* "PyCafe.pyx":5347 * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): * mvFloat[ij] = fval[ij] # <<<<<<<<<<<<<< * * free(fval) */ - __pyx_t_25 = __pyx_v_ij; + __pyx_t_29 = __pyx_v_ij; __pyx_t_8 = -1; - if (unlikely(__pyx_t_25 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_29 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_8 = 0; if (unlikely(__pyx_t_8 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_8); - __PYX_ERR(3, 5142, __pyx_L1_error) + __PYX_ERR(3, 5347, __pyx_L1_error) } - *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_25)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); + *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_29)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); } - /* "PyCafe.pyx":5144 + /* "PyCafe.pyx":5349 * mvFloat[ij] = fval[ij] * * free(fval) # <<<<<<<<<<<<<< @@ -94108,7 +98157,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_fval); - /* "PyCafe.pyx":5145 + /* "PyCafe.pyx":5350 * * free(fval) * return mvFloat # <<<<<<<<<<<<<< @@ -94116,23 +98165,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * # Method B to return memory view */ __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5145, __pyx_L1_error) + __pyx_t_7 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_r = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5136 + /* "PyCafe.pyx":5341 * return mvFloatNP # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< * * # Method A to return memory view */ - goto __pyx_L95; + goto __pyx_L159; } - /* "PyCafe.pyx":5159 + /* "PyCafe.pyx":5364 * ''' * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< @@ -94141,34 +98190,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5159, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_2 != 0); - if (!__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L108_bool_binop_done; - } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5159, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_3 != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L108_bool_binop_done:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5364, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L172_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5364, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + __pyx_t_3 = __pyx_t_1; + __pyx_L172_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_1 = (__pyx_t_3 != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5160 + /* "PyCafe.pyx":5365 * * elif art in ['array', 'array.array']: * arrayArray = array.array('f') # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * arrayArray.append(fval[ij]) */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5160, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_v_arrayArray = __pyx_t_7; __pyx_t_7 = 0; - /* "PyCafe.pyx":5161 + /* "PyCafe.pyx":5366 * elif art in ['array', 'array.array']: * arrayArray = array.array('f') * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -94180,20 +98229,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5162 + /* "PyCafe.pyx":5367 * arrayArray = array.array('f') * for ij in range(0, nelemToRetrieveFromCache): * arrayArray.append(fval[ij]) # <<<<<<<<<<<<<< * free(fval) * return arrayArray */ - __pyx_t_7 = PyFloat_FromDouble((__pyx_v_fval[__pyx_v_ij])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5162, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_fval[__pyx_v_ij])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_arrayArray, __pyx_t_7); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5162, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_arrayArray, __pyx_t_7); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5367, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } - /* "PyCafe.pyx":5163 + /* "PyCafe.pyx":5368 * for ij in range(0, nelemToRetrieveFromCache): * arrayArray.append(fval[ij]) * free(fval) # <<<<<<<<<<<<<< @@ -94202,7 +98251,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_fval); - /* "PyCafe.pyx":5164 + /* "PyCafe.pyx":5369 * arrayArray.append(fval[ij]) * free(fval) * return arrayArray # <<<<<<<<<<<<<< @@ -94214,17 +98263,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_r = __pyx_v_arrayArray; goto __pyx_L0; - /* "PyCafe.pyx":5159 + /* "PyCafe.pyx":5364 * ''' * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< * arrayArray = array.array('f') * for ij in range(0, nelemToRetrieveFromCache): */ - goto __pyx_L95; + goto __pyx_L159; } - /* "PyCafe.pyx":5166 + /* "PyCafe.pyx":5371 * return arrayArray * * elif art in ['ctypes', "ctype"]: # <<<<<<<<<<<<<< @@ -94233,58 +98282,58 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5166, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_1 != 0); - if (!__pyx_t_3) { + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5371, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + if (!__pyx_t_2) { } else { - __pyx_t_2 = __pyx_t_3; - goto __pyx_L112_bool_binop_done; + __pyx_t_1 = __pyx_t_2; + goto __pyx_L176_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5166, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 0); - __pyx_t_2 = __pyx_t_1; - __pyx_L112_bool_binop_done:; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5371, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L176_bool_binop_done:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { - /* "PyCafe.pyx":5167 + /* "PyCafe.pyx":5372 * * elif art in ['ctypes', "ctype"]: * ctypesArray = (ctypes.c_float*nelemToRetrieveFromCache)() # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * ctypesArray[ij] = fval[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_c_float); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5167, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5167, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_c_float); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); - __pyx_t_5 = PyNumber_Multiply(__pyx_t_9, __pyx_t_17); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_5 = PyNumber_Multiply(__pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __pyx_t_17 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_17)) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_17); + __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } - __pyx_t_7 = (__pyx_t_17) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_17) : __Pyx_PyObject_CallNoArg(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5167, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_ctypesArray = __pyx_t_7; __pyx_t_7 = 0; - /* "PyCafe.pyx":5168 + /* "PyCafe.pyx":5373 * elif art in ['ctypes', "ctype"]: * ctypesArray = (ctypes.c_float*nelemToRetrieveFromCache)() * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -94296,20 +98345,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5169 + /* "PyCafe.pyx":5374 * ctypesArray = (ctypes.c_float*nelemToRetrieveFromCache)() * for ij in range(0, nelemToRetrieveFromCache): * ctypesArray[ij] = fval[ij] # <<<<<<<<<<<<<< * free(fval) * return ctypesArray */ - __pyx_t_7 = PyFloat_FromDouble((__pyx_v_fval[__pyx_v_ij])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5169, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_fval[__pyx_v_ij])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_7, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5169, __pyx_L1_error) + if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_7, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5374, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } - /* "PyCafe.pyx":5170 + /* "PyCafe.pyx":5375 * for ij in range(0, nelemToRetrieveFromCache): * ctypesArray[ij] = fval[ij] * free(fval) # <<<<<<<<<<<<<< @@ -94318,7 +98367,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_fval); - /* "PyCafe.pyx":5171 + /* "PyCafe.pyx":5376 * ctypesArray[ij] = fval[ij] * free(fval) * return ctypesArray # <<<<<<<<<<<<<< @@ -94330,17 +98379,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_r = __pyx_v_ctypesArray; goto __pyx_L0; - /* "PyCafe.pyx":5166 + /* "PyCafe.pyx":5371 * return arrayArray * * elif art in ['ctypes', "ctype"]: # <<<<<<<<<<<<<< * ctypesArray = (ctypes.c_float*nelemToRetrieveFromCache)() * for ij in range(0, nelemToRetrieveFromCache): */ - goto __pyx_L95; + goto __pyx_L159; } - /* "PyCafe.pyx":5174 + /* "PyCafe.pyx":5379 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< @@ -94349,14 +98398,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ /*else*/ { - /* "PyCafe.pyx":5175 + /* "PyCafe.pyx":5380 * else: * print("Unknow array type in user request for art='", * art, "'. Possible types are:") # <<<<<<<<<<<<<< * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5174, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); @@ -94368,112 +98417,112 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_Possible_types_are); - /* "PyCafe.pyx":5174 + /* "PyCafe.pyx":5379 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5174, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5176 + /* "PyCafe.pyx":5381 * print("Unknow array type in user request for art='", * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") # <<<<<<<<<<<<<< * print("Returning memoryview") * mvFloat = np.empty( */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5176, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5177 + /* "PyCafe.pyx":5382 * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") # <<<<<<<<<<<<<< * mvFloat = np.empty( * nelemToRetrieveFromCache, dtype=np.float32) */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5177, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5382, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5178 + /* "PyCafe.pyx":5383 * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") * mvFloat = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5178, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5178, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5179 + /* "PyCafe.pyx":5384 * print("Returning memoryview") * mvFloat = np.empty( * nelemToRetrieveFromCache, dtype=np.float32) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvFloat[ij] = fval[ij] */ - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5179, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - /* "PyCafe.pyx":5178 + /* "PyCafe.pyx":5383 * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") * mvFloat = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5179 + /* "PyCafe.pyx":5384 * print("Returning memoryview") * mvFloat = np.empty( * nelemToRetrieveFromCache, dtype=np.float32) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvFloat[ij] = fval[ij] */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5179, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5179, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(3, 5179, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(3, 5384, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5178 + /* "PyCafe.pyx":5383 * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") * mvFloat = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_17, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5178, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_24 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_6, PyBUF_WRITABLE); if (unlikely(!__pyx_t_24.memview)) __PYX_ERR(3, 5178, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_6, PyBUF_WRITABLE); if (unlikely(!__pyx_t_28.memview)) __PYX_ERR(3, 5383, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_mvFloat = __pyx_t_24; - __pyx_t_24.memview = NULL; - __pyx_t_24.data = NULL; + __pyx_v_mvFloat = __pyx_t_28; + __pyx_t_28.memview = NULL; + __pyx_t_28.data = NULL; - /* "PyCafe.pyx":5180 + /* "PyCafe.pyx":5385 * mvFloat = np.empty( * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -94485,24 +98534,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5181 + /* "PyCafe.pyx":5386 * nelemToRetrieveFromCache, dtype=np.float32) * for ij in range(0, nelemToRetrieveFromCache): * mvFloat[ij] = fval[ij] # <<<<<<<<<<<<<< * free(fval) * return mvFloat */ - __pyx_t_26 = __pyx_v_ij; + __pyx_t_30 = __pyx_v_ij; __pyx_t_8 = -1; - if (unlikely(__pyx_t_26 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_30 >= (size_t)__pyx_v_mvFloat.shape[0])) __pyx_t_8 = 0; if (unlikely(__pyx_t_8 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_8); - __PYX_ERR(3, 5181, __pyx_L1_error) + __PYX_ERR(3, 5386, __pyx_L1_error) } - *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_26)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); + *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_mvFloat.data) + __pyx_t_30)) )) = ((float)(__pyx_v_fval[__pyx_v_ij])); } - /* "PyCafe.pyx":5182 + /* "PyCafe.pyx":5387 * for ij in range(0, nelemToRetrieveFromCache): * mvFloat[ij] = fval[ij] * free(fval) # <<<<<<<<<<<<<< @@ -94511,7 +98560,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_fval); - /* "PyCafe.pyx":5183 + /* "PyCafe.pyx":5388 * mvFloat[ij] = fval[ij] * free(fval) * return mvFloat # <<<<<<<<<<<<<< @@ -94519,15 +98568,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * elif dtcheck in [CAFE_DOUBLE]: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5183, __pyx_L1_error) + __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_mvFloat, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5388, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; } - __pyx_L95:; + __pyx_L159:; - /* "PyCafe.pyx":5123 + /* "PyCafe.pyx":5328 * status = self._c_cafe.getCacheFloatArray(handle, fval) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -94536,7 +98585,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5117 + /* "PyCafe.pyx":5322 * return mvInt * * elif dtcheck in [CAFE_FLOAT]: # <<<<<<<<<<<<<< @@ -94546,7 +98595,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC break; case CAFE_DOUBLE: - /* "PyCafe.pyx":5187 + /* "PyCafe.pyx":5392 * elif dtcheck in [CAFE_DOUBLE]: * * dval = malloc(nelemToRetrieveFromCache * sizeof(double)) # <<<<<<<<<<<<<< @@ -94555,7 +98604,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_dval = ((double *)malloc((__pyx_v_nelemToRetrieveFromCache * (sizeof(double))))); - /* "PyCafe.pyx":5189 + /* "PyCafe.pyx":5394 * dval = malloc(nelemToRetrieveFromCache * sizeof(double)) * * status = self._c_cafe.getDoubleArray(handle, dval) # <<<<<<<<<<<<<< @@ -94564,17 +98613,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_status = __pyx_v_self->_c_cafe->getDoubleArray(__pyx_v_handle, __pyx_v_dval); - /* "PyCafe.pyx":5191 + /* "PyCafe.pyx":5396 * status = self._c_cafe.getDoubleArray(handle, dval) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: */ - __pyx_t_1 = ((__pyx_v_status == ICAFE_NORMAL) != 0); - if (__pyx_t_1) { + __pyx_t_3 = ((__pyx_v_status == ICAFE_NORMAL) != 0); + if (__pyx_t_3) { - /* "PyCafe.pyx":5193 + /* "PyCafe.pyx":5398 * if status == ICAFE_NORMAL: * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< @@ -94583,111 +98632,111 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_2 != 0); - if (!__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L120_bool_binop_done; - } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_numpy, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5398, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); if (!__pyx_t_2) { } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L120_bool_binop_done; + __pyx_t_3 = __pyx_t_2; + goto __pyx_L184_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_2 != 0); - if (!__pyx_t_3) { + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5398, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (!__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L120_bool_binop_done; + __pyx_t_3 = __pyx_t_1; + goto __pyx_L184_bool_binop_done; } - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_numpy_ndarray, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5398, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); if (!__pyx_t_2) { } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L120_bool_binop_done; + __pyx_t_3 = __pyx_t_2; + goto __pyx_L184_bool_binop_done; } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5193, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_2 != 0); - __pyx_t_1 = __pyx_t_3; - __pyx_L120_bool_binop_done:; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_np, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5398, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L184_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_np_ndarray, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5398, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + __pyx_t_3 = __pyx_t_2; + __pyx_L184_bool_binop_done:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_3 = (__pyx_t_1 != 0); - if (__pyx_t_3) { + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { - /* "PyCafe.pyx":5195 + /* "PyCafe.pyx":5400 * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: * * mvDoubleNP = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5195, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5400, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5195, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5400, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5196 + /* "PyCafe.pyx":5401 * * mvDoubleNP = np.empty( * nelemToRetrieveFromCache, dtype=np.float64) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvDoubleNP[ij] = dval[ij] */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5196, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":5195 + /* "PyCafe.pyx":5400 * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: * * mvDoubleNP = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5195, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5196 + /* "PyCafe.pyx":5401 * * mvDoubleNP = np.empty( * nelemToRetrieveFromCache, dtype=np.float64) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvDoubleNP[ij] = dval[ij] */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5196, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5196, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float64); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5196, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float64); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5401, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(3, 5196, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_17) < 0) __PYX_ERR(3, 5401, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - /* "PyCafe.pyx":5195 + /* "PyCafe.pyx":5400 * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: * * mvDoubleNP = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_17, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5195, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_mvDoubleNP = __pyx_t_9; - __pyx_t_9 = 0; + __pyx_v_mvDoubleNP = __pyx_t_17; + __pyx_t_17 = 0; - /* "PyCafe.pyx":5197 + /* "PyCafe.pyx":5402 * mvDoubleNP = np.empty( * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -94699,20 +98748,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5198 + /* "PyCafe.pyx":5403 * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): * mvDoubleNP[ij] = dval[ij] # <<<<<<<<<<<<<< * * free(dval) */ - __pyx_t_9 = PyFloat_FromDouble(((double)(__pyx_v_dval[__pyx_v_ij]))); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5198, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely(__Pyx_SetItemInt(__pyx_v_mvDoubleNP, __pyx_v_ij, __pyx_t_9, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5198, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_17 = PyFloat_FromDouble(((double)(__pyx_v_dval[__pyx_v_ij]))); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + if (unlikely(__Pyx_SetItemInt(__pyx_v_mvDoubleNP, __pyx_v_ij, __pyx_t_17, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5403, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; } - /* "PyCafe.pyx":5200 + /* "PyCafe.pyx":5405 * mvDoubleNP[ij] = dval[ij] * * free(dval) # <<<<<<<<<<<<<< @@ -94721,7 +98770,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_dval); - /* "PyCafe.pyx":5201 + /* "PyCafe.pyx":5406 * * free(dval) * return mvDoubleNP # arr # <<<<<<<<<<<<<< @@ -94733,17 +98782,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_r = __pyx_v_mvDoubleNP; goto __pyx_L0; - /* "PyCafe.pyx":5193 + /* "PyCafe.pyx":5398 * if status == ICAFE_NORMAL: * * if art in ['numpy', 'ndarray', 'numpy.ndarray', 'np', 'np.ndarray']: # <<<<<<<<<<<<<< * * mvDoubleNP = np.empty( */ - goto __pyx_L119; + goto __pyx_L183; } - /* "PyCafe.pyx":5203 + /* "PyCafe.pyx":5408 * return mvDoubleNP # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< @@ -94752,100 +98801,100 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5203, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_3 = __pyx_t_2; - goto __pyx_L127_bool_binop_done; - } - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5203, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryview, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5408, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); if (!__pyx_t_1) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L127_bool_binop_done; + __pyx_t_2 = __pyx_t_1; + goto __pyx_L191_bool_binop_done; } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5203, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - __pyx_t_3 = __pyx_t_2; - __pyx_L127_bool_binop_done:; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_mv, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5408, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L191_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_memoryviewslice, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5408, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L191_bool_binop_done:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_2 = (__pyx_t_3 != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5206 + /* "PyCafe.pyx":5411 * * # Method A to return memory view * mvDouble = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - - /* "PyCafe.pyx":5207 - * # Method A to return memory view - * mvDouble = np.empty( - * nelemToRetrieveFromCache, dtype=np.float64) # <<<<<<<<<<<<<< - * for ij in range(0, nelemToRetrieveFromCache): - * mvDouble[ij] = dval[ij] - */ - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - - /* "PyCafe.pyx":5206 - * - * # Method A to return memory view - * mvDouble = np.empty( # <<<<<<<<<<<<<< - * nelemToRetrieveFromCache, dtype=np.float64) - * for ij in range(0, nelemToRetrieveFromCache): - */ - __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5206, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_9); - __pyx_t_9 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - /* "PyCafe.pyx":5207 + /* "PyCafe.pyx":5412 * # Method A to return memory view * mvDouble = np.empty( * nelemToRetrieveFromCache, dtype=np.float64) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvDouble[ij] = dval[ij] */ - __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5207, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + + /* "PyCafe.pyx":5411 + * + * # Method A to return memory view + * mvDouble = np.empty( # <<<<<<<<<<<<<< + * nelemToRetrieveFromCache, dtype=np.float64) + * for ij in range(0, nelemToRetrieveFromCache): + */ + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5207, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_17); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_17); + __pyx_t_17 = 0; + + /* "PyCafe.pyx":5412 + * # Method A to return memory view + * mvDouble = np.empty( + * nelemToRetrieveFromCache, dtype=np.float64) # <<<<<<<<<<<<<< + * for ij in range(0, nelemToRetrieveFromCache): + * mvDouble[ij] = dval[ij] + */ + __pyx_t_17 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float64); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5207, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float64); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(3, 5207, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_17, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(3, 5412, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":5206 + /* "PyCafe.pyx":5411 * * # Method A to return memory view * mvDouble = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5206, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, __pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_27 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_7, PyBUF_WRITABLE); if (unlikely(!__pyx_t_27.memview)) __PYX_ERR(3, 5206, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_31 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_7, PyBUF_WRITABLE); if (unlikely(!__pyx_t_31.memview)) __PYX_ERR(3, 5411, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_mvDouble = __pyx_t_27; - __pyx_t_27.memview = NULL; - __pyx_t_27.data = NULL; + __pyx_v_mvDouble = __pyx_t_31; + __pyx_t_31.memview = NULL; + __pyx_t_31.data = NULL; - /* "PyCafe.pyx":5208 + /* "PyCafe.pyx":5413 * mvDouble = np.empty( * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -94857,24 +98906,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5209 + /* "PyCafe.pyx":5414 * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): * mvDouble[ij] = dval[ij] # <<<<<<<<<<<<<< * free(dval) * return mvDouble */ - __pyx_t_28 = __pyx_v_ij; + __pyx_t_32 = __pyx_v_ij; __pyx_t_8 = -1; - if (unlikely(__pyx_t_28 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_32 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_8 = 0; if (unlikely(__pyx_t_8 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_8); - __PYX_ERR(3, 5209, __pyx_L1_error) + __PYX_ERR(3, 5414, __pyx_L1_error) } - *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_28)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); + *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_32)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); } - /* "PyCafe.pyx":5210 + /* "PyCafe.pyx":5415 * for ij in range(0, nelemToRetrieveFromCache): * mvDouble[ij] = dval[ij] * free(dval) # <<<<<<<<<<<<<< @@ -94883,7 +98932,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_dval); - /* "PyCafe.pyx":5211 + /* "PyCafe.pyx":5416 * mvDouble[ij] = dval[ij] * free(dval) * return mvDouble # <<<<<<<<<<<<<< @@ -94891,23 +98940,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * elif art in ['array', 'array.array']: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5211, __pyx_L1_error) + __pyx_t_7 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_r = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5203 + /* "PyCafe.pyx":5408 * return mvDoubleNP # arr * * elif art in ['memoryview', 'mv', 'memoryviewslice']: # <<<<<<<<<<<<<< * * # Method A to return memory view */ - goto __pyx_L119; + goto __pyx_L183; } - /* "PyCafe.pyx":5213 + /* "PyCafe.pyx":5418 * return mvDouble * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< @@ -94916,34 +98965,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5213, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_2 = __pyx_t_1; - goto __pyx_L132_bool_binop_done; - } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5213, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_1 != 0); - __pyx_t_2 = __pyx_t_3; - __pyx_L132_bool_binop_done:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_array, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5418, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L196_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_kp_u_array_array, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5418, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L196_bool_binop_done:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { - /* "PyCafe.pyx":5214 + /* "PyCafe.pyx":5419 * * elif art in ['array', 'array.array']: * arrayArray = array.array('d') # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * arrayArray.append(dval[ij]) */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5214, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7cpython_5array_array), __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_v_arrayArray = __pyx_t_7; __pyx_t_7 = 0; - /* "PyCafe.pyx":5215 + /* "PyCafe.pyx":5420 * elif art in ['array', 'array.array']: * arrayArray = array.array('d') * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -94955,20 +99004,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5216 + /* "PyCafe.pyx":5421 * arrayArray = array.array('d') * for ij in range(0, nelemToRetrieveFromCache): * arrayArray.append(dval[ij]) # <<<<<<<<<<<<<< * free(dval) * return arrayArray */ - __pyx_t_7 = PyFloat_FromDouble((__pyx_v_dval[__pyx_v_ij])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5216, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_dval[__pyx_v_ij])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_arrayArray, __pyx_t_7); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5216, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_arrayArray, __pyx_t_7); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(3, 5421, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } - /* "PyCafe.pyx":5217 + /* "PyCafe.pyx":5422 * for ij in range(0, nelemToRetrieveFromCache): * arrayArray.append(dval[ij]) * free(dval) # <<<<<<<<<<<<<< @@ -94977,7 +99026,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_dval); - /* "PyCafe.pyx":5218 + /* "PyCafe.pyx":5423 * arrayArray.append(dval[ij]) * free(dval) * return arrayArray # <<<<<<<<<<<<<< @@ -94989,17 +99038,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_r = __pyx_v_arrayArray; goto __pyx_L0; - /* "PyCafe.pyx":5213 + /* "PyCafe.pyx":5418 * return mvDouble * * elif art in ['array', 'array.array']: # <<<<<<<<<<<<<< * arrayArray = array.array('d') * for ij in range(0, nelemToRetrieveFromCache): */ - goto __pyx_L119; + goto __pyx_L183; } - /* "PyCafe.pyx":5220 + /* "PyCafe.pyx":5425 * return arrayArray * * elif art in ['ctypes', "ctype"]: # <<<<<<<<<<<<<< @@ -95008,58 +99057,58 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __Pyx_INCREF(__pyx_v_art); __pyx_t_16 = __pyx_v_art; - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5220, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); - if (!__pyx_t_1) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctypes, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5425, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (!__pyx_t_3) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L136_bool_binop_done; + __pyx_t_2 = __pyx_t_3; + goto __pyx_L200_bool_binop_done; } - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5220, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - __pyx_t_3 = __pyx_t_2; - __pyx_L136_bool_binop_done:; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_16, __pyx_n_u_ctype, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5425, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L200_bool_binop_done:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_2 = (__pyx_t_3 != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5221 + /* "PyCafe.pyx":5426 * * elif art in ['ctypes', "ctype"]: * ctypesArray = (ctypes.c_double*nelemToRetrieveFromCache)() # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * ctypesArray[ij] = dval[ij] */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5221, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_c_double); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5221, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5221, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_c_double); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_6 = PyNumber_Multiply(__pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5221, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_17 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_6 = PyNumber_Multiply(__pyx_t_9, __pyx_t_17); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_17 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_9)) { + __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_17)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(__pyx_t_17); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_7 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5221, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_17) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_17) : __Pyx_PyObject_CallNoArg(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_ctypesArray = __pyx_t_7; __pyx_t_7 = 0; - /* "PyCafe.pyx":5222 + /* "PyCafe.pyx":5427 * elif art in ['ctypes', "ctype"]: * ctypesArray = (ctypes.c_double*nelemToRetrieveFromCache)() * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -95071,20 +99120,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5223 + /* "PyCafe.pyx":5428 * ctypesArray = (ctypes.c_double*nelemToRetrieveFromCache)() * for ij in range(0, nelemToRetrieveFromCache): * ctypesArray[ij] = dval[ij] # <<<<<<<<<<<<<< * free(dval) * return ctypesArray */ - __pyx_t_7 = PyFloat_FromDouble((__pyx_v_dval[__pyx_v_ij])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5223, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_dval[__pyx_v_ij])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_7, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5223, __pyx_L1_error) + if (unlikely(__Pyx_SetItemInt(__pyx_v_ctypesArray, __pyx_v_ij, __pyx_t_7, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1) < 0)) __PYX_ERR(3, 5428, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } - /* "PyCafe.pyx":5224 + /* "PyCafe.pyx":5429 * for ij in range(0, nelemToRetrieveFromCache): * ctypesArray[ij] = dval[ij] * free(dval) # <<<<<<<<<<<<<< @@ -95093,7 +99142,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_dval); - /* "PyCafe.pyx":5225 + /* "PyCafe.pyx":5430 * ctypesArray[ij] = dval[ij] * free(dval) * return ctypesArray # <<<<<<<<<<<<<< @@ -95105,17 +99154,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_r = __pyx_v_ctypesArray; goto __pyx_L0; - /* "PyCafe.pyx":5220 + /* "PyCafe.pyx":5425 * return arrayArray * * elif art in ['ctypes', "ctype"]: # <<<<<<<<<<<<<< * ctypesArray = (ctypes.c_double*nelemToRetrieveFromCache)() * for ij in range(0, nelemToRetrieveFromCache): */ - goto __pyx_L119; + goto __pyx_L183; } - /* "PyCafe.pyx":5228 + /* "PyCafe.pyx":5433 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< @@ -95124,14 +99173,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ /*else*/ { - /* "PyCafe.pyx":5229 + /* "PyCafe.pyx":5434 * else: * print("Unknow array type in user request for art='", * art, "'. Possible types are:") # <<<<<<<<<<<<<< * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5228, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_kp_u_Unknow_array_type_in_user_reques); __Pyx_GIVEREF(__pyx_kp_u_Unknow_array_type_in_user_reques); @@ -95143,112 +99192,112 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_kp_u_Possible_types_are); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_Possible_types_are); - /* "PyCafe.pyx":5228 + /* "PyCafe.pyx":5433 * * else: * print("Unknow array type in user request for art='", # <<<<<<<<<<<<<< * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5228, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5230 + /* "PyCafe.pyx":5435 * print("Unknow array type in user request for art='", * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") # <<<<<<<<<<<<<< * print("Returning memoryview") * mvDouble = np.empty( */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5230, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5231 + /* "PyCafe.pyx":5436 * art, "'. Possible types are:") * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") # <<<<<<<<<<<<<< * mvDouble = np.empty( * nelemToRetrieveFromCache, dtype=np.float64) */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5231, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5232 + /* "PyCafe.pyx":5437 * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") * mvDouble = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5232, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5232, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5233 + /* "PyCafe.pyx":5438 * print("Returning memoryview") * mvDouble = np.empty( * nelemToRetrieveFromCache, dtype=np.float64) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvDouble[ij] = dval[ij] */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5233, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_nelemToRetrieveFromCache); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":5232 + /* "PyCafe.pyx":5437 * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") * mvDouble = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_17 = PyTuple_New(1); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5233 + /* "PyCafe.pyx":5438 * print("Returning memoryview") * mvDouble = np.empty( * nelemToRetrieveFromCache, dtype=np.float64) # <<<<<<<<<<<<<< * for ij in range(0, nelemToRetrieveFromCache): * mvDouble[ij] = dval[ij] */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5233, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(3, 5233, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_float64); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5233, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_float64); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(3, 5233, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(3, 5438, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5232 + /* "PyCafe.pyx":5437 * print("memoryview, numpy, array, ctypes") * print("Returning memoryview") * mvDouble = np.empty( # <<<<<<<<<<<<<< * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5232, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_17, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_27 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_27.memview)) __PYX_ERR(3, 5232, __pyx_L1_error) + __pyx_t_31 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_31.memview)) __PYX_ERR(3, 5437, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_mvDouble = __pyx_t_27; - __pyx_t_27.memview = NULL; - __pyx_t_27.data = NULL; + __pyx_v_mvDouble = __pyx_t_31; + __pyx_t_31.memview = NULL; + __pyx_t_31.data = NULL; - /* "PyCafe.pyx":5234 + /* "PyCafe.pyx":5439 * mvDouble = np.empty( * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): # <<<<<<<<<<<<<< @@ -95260,24 +99309,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ij = __pyx_t_11; - /* "PyCafe.pyx":5235 + /* "PyCafe.pyx":5440 * nelemToRetrieveFromCache, dtype=np.float64) * for ij in range(0, nelemToRetrieveFromCache): * mvDouble[ij] = dval[ij] # <<<<<<<<<<<<<< * free(dval) * return mvDouble */ - __pyx_t_29 = __pyx_v_ij; + __pyx_t_33 = __pyx_v_ij; __pyx_t_8 = -1; - if (unlikely(__pyx_t_29 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_8 = 0; + if (unlikely(__pyx_t_33 >= (size_t)__pyx_v_mvDouble.shape[0])) __pyx_t_8 = 0; if (unlikely(__pyx_t_8 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_8); - __PYX_ERR(3, 5235, __pyx_L1_error) + __PYX_ERR(3, 5440, __pyx_L1_error) } - *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_29)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); + *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_mvDouble.data) + __pyx_t_33)) )) = ((double)(__pyx_v_dval[__pyx_v_ij])); } - /* "PyCafe.pyx":5236 + /* "PyCafe.pyx":5441 * for ij in range(0, nelemToRetrieveFromCache): * mvDouble[ij] = dval[ij] * free(dval) # <<<<<<<<<<<<<< @@ -95286,7 +99335,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ free(__pyx_v_dval); - /* "PyCafe.pyx":5237 + /* "PyCafe.pyx":5442 * mvDouble[ij] = dval[ij] * free(dval) * return mvDouble # <<<<<<<<<<<<<< @@ -95294,15 +99343,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * if status != ICAFE_NORMAL: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5237, __pyx_L1_error) + __pyx_t_5 = __pyx_memoryview_fromslice(__pyx_v_mvDouble, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5442, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; } - __pyx_L119:; + __pyx_L183:; - /* "PyCafe.pyx":5191 + /* "PyCafe.pyx":5396 * status = self._c_cafe.getDoubleArray(handle, dval) * * if status == ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -95311,7 +99360,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5185 + /* "PyCafe.pyx":5390 * return mvFloat * * elif dtcheck in [CAFE_DOUBLE]: # <<<<<<<<<<<<<< @@ -95322,37 +99371,37 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC default: break; } - /* "PyCafe.pyx":5239 + /* "PyCafe.pyx":5444 * return mvDouble * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: */ - __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); - if (__pyx_t_2) { + __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5240 + /* "PyCafe.pyx":5445 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< * if handle == 0: * self._c_cafe.printStatusMessage(status) */ - __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); - if (__pyx_t_2) { + __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5241 + /* "PyCafe.pyx":5446 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * else: */ - __pyx_t_2 = ((__pyx_v_handle == 0) != 0); - if (__pyx_t_2) { + __pyx_t_1 = ((__pyx_v_handle == 0) != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5242 + /* "PyCafe.pyx":5447 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -95361,17 +99410,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5241 + /* "PyCafe.pyx":5446 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * else: */ - goto __pyx_L144; + goto __pyx_L208; } - /* "PyCafe.pyx":5244 + /* "PyCafe.pyx":5449 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -95381,9 +99430,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC /*else*/ { __pyx_v_self->_c_cafe->printStatus(__pyx_v_handle, __pyx_v_status); } - __pyx_L144:; + __pyx_L208:; - /* "PyCafe.pyx":5240 + /* "PyCafe.pyx":5445 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -95392,94 +99441,94 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5245 + /* "PyCafe.pyx":5450 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, */ - __pyx_t_2 = (__pyx_v_self->_enable_exceptions != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_v_self->_enable_exceptions != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5247 + /* "PyCafe.pyx":5452 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5247, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5452, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5247, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5247, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5452, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5452, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5452, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 5247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 5452, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5248 + /* "PyCafe.pyx":5453 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, * _error_text=self.cs.code(status), */ - __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5248, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 5247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 5452, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5249 + /* "PyCafe.pyx":5454 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, # <<<<<<<<<<<<<< * _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5249, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 5247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 5452, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5250 + /* "PyCafe.pyx":5455 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, * _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5250, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 5247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 5452, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5251 + /* "PyCafe.pyx":5456 * _error_code=status, * _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * return [None] */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5251, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 5247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 5452, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5246 + /* "PyCafe.pyx":5451 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5246, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5252 + /* "PyCafe.pyx":5457 * _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -95487,9 +99536,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5252, __pyx_L1_error) + __PYX_ERR(3, 5457, __pyx_L1_error) - /* "PyCafe.pyx":5245 + /* "PyCafe.pyx":5450 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -95498,7 +99547,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5253 + /* "PyCafe.pyx":5458 * _error_info=self.cs.info(status)) * raise _cafeException * return [None] # <<<<<<<<<<<<<< @@ -95506,7 +99555,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5253, __pyx_L1_error) + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); @@ -95515,7 +99564,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5239 + /* "PyCafe.pyx":5444 * return mvDouble * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -95524,7 +99573,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":4814 + /* "PyCafe.pyx":4904 * * ################################################################################## * def getArrayCache(self, handlePV, str dt='native', str art='numpy'): # <<<<<<<<<<<<<< @@ -95543,9 +99592,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_16); __Pyx_XDECREF(__pyx_t_17); __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1); - __PYX_XDEC_MEMVIEW(&__pyx_t_21, 1); - __PYX_XDEC_MEMVIEW(&__pyx_t_24, 1); - __PYX_XDEC_MEMVIEW(&__pyx_t_27, 1); + __PYX_XDEC_MEMVIEW(&__pyx_t_25, 1); + __PYX_XDEC_MEMVIEW(&__pyx_t_28, 1); + __PYX_XDEC_MEMVIEW(&__pyx_t_31, 1); __Pyx_AddTraceback("PyCafe.CyCafe.getArrayCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -95559,7 +99608,8 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_v_bVal); __Pyx_XDECREF(__pyx_v_strVal); __Pyx_XDECREF(__pyx_v_valStr); - __Pyx_XDECREF(__pyx_v_mvShortNP); + __Pyx_XDECREF(__pyx_v_mvInt8); + __Pyx_XDECREF(__pyx_v_mvUInt8); __Pyx_XDECREF(__pyx_v_arrayArray); __Pyx_XDECREF(__pyx_v_ctypesArray); __Pyx_XDECREF(__pyx_v_mvIntNP); @@ -95570,7 +99620,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_314getArrayCache(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":5261 +/* "PyCafe.pyx":5466 * ################################################################################## * * def getPVStrCache(self, handlePV): # <<<<<<<<<<<<<< @@ -95601,7 +99651,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_316getPVStrCache(struct __pyx_obj_6PyC PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getPVStrCache", 0); - /* "PyCafe.pyx":5262 + /* "PyCafe.pyx":5467 * * def getPVStrCache(self, handlePV): * return self.getPVCache(handlePV, 'str') # <<<<<<<<<<<<<< @@ -95609,7 +99659,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_316getPVStrCache(struct __pyx_obj_6PyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5262, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -95626,7 +99676,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_316getPVStrCache(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5262, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5467, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -95634,13 +99684,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_316getPVStrCache(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5262, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5467, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5262, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -95651,7 +99701,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_316getPVStrCache(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_str); __Pyx_GIVEREF(__pyx_n_u_str); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_str); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5262, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -95660,7 +99710,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_316getPVStrCache(struct __pyx_obj_6PyC __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5261 + /* "PyCafe.pyx":5466 * ################################################################################## * * def getPVStrCache(self, handlePV): # <<<<<<<<<<<<<< @@ -95684,7 +99734,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_316getPVStrCache(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":5266 +/* "PyCafe.pyx":5471 * * ################################################################################## * def getPVIntCache(self, handlePV): # <<<<<<<<<<<<<< @@ -95715,7 +99765,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_318getPVIntCache(struct __pyx_obj_6PyC PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getPVIntCache", 0); - /* "PyCafe.pyx":5267 + /* "PyCafe.pyx":5472 * ################################################################################## * def getPVIntCache(self, handlePV): * return self.getPVCache(handlePV, 'int') # <<<<<<<<<<<<<< @@ -95723,7 +99773,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_318getPVIntCache(struct __pyx_obj_6PyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5267, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -95740,7 +99790,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_318getPVIntCache(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5267, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5472, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -95748,13 +99798,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_318getPVIntCache(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5267, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5472, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5267, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -95765,7 +99815,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_318getPVIntCache(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_int); __Pyx_GIVEREF(__pyx_n_u_int); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_int); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5267, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -95774,7 +99824,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_318getPVIntCache(struct __pyx_obj_6PyC __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5266 + /* "PyCafe.pyx":5471 * * ################################################################################## * def getPVIntCache(self, handlePV): # <<<<<<<<<<<<<< @@ -95798,7 +99848,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_318getPVIntCache(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":5271 +/* "PyCafe.pyx":5476 * * ################################################################################## * def getPVFloatCache(self, handlePV): # <<<<<<<<<<<<<< @@ -95829,7 +99879,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_320getPVFloatCache(struct __pyx_obj_6P PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getPVFloatCache", 0); - /* "PyCafe.pyx":5272 + /* "PyCafe.pyx":5477 * ################################################################################## * def getPVFloatCache(self, handlePV): * return self.getPVCache(handlePV, 'float') # <<<<<<<<<<<<<< @@ -95837,7 +99887,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_320getPVFloatCache(struct __pyx_obj_6P * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5272, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -95854,7 +99904,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_320getPVFloatCache(struct __pyx_obj_6P #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5272, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5477, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -95862,13 +99912,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_320getPVFloatCache(struct __pyx_obj_6P #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_handlePV, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5272, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5477, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5272, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -95879,7 +99929,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_320getPVFloatCache(struct __pyx_obj_6P __Pyx_INCREF(__pyx_n_u_float); __Pyx_GIVEREF(__pyx_n_u_float); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_float); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5272, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -95888,7 +99938,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_320getPVFloatCache(struct __pyx_obj_6P __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5271 + /* "PyCafe.pyx":5476 * * ################################################################################## * def getPVFloatCache(self, handlePV): # <<<<<<<<<<<<<< @@ -95912,7 +99962,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_320getPVFloatCache(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":5276 +/* "PyCafe.pyx":5481 * * ################################################################################## * def getPVCache(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -95956,7 +100006,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_323getPVCache(PyObject *__pyx_v_self, } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPVCache") < 0)) __PYX_ERR(3, 5276, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPVCache") < 0)) __PYX_ERR(3, 5481, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -95972,13 +100022,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_323getPVCache(PyObject *__pyx_v_self, } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getPVCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5276, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getPVCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5481, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getPVCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 5276, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 5481, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_322getPVCache(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_dt); /* function exit code */ @@ -96008,7 +100058,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe struct __pyx_opt_args_6PyCafe_PVDataHolderToStruct __pyx_t_7; __Pyx_RefNannySetupContext("getPVCache", 0); - /* "PyCafe.pyx":5279 + /* "PyCafe.pyx":5484 * ################################################################################## * * cdef str _METHOD = "getPVCache(handlePV, str dt='native'" # <<<<<<<<<<<<<< @@ -96018,7 +100068,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe __Pyx_INCREF(__pyx_kp_u_getPVCache_handlePV_str_dt_nativ); __pyx_v__METHOD = __pyx_kp_u_getPVCache_handlePV_str_dt_nativ; - /* "PyCafe.pyx":5281 + /* "PyCafe.pyx":5486 * cdef str _METHOD = "getPVCache(handlePV, str dt='native'" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -96027,7 +100077,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe */ __pyx_v_handle = 0; - /* "PyCafe.pyx":5283 + /* "PyCafe.pyx":5488 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -96048,17 +100098,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5284 + /* "PyCafe.pyx":5489 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5284, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5489, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":5283 + /* "PyCafe.pyx":5488 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -96068,7 +100118,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe goto __pyx_L3; } - /* "PyCafe.pyx":5285 + /* "PyCafe.pyx":5490 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -96079,21 +100129,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5286 + /* "PyCafe.pyx":5491 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getPVCache. \n \ */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 5286, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5286, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 5491, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5491, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5286, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5491, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":5285 + /* "PyCafe.pyx":5490 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -96103,7 +100153,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe goto __pyx_L3; } - /* "PyCafe.pyx":5288 + /* "PyCafe.pyx":5493 * handle = self.checkForHandle(handlePV) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getPVCache. \n \ # <<<<<<<<<<<<<< @@ -96111,15 +100161,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe * */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__87, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5288, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__87, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 5288, __pyx_L1_error) + __PYX_ERR(3, 5493, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5293 + /* "PyCafe.pyx":5498 * cdef PVDataHolder pvd * * pvd.setNelem(self.hh.getNelemToRetrieveFromCache(handle)) # <<<<<<<<<<<<<< @@ -96128,7 +100178,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe */ (void)(__pyx_v_pvd.setNelem(__pyx_v_self->hh.getNelemToRetrieveFromCache(__pyx_v_handle))); - /* "PyCafe.pyx":5295 + /* "PyCafe.pyx":5500 * pvd.setNelem(self.hh.getNelemToRetrieveFromCache(handle)) * * status = self._c_cafe.getCache(handle, pvd) # <<<<<<<<<<<<<< @@ -96137,7 +100187,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe */ __pyx_v_status = __pyx_v_self->_c_cafe->getCache(__pyx_v_handle, __pyx_v_pvd); - /* "PyCafe.pyx":5297 + /* "PyCafe.pyx":5502 * status = self._c_cafe.getCache(handle, pvd) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -96147,7 +100197,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5298 + /* "PyCafe.pyx":5503 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -96157,7 +100207,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5299 + /* "PyCafe.pyx":5504 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -96167,7 +100217,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5300 + /* "PyCafe.pyx":5505 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -96176,7 +100226,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5299 + /* "PyCafe.pyx":5504 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -96186,7 +100236,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe goto __pyx_L8; } - /* "PyCafe.pyx":5302 + /* "PyCafe.pyx":5507 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -96198,7 +100248,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe } __pyx_L8:; - /* "PyCafe.pyx":5298 + /* "PyCafe.pyx":5503 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -96207,7 +100257,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":5303 + /* "PyCafe.pyx":5508 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -96217,76 +100267,76 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe __pyx_t_1 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5305 + /* "PyCafe.pyx":5510 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5305, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5510, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5305, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5305, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5305, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5510, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5510, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5510, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 5305, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 5510, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5306 + /* "PyCafe.pyx":5511 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5306, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5511, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 5305, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 5510, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5307 + /* "PyCafe.pyx":5512 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5307, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 5305, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 5510, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5307, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 5305, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 5510, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5308 + /* "PyCafe.pyx":5513 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5308, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5513, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 5305, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 5510, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5304 + /* "PyCafe.pyx":5509 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5304, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5509, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5309 + /* "PyCafe.pyx":5514 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -96294,9 +100344,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe * pvd_valnone = PVDataHolderToStruct(pvd, dt) */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5309, __pyx_L1_error) + __PYX_ERR(3, 5514, __pyx_L1_error) - /* "PyCafe.pyx":5303 + /* "PyCafe.pyx":5508 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -96305,7 +100355,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":5311 + /* "PyCafe.pyx":5516 * raise _cafeException * * pvd_valnone = PVDataHolderToStruct(pvd, dt) # <<<<<<<<<<<<<< @@ -96314,12 +100364,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe */ __pyx_t_7.__pyx_n = 1; __pyx_t_7.dt = __pyx_v_dt; - __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct(__pyx_v_pvd, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5311, __pyx_L1_error) + __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct(__pyx_v_pvd, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_pvd_valnone = ((struct __pyx_obj_6PyCafe_pvdata *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5313 + /* "PyCafe.pyx":5518 * pvd_valnone = PVDataHolderToStruct(pvd, dt) * # pvd_valnone.value[0]=None * return pvd_valnone # <<<<<<<<<<<<<< @@ -96331,7 +100381,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe __pyx_r = ((PyObject *)__pyx_v_pvd_valnone); goto __pyx_L0; - /* "PyCafe.pyx":5297 + /* "PyCafe.pyx":5502 * status = self._c_cafe.getCache(handle, pvd) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -96340,7 +100390,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":5315 + /* "PyCafe.pyx":5520 * return pvd_valnone * * return PVDataHolderToStruct(pvd, dt) # <<<<<<<<<<<<<< @@ -96350,13 +100400,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe __Pyx_XDECREF(__pyx_r); __pyx_t_7.__pyx_n = 1; __pyx_t_7.dt = __pyx_v_dt; - __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct(__pyx_v_pvd, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5315, __pyx_L1_error) + __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct(__pyx_v_pvd, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5276 + /* "PyCafe.pyx":5481 * * ################################################################################## * def getPVCache(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -96381,7 +100431,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_322getPVCache(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":5322 +/* "PyCafe.pyx":5527 * * ################################################################################## * def getCtrl(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -96425,7 +100475,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_325getCtrl(PyObject *__pyx_v_self, PyO } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCtrl") < 0)) __PYX_ERR(3, 5322, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCtrl") < 0)) __PYX_ERR(3, 5527, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -96441,13 +100491,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_325getCtrl(PyObject *__pyx_v_self, PyO } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getCtrl", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5322, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getCtrl", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5527, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getCtrl", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 5322, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 5527, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_324getCtrl(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_dt); /* function exit code */ @@ -96477,7 +100527,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy struct __pyx_opt_args_6PyCafe_PVCtrlHolderToStruct __pyx_t_7; __Pyx_RefNannySetupContext("getCtrl", 0); - /* "PyCafe.pyx":5325 + /* "PyCafe.pyx":5530 * ################################################################################## * * cdef str _METHOD = "getCtrl(handlePV, str dt='native')" # <<<<<<<<<<<<<< @@ -96487,7 +100537,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __Pyx_INCREF(__pyx_kp_u_getCtrl_handlePV_str_dt_native); __pyx_v__METHOD = __pyx_kp_u_getCtrl_handlePV_str_dt_native; - /* "PyCafe.pyx":5327 + /* "PyCafe.pyx":5532 * cdef str _METHOD = "getCtrl(handlePV, str dt='native')" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -96496,7 +100546,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_handle = 0; - /* "PyCafe.pyx":5329 + /* "PyCafe.pyx":5534 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -96517,17 +100567,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5330 + /* "PyCafe.pyx":5535 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5330, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5535, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":5329 + /* "PyCafe.pyx":5534 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -96537,7 +100587,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy goto __pyx_L3; } - /* "PyCafe.pyx":5331 + /* "PyCafe.pyx":5536 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -96548,21 +100598,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5332 + /* "PyCafe.pyx":5537 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getCtrl. \n\ */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 5332, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5332, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 5537, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5332, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5537, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":5331 + /* "PyCafe.pyx":5536 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -96572,7 +100622,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy goto __pyx_L3; } - /* "PyCafe.pyx":5334 + /* "PyCafe.pyx":5539 * handle = self.checkForHandle(handlePV) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getCtrl. \n\ # <<<<<<<<<<<<<< @@ -96580,15 +100630,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy * */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__88, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5334, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__88, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 5334, __pyx_L1_error) + __PYX_ERR(3, 5539, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5339 + /* "PyCafe.pyx":5544 * cdef PVCtrlHolder pvc * * pvc.setNelem(self.hh.getNelemClientCtrl(handle)) # do this dynamically # <<<<<<<<<<<<<< @@ -96597,7 +100647,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy */ (void)(__pyx_v_pvc.setNelem(__pyx_v_self->hh.getNelemClientCtrl(__pyx_v_handle))); - /* "PyCafe.pyx":5342 + /* "PyCafe.pyx":5547 * * cdef int status * with nogil: # <<<<<<<<<<<<<< @@ -96612,7 +100662,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy #endif /*try:*/ { - /* "PyCafe.pyx":5343 + /* "PyCafe.pyx":5548 * cdef int status * with nogil: * status = self._c_cafe.getCtrl(handle, pvc) # <<<<<<<<<<<<<< @@ -96622,7 +100672,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __pyx_v_status = __pyx_v_self->_c_cafe->getCtrl(__pyx_v_handle, __pyx_v_pvc); } - /* "PyCafe.pyx":5342 + /* "PyCafe.pyx":5547 * * cdef int status * with nogil: # <<<<<<<<<<<<<< @@ -96641,7 +100691,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy } } - /* "PyCafe.pyx":5345 + /* "PyCafe.pyx":5550 * status = self._c_cafe.getCtrl(handle, pvc) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -96651,7 +100701,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5346 + /* "PyCafe.pyx":5551 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -96661,7 +100711,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5347 + /* "PyCafe.pyx":5552 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -96671,7 +100721,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5348 + /* "PyCafe.pyx":5553 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -96680,7 +100730,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5347 + /* "PyCafe.pyx":5552 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -96690,7 +100740,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy goto __pyx_L11; } - /* "PyCafe.pyx":5350 + /* "PyCafe.pyx":5555 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -96702,7 +100752,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy } __pyx_L11:; - /* "PyCafe.pyx":5346 + /* "PyCafe.pyx":5551 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -96711,7 +100761,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":5351 + /* "PyCafe.pyx":5556 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -96721,76 +100771,76 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __pyx_t_1 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5353 + /* "PyCafe.pyx":5558 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5353, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5353, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5353, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5353, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5558, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5558, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 5353, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 5558, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5354 + /* "PyCafe.pyx":5559 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5354, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 5353, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 5558, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5355 + /* "PyCafe.pyx":5560 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5355, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 5353, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 5558, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5355, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 5353, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 5558, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5356 + /* "PyCafe.pyx":5561 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5356, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5561, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 5353, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 5558, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5352 + /* "PyCafe.pyx":5557 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5352, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5357 + /* "PyCafe.pyx":5562 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -96798,9 +100848,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy * pvc_valnone = PVCtrlHolderToStruct(pvc, dt) */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5357, __pyx_L1_error) + __PYX_ERR(3, 5562, __pyx_L1_error) - /* "PyCafe.pyx":5351 + /* "PyCafe.pyx":5556 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -96809,7 +100859,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":5359 + /* "PyCafe.pyx":5564 * raise _cafeException * * pvc_valnone = PVCtrlHolderToStruct(pvc, dt) # <<<<<<<<<<<<<< @@ -96818,12 +100868,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy */ __pyx_t_7.__pyx_n = 1; __pyx_t_7.dt = __pyx_v_dt; - __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVCtrlHolderToStruct(__pyx_v_pvc, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5359, __pyx_L1_error) + __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVCtrlHolderToStruct(__pyx_v_pvc, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5564, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_pvc_valnone = ((struct __pyx_obj_6PyCafe_pvctrl *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5360 + /* "PyCafe.pyx":5565 * * pvc_valnone = PVCtrlHolderToStruct(pvc, dt) * pvc_valnone.value[0] = None # <<<<<<<<<<<<<< @@ -96832,11 +100882,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy */ if (unlikely(__pyx_v_pvc_valnone->value == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 5360, __pyx_L1_error) + __PYX_ERR(3, 5565, __pyx_L1_error) } - if (unlikely(__Pyx_SetItemInt(__pyx_v_pvc_valnone->value, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(3, 5360, __pyx_L1_error) + if (unlikely(__Pyx_SetItemInt(__pyx_v_pvc_valnone->value, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(3, 5565, __pyx_L1_error) - /* "PyCafe.pyx":5361 + /* "PyCafe.pyx":5566 * pvc_valnone = PVCtrlHolderToStruct(pvc, dt) * pvc_valnone.value[0] = None * return pvc_valnone # <<<<<<<<<<<<<< @@ -96848,7 +100898,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __pyx_r = ((PyObject *)__pyx_v_pvc_valnone); goto __pyx_L0; - /* "PyCafe.pyx":5345 + /* "PyCafe.pyx":5550 * status = self._c_cafe.getCtrl(handle, pvc) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -96857,7 +100907,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy */ } - /* "PyCafe.pyx":5362 + /* "PyCafe.pyx":5567 * pvc_valnone.value[0] = None * return pvc_valnone * return PVCtrlHolderToStruct(pvc, dt) # <<<<<<<<<<<<<< @@ -96867,13 +100917,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy __Pyx_XDECREF(__pyx_r); __pyx_t_7.__pyx_n = 1; __pyx_t_7.dt = __pyx_v_dt; - __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVCtrlHolderToStruct(__pyx_v_pvc, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5362, __pyx_L1_error) + __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVCtrlHolderToStruct(__pyx_v_pvc, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5322 + /* "PyCafe.pyx":5527 * * ################################################################################## * def getCtrl(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -96898,7 +100948,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_324getCtrl(struct __pyx_obj_6PyCafe_Cy return __pyx_r; } -/* "PyCafe.pyx":5370 +/* "PyCafe.pyx":5575 * ################################################################################## * * def getCtrlCache(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -96942,7 +100992,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_327getCtrlCache(PyObject *__pyx_v_self } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCtrlCache") < 0)) __PYX_ERR(3, 5370, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getCtrlCache") < 0)) __PYX_ERR(3, 5575, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -96958,13 +101008,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_327getCtrlCache(PyObject *__pyx_v_self } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getCtrlCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5370, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getCtrlCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5575, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getCtrlCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 5370, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 5575, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_dt); /* function exit code */ @@ -96994,7 +101044,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa struct __pyx_opt_args_6PyCafe_PVCtrlHolderToStruct __pyx_t_7; __Pyx_RefNannySetupContext("getCtrlCache", 0); - /* "PyCafe.pyx":5372 + /* "PyCafe.pyx":5577 * def getCtrlCache(self, handlePV, str dt='native'): * ################################################################################## * cdef str _METHOD = "getCtrlCache(handlePV, str dt='native')" # <<<<<<<<<<<<<< @@ -97004,7 +101054,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_kp_u_getCtrlCache_handlePV_str_dt_nat); __pyx_v__METHOD = __pyx_kp_u_getCtrlCache_handlePV_str_dt_nat; - /* "PyCafe.pyx":5373 + /* "PyCafe.pyx":5578 * ################################################################################## * cdef str _METHOD = "getCtrlCache(handlePV, str dt='native')" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -97013,7 +101063,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa */ __pyx_v_handle = 0; - /* "PyCafe.pyx":5375 + /* "PyCafe.pyx":5580 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -97034,17 +101084,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5376 + /* "PyCafe.pyx":5581 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5376, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5581, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":5375 + /* "PyCafe.pyx":5580 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -97054,7 +101104,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa goto __pyx_L3; } - /* "PyCafe.pyx":5377 + /* "PyCafe.pyx":5582 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -97065,21 +101115,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5378 + /* "PyCafe.pyx":5583 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getCtrlCache. \n\ */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 5378, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5378, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 5583, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5378, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5583, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":5377 + /* "PyCafe.pyx":5582 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -97089,7 +101139,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa goto __pyx_L3; } - /* "PyCafe.pyx":5380 + /* "PyCafe.pyx":5585 * handle = self.checkForHandle(handlePV) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getCtrlCache. \n\ # <<<<<<<<<<<<<< @@ -97097,15 +101147,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa * */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__89, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5380, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__89, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 5380, __pyx_L1_error) + __PYX_ERR(3, 5585, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5385 + /* "PyCafe.pyx":5590 * cdef PVCtrlHolder pvc * * pvc.setNelem(self.hh.getNelemToRetrieveFromCtrlCache(handle)) # <<<<<<<<<<<<<< @@ -97114,7 +101164,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa */ (void)(__pyx_v_pvc.setNelem(__pyx_v_self->hh.getNelemToRetrieveFromCtrlCache(__pyx_v_handle))); - /* "PyCafe.pyx":5388 + /* "PyCafe.pyx":5593 * * * status = self._c_cafe.getCtrlCache(handle, pvc) # <<<<<<<<<<<<<< @@ -97123,7 +101173,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa */ __pyx_v_status = __pyx_v_self->_c_cafe->getCtrlCache(__pyx_v_handle, __pyx_v_pvc); - /* "PyCafe.pyx":5390 + /* "PyCafe.pyx":5595 * status = self._c_cafe.getCtrlCache(handle, pvc) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -97133,7 +101183,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5391 + /* "PyCafe.pyx":5596 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -97143,7 +101193,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5392 + /* "PyCafe.pyx":5597 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -97153,7 +101203,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5393 + /* "PyCafe.pyx":5598 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -97162,7 +101212,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5392 + /* "PyCafe.pyx":5597 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -97172,7 +101222,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa goto __pyx_L8; } - /* "PyCafe.pyx":5395 + /* "PyCafe.pyx":5600 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -97184,7 +101234,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa } __pyx_L8:; - /* "PyCafe.pyx":5391 + /* "PyCafe.pyx":5596 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -97193,7 +101243,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":5396 + /* "PyCafe.pyx":5601 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -97203,76 +101253,76 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa __pyx_t_1 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5398 + /* "PyCafe.pyx":5603 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, # <<<<<<<<<<<<<< * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5398, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5603, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5398, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5398, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5398, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5603, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5603, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5603, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 5398, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 5603, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5399 + /* "PyCafe.pyx":5604 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5399, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 5398, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 5603, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5400 + /* "PyCafe.pyx":5605 * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5400, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 5398, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 5603, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5400, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 5398, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 5603, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5401 + /* "PyCafe.pyx":5606 * _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5401, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5606, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 5398, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 5603, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5397 + /* "PyCafe.pyx":5602 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, * _pv_name=self._c_cafe.getPVFromHandle(handle), */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5397, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5402 + /* "PyCafe.pyx":5607 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -97280,9 +101330,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa * pvc_valnone = PVCtrlHolderToStruct(pvc, dt) */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5402, __pyx_L1_error) + __PYX_ERR(3, 5607, __pyx_L1_error) - /* "PyCafe.pyx":5396 + /* "PyCafe.pyx":5601 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -97291,7 +101341,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":5404 + /* "PyCafe.pyx":5609 * raise _cafeException * * pvc_valnone = PVCtrlHolderToStruct(pvc, dt) # <<<<<<<<<<<<<< @@ -97300,12 +101350,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa */ __pyx_t_7.__pyx_n = 1; __pyx_t_7.dt = __pyx_v_dt; - __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVCtrlHolderToStruct(__pyx_v_pvc, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5404, __pyx_L1_error) + __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVCtrlHolderToStruct(__pyx_v_pvc, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_pvc_valnone = ((struct __pyx_obj_6PyCafe_pvctrl *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5405 + /* "PyCafe.pyx":5610 * * pvc_valnone = PVCtrlHolderToStruct(pvc, dt) * pvc_valnone.value[0] = None # <<<<<<<<<<<<<< @@ -97314,11 +101364,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa */ if (unlikely(__pyx_v_pvc_valnone->value == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 5405, __pyx_L1_error) + __PYX_ERR(3, 5610, __pyx_L1_error) } - if (unlikely(__Pyx_SetItemInt(__pyx_v_pvc_valnone->value, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(3, 5405, __pyx_L1_error) + if (unlikely(__Pyx_SetItemInt(__pyx_v_pvc_valnone->value, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(3, 5610, __pyx_L1_error) - /* "PyCafe.pyx":5406 + /* "PyCafe.pyx":5611 * pvc_valnone = PVCtrlHolderToStruct(pvc, dt) * pvc_valnone.value[0] = None * return pvc_valnone # <<<<<<<<<<<<<< @@ -97330,7 +101380,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa __pyx_r = ((PyObject *)__pyx_v_pvc_valnone); goto __pyx_L0; - /* "PyCafe.pyx":5390 + /* "PyCafe.pyx":5595 * status = self._c_cafe.getCtrlCache(handle, pvc) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -97339,7 +101389,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":5408 + /* "PyCafe.pyx":5613 * return pvc_valnone * * return PVCtrlHolderToStruct(pvc, dt) # <<<<<<<<<<<<<< @@ -97349,13 +101399,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa __Pyx_XDECREF(__pyx_r); __pyx_t_7.__pyx_n = 1; __pyx_t_7.dt = __pyx_v_dt; - __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVCtrlHolderToStruct(__pyx_v_pvc, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5408, __pyx_L1_error) + __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVCtrlHolderToStruct(__pyx_v_pvc, &__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5613, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5370 + /* "PyCafe.pyx":5575 * ################################################################################## * * def getCtrlCache(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< @@ -97380,7 +101430,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_326getCtrlCache(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":5416 +/* "PyCafe.pyx":5621 * ################################################################################## * * def groupMonitorStop(self, ghandleName): # <<<<<<<<<<<<<< @@ -97419,7 +101469,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 PyObject *__pyx_t_7 = NULL; __Pyx_RefNannySetupContext("groupMonitorStop", 0); - /* "PyCafe.pyx":5418 + /* "PyCafe.pyx":5623 * def groupMonitorStop(self, ghandleName): * ################################################################################## * cdef str _METHOD = "groupMonitorStop(ghandleName)" # <<<<<<<<<<<<<< @@ -97429,7 +101479,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 __Pyx_INCREF(__pyx_kp_u_groupMonitorStop_ghandleName); __pyx_v__METHOD = __pyx_kp_u_groupMonitorStop_ghandleName; - /* "PyCafe.pyx":5420 + /* "PyCafe.pyx":5625 * cdef str _METHOD = "groupMonitorStop(ghandleName)" * * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -97438,7 +101488,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":5421 + /* "PyCafe.pyx":5626 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -97459,17 +101509,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5422 + /* "PyCafe.pyx":5627 * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5422, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5627, __pyx_L1_error) __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5421 + /* "PyCafe.pyx":5626 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -97479,7 +101529,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 goto __pyx_L3; } - /* "PyCafe.pyx":5423 + /* "PyCafe.pyx":5628 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -97490,21 +101540,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5424 + /* "PyCafe.pyx":5629 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 5424, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5424, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 5629, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5424, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5629, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5423 + /* "PyCafe.pyx":5628 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -97514,7 +101564,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 goto __pyx_L3; } - /* "PyCafe.pyx":5426 + /* "PyCafe.pyx":5631 * ghandle = self.checkForGroupHandle(ghandleName) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< @@ -97523,33 +101573,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 */ /*else*/ { - /* "PyCafe.pyx":5427 + /* "PyCafe.pyx":5632 * else: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _error_info= ("First input argument, should be of type " * "if group handle, else if group name")) */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5427, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5632, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5427, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5427, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_8) < 0) __PYX_ERR(3, 5427, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5632, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5632, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_8) < 0) __PYX_ERR(3, 5632, __pyx_L1_error) - /* "PyCafe.pyx":5426 + /* "PyCafe.pyx":5631 * ghandle = self.checkForGroupHandle(ghandleName) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _error_info= ("First input argument, should be of type " */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5426, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5430 + /* "PyCafe.pyx":5635 * _error_info= ("First input argument, should be of type " * "if group handle, else if group name")) * raise _cafeException # <<<<<<<<<<<<<< @@ -97557,11 +101607,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 * cdef PVGroup pvg */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5430, __pyx_L1_error) + __PYX_ERR(3, 5635, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5434 + /* "PyCafe.pyx":5639 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -97576,7 +101626,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 #endif /*try:*/ { - /* "PyCafe.pyx":5435 + /* "PyCafe.pyx":5640 * * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) # <<<<<<<<<<<<<< @@ -97586,7 +101636,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 (void)(__pyx_v_self->_c_cafe->groupAttach(__pyx_v_ghandle, __pyx_v_pvg)); } - /* "PyCafe.pyx":5434 + /* "PyCafe.pyx":5639 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -97605,7 +101655,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 } } - /* "PyCafe.pyx":5438 + /* "PyCafe.pyx":5643 * * cdef vector[int] vStatus * vStatus.reserve(pvg.getNPV()) # <<<<<<<<<<<<<< @@ -97614,7 +101664,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 */ __pyx_v_vStatus.reserve(__pyx_v_pvg.getNPV()); - /* "PyCafe.pyx":5440 + /* "PyCafe.pyx":5645 * vStatus.reserve(pvg.getNPV()) * * with nogil: # <<<<<<<<<<<<<< @@ -97629,7 +101679,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 #endif /*try:*/ { - /* "PyCafe.pyx":5441 + /* "PyCafe.pyx":5646 * * with nogil: * status = self._c_cafe.groupMonitorStop(ghandle, vStatus) # <<<<<<<<<<<<<< @@ -97639,7 +101689,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 __pyx_v_status = __pyx_v_self->_c_cafe->groupMonitorStop(__pyx_v_ghandle, __pyx_v_vStatus); } - /* "PyCafe.pyx":5440 + /* "PyCafe.pyx":5645 * vStatus.reserve(pvg.getNPV()) * * with nogil: # <<<<<<<<<<<<<< @@ -97658,7 +101708,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 } } - /* "PyCafe.pyx":5443 + /* "PyCafe.pyx":5648 * status = self._c_cafe.groupMonitorStop(ghandle, vStatus) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -97668,7 +101718,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5444 + /* "PyCafe.pyx":5649 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -97678,7 +101728,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5445 + /* "PyCafe.pyx":5650 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -97687,7 +101737,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5444 + /* "PyCafe.pyx":5649 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -97696,7 +101746,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 */ } - /* "PyCafe.pyx":5443 + /* "PyCafe.pyx":5648 * status = self._c_cafe.groupMonitorStop(ghandle, vStatus) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -97705,7 +101755,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 */ } - /* "PyCafe.pyx":5447 + /* "PyCafe.pyx":5652 * self._c_cafe.printStatusMessage(status) * * return status, vStatus # <<<<<<<<<<<<<< @@ -97713,11 +101763,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5447, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5652, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5447, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5652, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5447, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5652, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); @@ -97729,7 +101779,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 __pyx_t_7 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5416 + /* "PyCafe.pyx":5621 * ################################################################################## * * def groupMonitorStop(self, ghandleName): # <<<<<<<<<<<<<< @@ -97754,7 +101804,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_328groupMonitorStop(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":5453 +/* "PyCafe.pyx":5658 * ################################################################################## * * def getMonitorPolicyVector(self, handlePV, _monid): # <<<<<<<<<<<<<< @@ -97793,11 +101843,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_331getMonitorPolicyVector(PyObject *__ case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_monid_2)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("getMonitorPolicyVector", 1, 2, 2, 1); __PYX_ERR(3, 5453, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getMonitorPolicyVector", 1, 2, 2, 1); __PYX_ERR(3, 5658, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getMonitorPolicyVector") < 0)) __PYX_ERR(3, 5453, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getMonitorPolicyVector") < 0)) __PYX_ERR(3, 5658, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -97810,7 +101860,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_331getMonitorPolicyVector(PyObject *__ } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getMonitorPolicyVector", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5453, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getMonitorPolicyVector", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5658, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getMonitorPolicyVector", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -97841,7 +101891,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("getMonitorPolicyVector", 0); - /* "PyCafe.pyx":5455 + /* "PyCafe.pyx":5660 * def getMonitorPolicyVector(self, handlePV, _monid): * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -97850,7 +101900,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_handle = 0; - /* "PyCafe.pyx":5456 + /* "PyCafe.pyx":5661 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -97871,17 +101921,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5457 + /* "PyCafe.pyx":5662 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV, force=True) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5457, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5662, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":5456 + /* "PyCafe.pyx":5661 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -97891,7 +101941,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx goto __pyx_L3; } - /* "PyCafe.pyx":5458 + /* "PyCafe.pyx":5663 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -97902,23 +101952,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5459 + /* "PyCafe.pyx":5664 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV, force=True) # <<<<<<<<<<<<<< * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getMonitorPolicyVector \n\ */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 5459, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 5664, __pyx_L1_error) __pyx_t_6.__pyx_n = 1; __pyx_t_6.force = 1; - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, &__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5459, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, &__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5664, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5459, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5664, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":5458 + /* "PyCafe.pyx":5663 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -97928,7 +101978,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx goto __pyx_L3; } - /* "PyCafe.pyx":5461 + /* "PyCafe.pyx":5666 * handle = self.checkForHandle(handlePV, force=True) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getMonitorPolicyVector \n\ # <<<<<<<<<<<<<< @@ -97936,15 +101986,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx * */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__90, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5461, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__90, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5666, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 5461, __pyx_L1_error) + __PYX_ERR(3, 5666, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5466 + /* "PyCafe.pyx":5671 * cdef vector[MonitorPolicy] mpV * * self.hh.getMonitorPolicyVector(handle, mpV) # <<<<<<<<<<<<<< @@ -97953,19 +102003,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ (void)(__pyx_v_self->hh.getMonitorPolicyVector(__pyx_v_handle, __pyx_v_mpV)); - /* "PyCafe.pyx":5470 + /* "PyCafe.pyx":5675 * cdef monitorpolicy mp * * mp = monitorpolicy() # <<<<<<<<<<<<<< * * cdef unsigned int i */ - __pyx_t_5 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_monitorpolicy)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5470, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_monitorpolicy)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_mp = ((struct __pyx_obj_6PyCafe_monitorpolicy *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5474 + /* "PyCafe.pyx":5679 * cdef unsigned int i * * for i in range(0, mpV.size()): # <<<<<<<<<<<<<< @@ -97977,22 +102027,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_8; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "PyCafe.pyx":5476 + /* "PyCafe.pyx":5681 * for i in range(0, mpV.size()): * * if mpV[i].getMonitorID() == _monid: # <<<<<<<<<<<<<< * * mp.monid = mpV[i].getMonitorID() */ - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int((__pyx_v_mpV[__pyx_v_i]).getMonitorID()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5476, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int((__pyx_v_mpV[__pyx_v_i]).getMonitorID()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = PyObject_RichCompare(__pyx_t_5, __pyx_v__monid, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5476, __pyx_L1_error) + __pyx_t_9 = PyObject_RichCompare(__pyx_t_5, __pyx_v__monid, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5681, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5476, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5681, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__pyx_t_1) { - /* "PyCafe.pyx":5478 + /* "PyCafe.pyx":5683 * if mpV[i].getMonitorID() == _monid: * * mp.monid = mpV[i].getMonitorID() # <<<<<<<<<<<<<< @@ -98001,7 +102051,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->monid = (__pyx_v_mpV[__pyx_v_i]).getMonitorID(); - /* "PyCafe.pyx":5480 + /* "PyCafe.pyx":5685 * mp.monid = mpV[i].getMonitorID() * * mp.nelem = mpV[i].getNelem() # <<<<<<<<<<<<<< @@ -98010,7 +102060,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->nelem = (__pyx_v_mpV[__pyx_v_i]).getNelem(); - /* "PyCafe.pyx":5482 + /* "PyCafe.pyx":5687 * mp.nelem = mpV[i].getNelem() * * mp.dataType = mpV[i].getDataType() # <<<<<<<<<<<<<< @@ -98019,7 +102069,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->dataType = (__pyx_v_mpV[__pyx_v_i]).getDataType(); - /* "PyCafe.pyx":5483 + /* "PyCafe.pyx":5688 * * mp.dataType = mpV[i].getDataType() * mp.userArgs = mpV[i].getUserArgs() # <<<<<<<<<<<<<< @@ -98028,7 +102078,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->userArgs = ((long)(__pyx_v_mpV[__pyx_v_i]).getUserArgs()); - /* "PyCafe.pyx":5484 + /* "PyCafe.pyx":5689 * mp.dataType = mpV[i].getDataType() * mp.userArgs = mpV[i].getUserArgs() * mp.dbrDataType = mpV[i].getDbrDataType() # <<<<<<<<<<<<<< @@ -98037,7 +102087,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->dbrDataType = (__pyx_v_mpV[__pyx_v_i]).getDbrDataType(); - /* "PyCafe.pyx":5485 + /* "PyCafe.pyx":5690 * mp.userArgs = mpV[i].getUserArgs() * mp.dbrDataType = mpV[i].getDbrDataType() * mp.cafeDbrType = mpV[i].getCafeDbrType() # <<<<<<<<<<<<<< @@ -98046,7 +102096,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->cafeDbrType = (__pyx_v_mpV[__pyx_v_i]).getCafeDbrType(); - /* "PyCafe.pyx":5486 + /* "PyCafe.pyx":5691 * mp.dbrDataType = mpV[i].getDbrDataType() * mp.cafeDbrType = mpV[i].getCafeDbrType() * mp.mask = mpV[i].getMask() # <<<<<<<<<<<<<< @@ -98055,7 +102105,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->mask = (__pyx_v_mpV[__pyx_v_i]).getMask(); - /* "PyCafe.pyx":5487 + /* "PyCafe.pyx":5692 * mp.cafeDbrType = mpV[i].getCafeDbrType() * mp.mask = mpV[i].getMask() * mp.maskHasDBE_PROPERTY = mpV[i].maskHasDBE_PROPERTY() # <<<<<<<<<<<<<< @@ -98064,7 +102114,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->maskHasDBE_PROPERTY = (__pyx_v_mpV[__pyx_v_i]).maskHasDBE_PROPERTY(); - /* "PyCafe.pyx":5488 + /* "PyCafe.pyx":5693 * mp.mask = mpV[i].getMask() * mp.maskHasDBE_PROPERTY = mpV[i].maskHasDBE_PROPERTY() * mp.maskHasDBE_VALUE = mpV[i].maskHasDBE_VALUE() # <<<<<<<<<<<<<< @@ -98073,7 +102123,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->maskHasDBE_VALUE = (__pyx_v_mpV[__pyx_v_i]).maskHasDBE_VALUE(); - /* "PyCafe.pyx":5489 + /* "PyCafe.pyx":5694 * mp.maskHasDBE_PROPERTY = mpV[i].maskHasDBE_PROPERTY() * mp.maskHasDBE_VALUE = mpV[i].maskHasDBE_VALUE() * mp.maskHasDBE_LOG = mpV[i].maskHasDBE_LOG() # <<<<<<<<<<<<<< @@ -98082,7 +102132,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->maskHasDBE_LOG = (__pyx_v_mpV[__pyx_v_i]).maskHasDBE_LOG(); - /* "PyCafe.pyx":5490 + /* "PyCafe.pyx":5695 * mp.maskHasDBE_VALUE = mpV[i].maskHasDBE_VALUE() * mp.maskHasDBE_LOG = mpV[i].maskHasDBE_LOG() * mp.maskHasDBE_ALARM = mpV[i].maskHasDBE_ALARM() # <<<<<<<<<<<<<< @@ -98091,7 +102141,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ __pyx_v_mp->maskHasDBE_ALARM = (__pyx_v_mpV[__pyx_v_i]).maskHasDBE_ALARM(); - /* "PyCafe.pyx":5491 + /* "PyCafe.pyx":5696 * mp.maskHasDBE_LOG = mpV[i].maskHasDBE_LOG() * mp.maskHasDBE_ALARM = mpV[i].maskHasDBE_ALARM() * break # <<<<<<<<<<<<<< @@ -98100,7 +102150,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx */ goto __pyx_L7_break; - /* "PyCafe.pyx":5476 + /* "PyCafe.pyx":5681 * for i in range(0, mpV.size()): * * if mpV[i].getMonitorID() == _monid: # <<<<<<<<<<<<<< @@ -98111,7 +102161,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx } __pyx_L7_break:; - /* "PyCafe.pyx":5493 + /* "PyCafe.pyx":5698 * break * * return mp # <<<<<<<<<<<<<< @@ -98123,7 +102173,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx __pyx_r = ((PyObject *)__pyx_v_mp); goto __pyx_L0; - /* "PyCafe.pyx":5453 + /* "PyCafe.pyx":5658 * ################################################################################## * * def getMonitorPolicyVector(self, handlePV, _monid): # <<<<<<<<<<<<<< @@ -98146,7 +102196,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_330getMonitorPolicyVector(struct __pyx return __pyx_r; } -/* "PyCafe.pyx":5495 +/* "PyCafe.pyx":5700 * return mp * * def groupMonitor(self, ghandleName, object cb=None, DBR_TYPE dbr=DBR_TIME, # <<<<<<<<<<<<<< @@ -98217,7 +102267,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_333groupMonitor(PyObject *__pyx_v_self } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupMonitor") < 0)) __PYX_ERR(3, 5495, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupMonitor") < 0)) __PYX_ERR(3, 5700, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -98237,24 +102287,24 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_333groupMonitor(PyObject *__pyx_v_self __pyx_v_ghandleName = values[0]; __pyx_v_cb = values[1]; if (values[2]) { - __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5495, __pyx_L3_error) + __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5700, __pyx_L3_error) } else { __pyx_v_dbr = __pyx_k__91; } if (values[3]) { - __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5496, __pyx_L3_error) + __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5701, __pyx_L3_error) } else { __pyx_v_mask = __pyx_k__92; } if (values[4]) { - __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 5497, __pyx_L3_error) + __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 5702, __pyx_L3_error) } else { __pyx_v_notify_milliseconds = ((unsigned short)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("groupMonitor", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5495, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("groupMonitor", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5700, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.groupMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -98280,7 +102330,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_332groupMonitor(struct __pyx_obj_6PyCa PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("groupMonitor", 0); - /* "PyCafe.pyx":5498 + /* "PyCafe.pyx":5703 * unsigned int mask=DBE_VALUE | DBE_LOG | DBE_ALARM, * unsigned short notify_milliseconds=0): * return self.groupMonitorStart(ghandleName, cb, dbr, mask, notify_milliseconds) # <<<<<<<<<<<<<< @@ -98288,13 +102338,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_332groupMonitor(struct __pyx_obj_6PyCa * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_groupMonitorStart); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5498, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_groupMonitorStart); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_From_DBR_TYPE(__pyx_v_dbr); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 5498, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_DBR_TYPE(__pyx_v_dbr); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 5703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 5498, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 5703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyInt_From_unsigned_short(__pyx_v_notify_milliseconds); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5498, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_short(__pyx_v_notify_milliseconds); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; @@ -98311,7 +102361,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_332groupMonitor(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[6] = {__pyx_t_6, __pyx_v_ghandleName, __pyx_v_cb, __pyx_t_3, __pyx_t_4, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 5+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5498, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 5+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5703, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -98322,7 +102372,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_332groupMonitor(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[6] = {__pyx_t_6, __pyx_v_ghandleName, __pyx_v_cb, __pyx_t_3, __pyx_t_4, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 5+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5498, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 5+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5703, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -98331,7 +102381,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_332groupMonitor(struct __pyx_obj_6PyCa } else #endif { - __pyx_t_8 = PyTuple_New(5+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5498, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(5+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; @@ -98351,7 +102401,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_332groupMonitor(struct __pyx_obj_6PyCa __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5498, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } @@ -98360,7 +102410,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_332groupMonitor(struct __pyx_obj_6PyCa __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5495 + /* "PyCafe.pyx":5700 * return mp * * def groupMonitor(self, ghandleName, object cb=None, DBR_TYPE dbr=DBR_TIME, # <<<<<<<<<<<<<< @@ -98387,7 +102437,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_332groupMonitor(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":5501 +/* "PyCafe.pyx":5706 * * ################################################################################## * def groupMonitorStart(self, ghandleName, object cb=None, # <<<<<<<<<<<<<< @@ -98458,7 +102508,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_335groupMonitorStart(PyObject *__pyx_v } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupMonitorStart") < 0)) __PYX_ERR(3, 5501, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupMonitorStart") < 0)) __PYX_ERR(3, 5706, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -98478,24 +102528,24 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_335groupMonitorStart(PyObject *__pyx_v __pyx_v_ghandleName = values[0]; __pyx_v_cb = values[1]; if (values[2]) { - __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5502, __pyx_L3_error) + __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5707, __pyx_L3_error) } else { __pyx_v_dbr = __pyx_k__93; } if (values[3]) { - __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5503, __pyx_L3_error) + __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5708, __pyx_L3_error) } else { __pyx_v_mask = __pyx_k__94; } if (values[4]) { - __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 5504, __pyx_L3_error) + __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 5709, __pyx_L3_error) } else { __pyx_v_notify_milliseconds = ((unsigned short)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("groupMonitorStart", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5501, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("groupMonitorStart", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5706, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.groupMonitorStart", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -98519,7 +102569,6 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ CYTHON_UNUSED PyObject *__pyx_v_handleList = NULL; long __pyx_v_i; PyObject *__pyx_v_sig = NULL; - PyObject *__pyx_v_param = NULL; std::vector __pyx_v_vStatus; int __pyx_v_status; PyObject *__pyx_r = NULL; @@ -98535,12 +102584,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ unsigned int __pyx_t_9; long __pyx_t_10; Py_ssize_t __pyx_t_11; - Py_ssize_t __pyx_t_12; - int __pyx_t_13; - int __pyx_t_14; __Pyx_RefNannySetupContext("groupMonitorStart", 0); - /* "PyCafe.pyx":5506 + /* "PyCafe.pyx":5711 * unsigned short notify_milliseconds=0): * ################################################################################## * cdef str _METHOD = "groupMonitorStart(ghandleName, cb, dbr, mask)" # <<<<<<<<<<<<<< @@ -98550,7 +102596,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __Pyx_INCREF(__pyx_kp_u_groupMonitorStart_ghandleName_cb); __pyx_v__METHOD = __pyx_kp_u_groupMonitorStart_ghandleName_cb; - /* "PyCafe.pyx":5508 + /* "PyCafe.pyx":5713 * cdef str _METHOD = "groupMonitorStart(ghandleName, cb, dbr, mask)" * * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -98559,7 +102605,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":5509 + /* "PyCafe.pyx":5714 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -98580,17 +102626,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5510 + /* "PyCafe.pyx":5715 * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5510, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5715, __pyx_L1_error) __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5509 + /* "PyCafe.pyx":5714 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -98600,7 +102646,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ goto __pyx_L3; } - /* "PyCafe.pyx":5511 + /* "PyCafe.pyx":5716 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -98611,21 +102657,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5512 + /* "PyCafe.pyx":5717 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 5512, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5512, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 5717, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5717, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5512, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5717, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5511 + /* "PyCafe.pyx":5716 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -98635,7 +102681,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ goto __pyx_L3; } - /* "PyCafe.pyx":5514 + /* "PyCafe.pyx":5719 * ghandle = self.checkForGroupHandle(ghandleName) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -98643,18 +102689,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ * raise _cafeException */ /*else*/ { - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5514, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5514, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5514, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 5514, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5514, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5719, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5719, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 5719, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5516 + /* "PyCafe.pyx":5721 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if group handle, else if group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -98662,11 +102708,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ * if dbr: */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5516, __pyx_L1_error) + __PYX_ERR(3, 5721, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5518 + /* "PyCafe.pyx":5723 * raise _cafeException * * if dbr: # <<<<<<<<<<<<<< @@ -98675,7 +102721,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ if (__pyx_v_dbr) { - /* "PyCafe.pyx":5519 + /* "PyCafe.pyx":5724 * * if dbr: * if dbr not in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: # <<<<<<<<<<<<<< @@ -98697,14 +102743,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5520 + /* "PyCafe.pyx":5725 * 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( */ - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5520, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5725, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_kp_u_Warning_from_groupMonitorStart); __Pyx_GIVEREF(__pyx_kp_u_Warning_from_groupMonitorStart); @@ -98712,34 +102758,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __Pyx_INCREF(__pyx_v_ghandleName); __Pyx_GIVEREF(__pyx_v_ghandleName); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_ghandleName); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5520, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5725, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5522 + /* "PyCafe.pyx":5727 * 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") */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__95, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5522, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__95, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5524 + /* "PyCafe.pyx":5729 * 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 * */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5524, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5525 + /* "PyCafe.pyx":5730 * "dbr base type should be one of DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL") * print("Assuming DBR_TIME") * dbr = DBR_TIME # <<<<<<<<<<<<<< @@ -98748,7 +102794,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ __pyx_v_dbr = DBR_TIME; - /* "PyCafe.pyx":5519 + /* "PyCafe.pyx":5724 * * if dbr: * if dbr not in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: # <<<<<<<<<<<<<< @@ -98757,7 +102803,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ } - /* "PyCafe.pyx":5518 + /* "PyCafe.pyx":5723 * raise _cafeException * * if dbr: # <<<<<<<<<<<<<< @@ -98766,7 +102812,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ } - /* "PyCafe.pyx":5532 + /* "PyCafe.pyx":5737 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -98781,7 +102827,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ #endif /*try:*/ { - /* "PyCafe.pyx":5533 + /* "PyCafe.pyx":5738 * * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) # <<<<<<<<<<<<<< @@ -98791,7 +102837,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ (void)(__pyx_v_self->_c_cafe->groupAttach(__pyx_v_ghandle, __pyx_v_pvg)); } - /* "PyCafe.pyx":5532 + /* "PyCafe.pyx":5737 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -98810,7 +102856,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ } } - /* "PyCafe.pyx":5536 + /* "PyCafe.pyx":5741 * * cdef MonitorPolicy * mp * mp = self._c_cafe.createMonitorPolicyArray(pvg.getNPV()) # <<<<<<<<<<<<<< @@ -98819,28 +102865,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ __pyx_v_mp = __pyx_v_self->_c_cafe->createMonitorPolicyArray(__pyx_v_pvg.getNPV()); - /* "PyCafe.pyx":5538 + /* "PyCafe.pyx":5743 * mp = self._c_cafe.createMonitorPolicyArray(pvg.getNPV()) * * handleList = [] # <<<<<<<<<<<<<< * handleList = self.getHandlesFromWithinGroup(ghandle) * */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5538, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_handleList = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":5539 + /* "PyCafe.pyx":5744 * * handleList = [] * handleList = self.getHandlesFromWithinGroup(ghandle) # <<<<<<<<<<<<<< * - * for i in range(0, pvg.getNPV()): + * #cb_list = [cb] * pvg.getNPV() */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5539, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5539, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -98855,14 +102901,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5539, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5541 - * handleList = self.getHandlesFromWithinGroup(ghandle) + /* "PyCafe.pyx":5748 + * #cb_list = [cb] * pvg.getNPV() * * for i in range(0, pvg.getNPV()): # <<<<<<<<<<<<<< * @@ -98873,7 +102919,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { __pyx_v_i = __pyx_t_10; - /* "PyCafe.pyx":5543 + /* "PyCafe.pyx":5750 * for i in range(0, pvg.getNPV()): * * mp[i].setMask(mask) # <<<<<<<<<<<<<< @@ -98882,7 +102928,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ (__pyx_v_mp[__pyx_v_i]).setMask(__pyx_v_mask); - /* "PyCafe.pyx":5544 + /* "PyCafe.pyx":5751 * * mp[i].setMask(mask) * mp[i].setCafeDbrType(dbr) # <<<<<<<<<<<<<< @@ -98891,7 +102937,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ (__pyx_v_mp[__pyx_v_i]).setCafeDbrType(__pyx_v_dbr); - /* "PyCafe.pyx":5545 + /* "PyCafe.pyx":5752 * mp[i].setMask(mask) * mp[i].setCafeDbrType(dbr) * mp[i].setNotifyDeltaMilliSeconds(notify_milliseconds) # <<<<<<<<<<<<<< @@ -98900,7 +102946,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ (__pyx_v_mp[__pyx_v_i]).setNotifyDeltaMilliSeconds(__pyx_v_notify_milliseconds); - /* "PyCafe.pyx":5546 + /* "PyCafe.pyx":5753 * mp[i].setCafeDbrType(dbr) * mp[i].setNotifyDeltaMilliSeconds(notify_milliseconds) * mpid = mp[i].getMonitorID() # <<<<<<<<<<<<<< @@ -98909,26 +102955,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ __pyx_v_mpid = (__pyx_v_mp[__pyx_v_i]).getMonitorID(); - /* "PyCafe.pyx":5548 + /* "PyCafe.pyx":5755 * mpid = mp[i].getMonitorID() * * if cb: # <<<<<<<<<<<<<< * sig = inspect.signature(cb) * # a=inspect.getargspec(cb) */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_cb); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5548, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_cb); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5755, __pyx_L1_error) if (__pyx_t_2) { - /* "PyCafe.pyx":5549 + /* "PyCafe.pyx":5756 * * if cb: * sig = inspect.signature(cb) # <<<<<<<<<<<<<< * # a=inspect.getargspec(cb) * */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_inspect); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5549, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_inspect); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_signature); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5549, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_signature); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -98943,222 +102989,44 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ } __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_v_cb) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_cb); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5549, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5552 + /* "PyCafe.pyx":5759 * # a=inspect.getargspec(cb) * - * mp.setUserArgs(< void * > mpid) # <<<<<<<<<<<<<< - * mp.setNoCyCallbackParameters(len(sig.parameters)) - * mp.setPyCyHandler( cb) + * mp[i].setUserArgs(< void * > mpid) # <<<<<<<<<<<<<< + * mp[i].setNoCyCallbackParameters(len(sig.parameters)) + * mp[i].setPyCyHandler( cb) #cb_list[i]) */ - __pyx_v_mp->setUserArgs(((void *)__pyx_v_mpid)); + (__pyx_v_mp[__pyx_v_i]).setUserArgs(((void *)__pyx_v_mpid)); - /* "PyCafe.pyx":5553 + /* "PyCafe.pyx":5760 * - * mp.setUserArgs(< void * > mpid) - * mp.setNoCyCallbackParameters(len(sig.parameters)) # <<<<<<<<<<<<<< - * mp.setPyCyHandler( cb) + * mp[i].setUserArgs(< void * > mpid) + * mp[i].setNoCyCallbackParameters(len(sig.parameters)) # <<<<<<<<<<<<<< + * mp[i].setPyCyHandler( cb) #cb_list[i]) * */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5553, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5760, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_11 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5553, __pyx_L1_error) + __pyx_t_11 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5760, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_mp->setNoCyCallbackParameters(__pyx_t_11); + (__pyx_v_mp[__pyx_v_i]).setNoCyCallbackParameters(__pyx_t_11); - /* "PyCafe.pyx":5554 - * mp.setUserArgs(< void * > mpid) - * mp.setNoCyCallbackParameters(len(sig.parameters)) - * mp.setPyCyHandler( cb) # <<<<<<<<<<<<<< + /* "PyCafe.pyx":5761 + * mp[i].setUserArgs(< void * > mpid) + * mp[i].setNoCyCallbackParameters(len(sig.parameters)) + * mp[i].setPyCyHandler( cb) #cb_list[i]) # <<<<<<<<<<<<<< * - * print('============//1//') + * #print('============//1//') */ - __pyx_v_mp->setPyCyHandler(((void *)__pyx_v_cb)); + (__pyx_v_mp[__pyx_v_i]).setPyCyHandler(((void *)__pyx_v_cb)); - /* "PyCafe.pyx":5556 - * mp.setPyCyHandler( cb) - * - * print('============//1//') # <<<<<<<<<<<<<< - * print('SIGNATURE:') - * print(str(sig)) - */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__97, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5556, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "PyCafe.pyx":5557 - * - * print('============//1//') - * print('SIGNATURE:') # <<<<<<<<<<<<<< - * print(str(sig)) - * for param in sig.parameters.values(): - */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__98, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5557, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "PyCafe.pyx":5558 - * print('============//1//') - * print('SIGNATURE:') - * print(str(sig)) # <<<<<<<<<<<<<< - * for param in sig.parameters.values(): - * print('Parameter:', param) - */ - __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_v_sig); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5558, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5558, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "PyCafe.pyx":5559 - * print('SIGNATURE:') - * print(str(sig)) - * for param in sig.parameters.values(): # <<<<<<<<<<<<<< - * print('Parameter:', param) - * print('len1', len(sig.parameters.values())) - */ - __pyx_t_11 = 0; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5559, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__pyx_t_5 == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(3, 5559, __pyx_L1_error) - } - __pyx_t_6 = __Pyx_dict_iterator(__pyx_t_5, 0, __pyx_n_s_values, (&__pyx_t_12), (&__pyx_t_13)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5559, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_7); - __pyx_t_7 = __pyx_t_6; - __pyx_t_6 = 0; - while (1) { - __pyx_t_14 = __Pyx_dict_iter_next(__pyx_t_7, __pyx_t_12, &__pyx_t_11, NULL, &__pyx_t_6, NULL, __pyx_t_13); - if (unlikely(__pyx_t_14 == 0)) break; - if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(3, 5559, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_6); - __pyx_t_6 = 0; - - /* "PyCafe.pyx":5560 - * print(str(sig)) - * for param in sig.parameters.values(): - * print('Parameter:', param) # <<<<<<<<<<<<<< - * print('len1', len(sig.parameters.values())) - * print('len2', len(sig.parameters)) - */ - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__pyx_kp_u_Parameter); - __Pyx_GIVEREF(__pyx_kp_u_Parameter); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_Parameter); - __Pyx_INCREF(__pyx_v_param); - __Pyx_GIVEREF(__pyx_v_param); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_param); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "PyCafe.pyx":5561 - * for param in sig.parameters.values(): - * print('Parameter:', param) - * print('len1', len(sig.parameters.values())) # <<<<<<<<<<<<<< - * print('len2', len(sig.parameters)) - * print('monitor id', mpid) - */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5561, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_values); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5561, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - } - } - __pyx_t_7 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5561, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_12 = PyObject_Length(__pyx_t_7); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5561, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5561, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5561, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__pyx_n_u_len1); - __Pyx_GIVEREF(__pyx_n_u_len1); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_n_u_len1); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5561, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "PyCafe.pyx":5562 - * print('Parameter:', param) - * print('len1', len(sig.parameters.values())) - * print('len2', len(sig.parameters)) # <<<<<<<<<<<<<< - * print('monitor id', mpid) - * - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5562, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_12 = PyObject_Length(__pyx_t_7); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5562, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5562, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5562, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__pyx_n_u_len2); - __Pyx_GIVEREF(__pyx_n_u_len2); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_n_u_len2); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5562, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "PyCafe.pyx":5563 - * print('len1', len(sig.parameters.values())) - * print('len2', len(sig.parameters)) - * print('monitor id', mpid) # <<<<<<<<<<<<<< - * - * mpV.push_back(mp[i]) - */ - __pyx_t_7 = __Pyx_PyInt_From_unsigned_long(__pyx_v_mpid); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5563, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5563, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__pyx_kp_u_monitor_id); - __Pyx_GIVEREF(__pyx_kp_u_monitor_id); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_monitor_id); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5563, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "PyCafe.pyx":5548 + /* "PyCafe.pyx":5755 * mpid = mp[i].getMonitorID() * * if cb: # <<<<<<<<<<<<<< @@ -99167,8 +103035,8 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ } - /* "PyCafe.pyx":5565 - * print('monitor id', mpid) + /* "PyCafe.pyx":5772 + * #print('monitor id', mpid) * * mpV.push_back(mp[i]) # <<<<<<<<<<<<<< * @@ -99178,11 +103046,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __pyx_v_mpV.push_back((__pyx_v_mp[__pyx_v_i])); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 5565, __pyx_L1_error) + __PYX_ERR(3, 5772, __pyx_L1_error) } } - /* "PyCafe.pyx":5568 + /* "PyCafe.pyx":5775 * * cdef vector[int] vStatus * vStatus.reserve(pvg.getNPV()) # <<<<<<<<<<<<<< @@ -99191,7 +103059,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ __pyx_v_vStatus.reserve(__pyx_v_pvg.getNPV()); - /* "PyCafe.pyx":5570 + /* "PyCafe.pyx":5777 * vStatus.reserve(pvg.getNPV()) * * with nogil: # <<<<<<<<<<<<<< @@ -99206,7 +103074,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ #endif /*try:*/ { - /* "PyCafe.pyx":5571 + /* "PyCafe.pyx":5778 * * with nogil: * status = self._c_cafe.groupMonitorStart(ghandle, vStatus, mpV) # <<<<<<<<<<<<<< @@ -99216,7 +103084,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __pyx_v_status = __pyx_v_self->_c_cafe->groupMonitorStart(__pyx_v_ghandle, __pyx_v_vStatus, __pyx_v_mpV); } - /* "PyCafe.pyx":5570 + /* "PyCafe.pyx":5777 * vStatus.reserve(pvg.getNPV()) * * with nogil: # <<<<<<<<<<<<<< @@ -99229,13 +103097,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif - goto __pyx_L18; + goto __pyx_L16; } - __pyx_L18:; + __pyx_L16:; } } - /* "PyCafe.pyx":5573 + /* "PyCafe.pyx":5780 * status = self._c_cafe.groupMonitorStart(ghandle, vStatus, mpV) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -99245,7 +103113,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5574 + /* "PyCafe.pyx":5781 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -99255,7 +103123,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5575 + /* "PyCafe.pyx":5782 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -99264,7 +103132,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5574 + /* "PyCafe.pyx":5781 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -99273,7 +103141,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ } - /* "PyCafe.pyx":5573 + /* "PyCafe.pyx":5780 * status = self._c_cafe.groupMonitorStart(ghandle, vStatus, mpV) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -99282,7 +103150,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ */ } - /* "PyCafe.pyx":5577 + /* "PyCafe.pyx":5784 * self._c_cafe.printStatusMessage(status) * * return status, vStatus # <<<<<<<<<<<<<< @@ -99290,23 +103158,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5577, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 5784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6); - __pyx_t_7 = 0; - __pyx_t_6 = 0; - __pyx_r = __pyx_t_5; + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); __pyx_t_5 = 0; + __pyx_t_7 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5501 + /* "PyCafe.pyx":5706 * * ################################################################################## * def groupMonitorStart(self, ghandleName, object cb=None, # <<<<<<<<<<<<<< @@ -99329,13 +103197,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_334groupMonitorStart(struct __pyx_obj_ __Pyx_XDECREF((PyObject *)__pyx_v__cafeException); __Pyx_XDECREF(__pyx_v_handleList); __Pyx_XDECREF(__pyx_v_sig); - __Pyx_XDECREF(__pyx_v_param); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "PyCafe.pyx":5583 +/* "PyCafe.pyx":5790 * ############################################################################ * * def groupMonitorStartWithCBList(self, # <<<<<<<<<<<<<< @@ -99358,7 +103225,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_337groupMonitorStartWithCBList(PyObjec static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ghandleName,&__pyx_n_s_cb,&__pyx_n_s_dbr,&__pyx_n_s_mask_2,&__pyx_n_s_notify_milliseconds,0}; PyObject* values[5] = {0,0,0,0,0}; - /* "PyCafe.pyx":5584 + /* "PyCafe.pyx":5791 * * def groupMonitorStartWithCBList(self, * ghandleName, list cb=None, # <<<<<<<<<<<<<< @@ -99414,7 +103281,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_337groupMonitorStartWithCBList(PyObjec } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupMonitorStartWithCBList") < 0)) __PYX_ERR(3, 5583, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupMonitorStartWithCBList") < 0)) __PYX_ERR(3, 5790, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -99434,33 +103301,33 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_337groupMonitorStartWithCBList(PyObjec __pyx_v_ghandleName = values[0]; __pyx_v_cb = ((PyObject*)values[1]); if (values[2]) { - __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5585, __pyx_L3_error) + __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 5792, __pyx_L3_error) } else { - __pyx_v_dbr = __pyx_k__99; + __pyx_v_dbr = __pyx_k__97; } if (values[3]) { - __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5586, __pyx_L3_error) + __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5793, __pyx_L3_error) } else { - __pyx_v_mask = __pyx_k__100; + __pyx_v_mask = __pyx_k__98; } if (values[4]) { - __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 5588, __pyx_L3_error) + __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 5795, __pyx_L3_error) } else { __pyx_v_notify_milliseconds = ((unsigned short)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("groupMonitorStartWithCBList", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5583, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("groupMonitorStartWithCBList", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5790, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.groupMonitorStartWithCBList", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cb), (&PyList_Type), 1, "cb", 1))) __PYX_ERR(3, 5584, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cb), (&PyList_Type), 1, "cb", 1))) __PYX_ERR(3, 5791, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_ghandleName, __pyx_v_cb, __pyx_v_dbr, __pyx_v_mask, __pyx_v_notify_milliseconds); - /* "PyCafe.pyx":5583 + /* "PyCafe.pyx":5790 * ############################################################################ * * def groupMonitorStartWithCBList(self, # <<<<<<<<<<<<<< @@ -99488,44 +103355,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct CYTHON_UNUSED PyObject *__pyx_v_handleList = NULL; long __pyx_v_i; PyObject *__pyx_v_sig = NULL; - PyObject *__pyx_v_param = NULL; std::vector __pyx_v_vStatus; int __pyx_v_status; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; + int __pyx_t_1; + int __pyx_t_2; int __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - unsigned int __pyx_t_6; + unsigned int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; unsigned int __pyx_t_10; long __pyx_t_11; - Py_ssize_t __pyx_t_12; - int __pyx_t_13; - int __pyx_t_14; __Pyx_RefNannySetupContext("groupMonitorStartWithCBList", 0); - /* "PyCafe.pyx":5590 + /* "PyCafe.pyx":5797 * unsigned short notify_milliseconds=0): * ############################################################################ - * cdef str _METHOD = ("groupMonitorStartWithCBList(ghandleName, cb," + + # <<<<<<<<<<<<<< + * cdef str _METHOD = ("groupMonitorStartWithCBList(ghandleName, cb," + # <<<<<<<<<<<<<< * "dbr, mask, notify_milliseconds)") * */ - __pyx_t_1 = PyNumber_Positive(__pyx_kp_u_dbr_mask_notify_milliseconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5590, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyNumber_Add(__pyx_kp_u_groupMonitorStartWithCBList_ghan, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5590, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (!(likely(PyUnicode_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(3, 5590, __pyx_L1_error) - __pyx_v__METHOD = ((PyObject*)__pyx_t_2); - __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_groupMonitorStartWithCBList_ghan); + __pyx_v__METHOD = __pyx_kp_u_groupMonitorStartWithCBList_ghan; - /* "PyCafe.pyx":5593 + /* "PyCafe.pyx":5800 * "dbr, mask, notify_milliseconds)") * * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -99534,38 +103391,38 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":5594 + /* "PyCafe.pyx":5801 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< * ghandle = ghandleName * elif isinstance(ghandleName, (str)): */ - __pyx_t_4 = PyInt_Check(__pyx_v_ghandleName); - __pyx_t_5 = (__pyx_t_4 != 0); - if (!__pyx_t_5) { + __pyx_t_2 = PyInt_Check(__pyx_v_ghandleName); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { } else { - __pyx_t_3 = __pyx_t_5; + __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } - __pyx_t_5 = PyLong_Check(__pyx_v_ghandleName); - __pyx_t_4 = (__pyx_t_5 != 0); - __pyx_t_3 = __pyx_t_4; + __pyx_t_3 = PyLong_Check(__pyx_v_ghandleName); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { - /* "PyCafe.pyx":5595 + /* "PyCafe.pyx":5802 * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) */ - __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5595, __pyx_L1_error) - __pyx_v_ghandle = __pyx_t_6; + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5802, __pyx_L1_error) + __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5594 + /* "PyCafe.pyx":5801 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -99575,32 +103432,32 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct goto __pyx_L3; } - /* "PyCafe.pyx":5596 + /* "PyCafe.pyx":5803 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< * ghandle = self.checkForGroupHandle(ghandleName) * else: */ - __pyx_t_4 = PyUnicode_Check(__pyx_v_ghandleName); - __pyx_t_3 = (__pyx_t_4 != 0); - if (__pyx_t_3) { + __pyx_t_2 = PyUnicode_Check(__pyx_v_ghandleName); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5597 + /* "PyCafe.pyx":5804 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 5597, __pyx_L1_error) - __pyx_t_2 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5597, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5597, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_ghandle = __pyx_t_6; + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 5804, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5804, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5804, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5596 + /* "PyCafe.pyx":5803 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -99610,7 +103467,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct goto __pyx_L3; } - /* "PyCafe.pyx":5599 + /* "PyCafe.pyx":5806 * ghandle = self.checkForGroupHandle(ghandleName) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -99618,18 +103475,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct * raise _cafeException */ /*else*/ { - __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5599, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5599, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 5599, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_1); - __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5806, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5806, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5806, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 5806, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5806, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); + __pyx_t_6 = 0; - /* "PyCafe.pyx":5601 + /* "PyCafe.pyx":5808 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if group handle, else if group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -99637,11 +103494,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct * if dbr: */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5601, __pyx_L1_error) + __PYX_ERR(3, 5808, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5603 + /* "PyCafe.pyx":5810 * raise _cafeException * * if dbr: # <<<<<<<<<<<<<< @@ -99650,7 +103507,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ if (__pyx_v_dbr) { - /* "PyCafe.pyx":5604 + /* "PyCafe.pyx":5811 * * if dbr: * if dbr not in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: # <<<<<<<<<<<<<< @@ -99663,58 +103520,58 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct case DBR_TIME: case DBR_GR: case DBR_CTRL: - __pyx_t_3 = 0; + __pyx_t_1 = 0; break; default: - __pyx_t_3 = 1; + __pyx_t_1 = 1; break; } - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { - /* "PyCafe.pyx":5605 + /* "PyCafe.pyx":5812 * 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( */ - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5605, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_kp_u_Warning_from_groupMonitorStartW); __Pyx_GIVEREF(__pyx_kp_u_Warning_from_groupMonitorStartW); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_Warning_from_groupMonitorStartW); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_Warning_from_groupMonitorStartW); __Pyx_INCREF(__pyx_v_ghandleName); __Pyx_GIVEREF(__pyx_v_ghandleName); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ghandleName); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5605, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_ghandleName); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5607 + /* "PyCafe.pyx":5814 * 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") */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__95, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5607, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__95, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5814, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5609 + /* "PyCafe.pyx":5816 * 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 * */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5609, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5610 + /* "PyCafe.pyx":5817 * "dbr base type should be one of DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL") * print("Assuming DBR_TIME") * dbr = DBR_TIME # <<<<<<<<<<<<<< @@ -99723,7 +103580,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ __pyx_v_dbr = DBR_TIME; - /* "PyCafe.pyx":5604 + /* "PyCafe.pyx":5811 * * if dbr: * if dbr not in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: # <<<<<<<<<<<<<< @@ -99732,7 +103589,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ } - /* "PyCafe.pyx":5603 + /* "PyCafe.pyx":5810 * raise _cafeException * * if dbr: # <<<<<<<<<<<<<< @@ -99741,31 +103598,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ } - /* "PyCafe.pyx":5612 + /* "PyCafe.pyx":5819 * 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") */ - __pyx_t_4 = PyList_Check(__pyx_v_cb); - __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); - if (__pyx_t_3) { + __pyx_t_2 = PyList_Check(__pyx_v_cb); + __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5613 + /* "PyCafe.pyx":5820 * * 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") * */ - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__101, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5613, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(3, 5613, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__99, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5820, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(3, 5820, __pyx_L1_error) - /* "PyCafe.pyx":5612 + /* "PyCafe.pyx":5819 * dbr = DBR_TIME * * if not isinstance(cb, (list)): # <<<<<<<<<<<<<< @@ -99774,7 +103631,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ } - /* "PyCafe.pyx":5622 + /* "PyCafe.pyx":5829 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -99789,7 +103646,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct #endif /*try:*/ { - /* "PyCafe.pyx":5623 + /* "PyCafe.pyx":5830 * * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) # <<<<<<<<<<<<<< @@ -99799,7 +103656,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct (void)(__pyx_v_self->_c_cafe->groupAttach(__pyx_v_ghandle, __pyx_v_pvg)); } - /* "PyCafe.pyx":5622 + /* "PyCafe.pyx":5829 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -99818,7 +103675,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct } } - /* "PyCafe.pyx":5625 + /* "PyCafe.pyx":5832 * self._c_cafe.groupAttach(ghandle, pvg) * * if (len(cb) != pvg.getNPV()): # <<<<<<<<<<<<<< @@ -99827,23 +103684,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ if (unlikely(__pyx_v_cb == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 5625, __pyx_L1_error) + __PYX_ERR(3, 5832, __pyx_L1_error) } - __pyx_t_7 = PyList_GET_SIZE(__pyx_v_cb); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5625, __pyx_L1_error) - __pyx_t_3 = ((__pyx_t_7 != __pyx_v_pvg.getNPV()) != 0); - if (__pyx_t_3) { + __pyx_t_7 = PyList_GET_SIZE(__pyx_v_cb); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5832, __pyx_L1_error) + __pyx_t_1 = ((__pyx_t_7 != __pyx_v_pvg.getNPV()) != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5626 + /* "PyCafe.pyx":5833 * * 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\ */ - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_pvg.getNPV()); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5626, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_pvg.getNPV()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5833, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); - /* "PyCafe.pyx":5627 + /* "PyCafe.pyx":5834 * if (len(cb) != pvg.getNPV()): * print("No of group members is ", pvg.getNPV(), * " while list of callback objects is", len(cb)) # <<<<<<<<<<<<<< @@ -99852,52 +103709,52 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ if (unlikely(__pyx_v_cb == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 5627, __pyx_L1_error) + __PYX_ERR(3, 5834, __pyx_L1_error) } - __pyx_t_7 = PyList_GET_SIZE(__pyx_v_cb); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5627, __pyx_L1_error) - __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5627, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = PyList_GET_SIZE(__pyx_v_cb); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5834, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5834, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":5626 + /* "PyCafe.pyx":5833 * * 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\ */ - __pyx_t_8 = PyTuple_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5626, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5833, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_kp_u_No_of_group_members_is); __Pyx_GIVEREF(__pyx_kp_u_No_of_group_members_is); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_No_of_group_members_is); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_5); __Pyx_INCREF(__pyx_kp_u_while_list_of_callback_objects); __Pyx_GIVEREF(__pyx_kp_u_while_list_of_callback_objects); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u_while_list_of_callback_objects); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_1); - __pyx_t_2 = 0; - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5626, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_8, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5833, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5628 + /* "PyCafe.pyx":5835 * 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") * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__102, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5628, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(3, 5628, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__100, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5835, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(3, 5835, __pyx_L1_error) - /* "PyCafe.pyx":5625 + /* "PyCafe.pyx":5832 * self._c_cafe.groupAttach(ghandle, pvg) * * if (len(cb) != pvg.getNPV()): # <<<<<<<<<<<<<< @@ -99906,7 +103763,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ } - /* "PyCafe.pyx":5632 + /* "PyCafe.pyx":5839 * * cdef MonitorPolicy * mp * mp = self._c_cafe.createMonitorPolicyArray(pvg.getNPV()) # <<<<<<<<<<<<<< @@ -99915,29 +103772,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ __pyx_v_mp = __pyx_v_self->_c_cafe->createMonitorPolicyArray(__pyx_v_pvg.getNPV()); - /* "PyCafe.pyx":5634 + /* "PyCafe.pyx":5841 * mp = self._c_cafe.createMonitorPolicyArray(pvg.getNPV()) * * handleList = [] # <<<<<<<<<<<<<< * handleList = self.getHandlesFromWithinGroup(ghandle) * */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5634, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_handleList = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5841, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_v_handleList = __pyx_t_6; + __pyx_t_6 = 0; - /* "PyCafe.pyx":5635 + /* "PyCafe.pyx":5842 * * handleList = [] * handleList = self.getHandlesFromWithinGroup(ghandle) # <<<<<<<<<<<<<< * * for i in range(0, pvg.getNPV()): */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5635, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5842, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5635, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5842, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); @@ -99948,28 +103805,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_2); + __pyx_t_6 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_5); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5635, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5842, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_1); - __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_6); + __pyx_t_6 = 0; - /* "PyCafe.pyx":5637 + /* "PyCafe.pyx":5844 * handleList = self.getHandlesFromWithinGroup(ghandle) * * for i in range(0, pvg.getNPV()): # <<<<<<<<<<<<<< * * mp[i].setMask(mask) */ - __pyx_t_6 = __pyx_v_pvg.getNPV(); - __pyx_t_10 = __pyx_t_6; + __pyx_t_4 = __pyx_v_pvg.getNPV(); + __pyx_t_10 = __pyx_t_4; for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_i = __pyx_t_11; - /* "PyCafe.pyx":5639 + /* "PyCafe.pyx":5846 * for i in range(0, pvg.getNPV()): * * mp[i].setMask(mask) # <<<<<<<<<<<<<< @@ -99978,7 +103835,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ (__pyx_v_mp[__pyx_v_i]).setMask(__pyx_v_mask); - /* "PyCafe.pyx":5640 + /* "PyCafe.pyx":5847 * * mp[i].setMask(mask) * mp[i].setCafeDbrType(dbr) # <<<<<<<<<<<<<< @@ -99987,7 +103844,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ (__pyx_v_mp[__pyx_v_i]).setCafeDbrType(__pyx_v_dbr); - /* "PyCafe.pyx":5641 + /* "PyCafe.pyx":5848 * mp[i].setMask(mask) * mp[i].setCafeDbrType(dbr) * mp[i].setNotifyDeltaMilliSeconds(notify_milliseconds) # <<<<<<<<<<<<<< @@ -99996,7 +103853,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ (__pyx_v_mp[__pyx_v_i]).setNotifyDeltaMilliSeconds(__pyx_v_notify_milliseconds); - /* "PyCafe.pyx":5643 + /* "PyCafe.pyx":5850 * mp[i].setNotifyDeltaMilliSeconds(notify_milliseconds) * * mpid = mp[i].getMonitorID() # <<<<<<<<<<<<<< @@ -100005,7 +103862,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ __pyx_v_mpid = (__pyx_v_mp[__pyx_v_i]).getMonitorID(); - /* "PyCafe.pyx":5648 + /* "PyCafe.pyx":5855 * * # For setUserArgs pass the address of the variable. * if cb[i]: # <<<<<<<<<<<<<< @@ -100014,52 +103871,52 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ if (unlikely(__pyx_v_cb == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 5648, __pyx_L1_error) + __PYX_ERR(3, 5855, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_cb, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5648, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 5648, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (__pyx_t_3) { + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_cb, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5855, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_1) { - /* "PyCafe.pyx":5649 + /* "PyCafe.pyx":5856 * # For setUserArgs pass the address of the variable. * if cb[i]: * sig = inspect.signature(cb[i]) # <<<<<<<<<<<<<< * mp[i].setUserArgs(< void * > mpid) # ( ptr_mpid)[0]) * mp[i].setNoCyCallbackParameters(len(sig.parameters)) */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_inspect); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5649, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_inspect); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_signature); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5649, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_signature); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(__pyx_v_cb == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 5649, __pyx_L1_error) + __PYX_ERR(3, 5856, __pyx_L1_error) } - __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_cb, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5649, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_cb, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_5, function); } } - __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_9, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_8); + __pyx_t_6 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_9, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5649, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); - __pyx_t_1 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_6); + __pyx_t_6 = 0; - /* "PyCafe.pyx":5650 + /* "PyCafe.pyx":5857 * if cb[i]: * sig = inspect.signature(cb[i]) * mp[i].setUserArgs(< void * > mpid) # ( ptr_mpid)[0]) # <<<<<<<<<<<<<< @@ -100068,214 +103925,36 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ (__pyx_v_mp[__pyx_v_i]).setUserArgs(((void *)__pyx_v_mpid)); - /* "PyCafe.pyx":5651 + /* "PyCafe.pyx":5858 * sig = inspect.signature(cb[i]) * mp[i].setUserArgs(< void * > mpid) # ( ptr_mpid)[0]) * mp[i].setNoCyCallbackParameters(len(sig.parameters)) # <<<<<<<<<<<<<< * mp[i].setPyCyHandler( cb[i]) * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5651, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5651, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5858, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_Length(__pyx_t_6); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5858, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; (__pyx_v_mp[__pyx_v_i]).setNoCyCallbackParameters(__pyx_t_7); - /* "PyCafe.pyx":5652 + /* "PyCafe.pyx":5859 * mp[i].setUserArgs(< void * > mpid) # ( ptr_mpid)[0]) * mp[i].setNoCyCallbackParameters(len(sig.parameters)) * mp[i].setPyCyHandler( cb[i]) # <<<<<<<<<<<<<< * - * print('============') + * #print('============') */ if (unlikely(__pyx_v_cb == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 5652, __pyx_L1_error) + __PYX_ERR(3, 5859, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_cb, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5652, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - (__pyx_v_mp[__pyx_v_i]).setPyCyHandler(((void *)__pyx_t_1)); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_cb, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + (__pyx_v_mp[__pyx_v_i]).setPyCyHandler(((void *)__pyx_t_6)); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5654 - * mp[i].setPyCyHandler( cb[i]) - * - * print('============') # <<<<<<<<<<<<<< - * print('SIGNATURE//2//:') - * print(str(sig)) - */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__104, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5654, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "PyCafe.pyx":5655 - * - * print('============') - * print('SIGNATURE//2//:') # <<<<<<<<<<<<<< - * print(str(sig)) - * for param in sig.parameters.values(): - */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__105, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5655, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "PyCafe.pyx":5656 - * print('============') - * print('SIGNATURE//2//:') - * print(str(sig)) # <<<<<<<<<<<<<< - * for param in sig.parameters.values(): - * print('Parameter:', param) - */ - __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_v_sig); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5656, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5656, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "PyCafe.pyx":5657 - * print('SIGNATURE//2//:') - * print(str(sig)) - * for param in sig.parameters.values(): # <<<<<<<<<<<<<< - * print('Parameter:', param) - * print('len1', len(sig.parameters.values())) - */ - __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5657, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (unlikely(__pyx_t_1 == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(3, 5657, __pyx_L1_error) - } - __pyx_t_8 = __Pyx_dict_iterator(__pyx_t_1, 0, __pyx_n_s_values, (&__pyx_t_12), (&__pyx_t_13)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5657, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); - __pyx_t_2 = __pyx_t_8; - __pyx_t_8 = 0; - while (1) { - __pyx_t_14 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_12, &__pyx_t_7, NULL, &__pyx_t_8, NULL, __pyx_t_13); - if (unlikely(__pyx_t_14 == 0)) break; - if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(3, 5657, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_8); - __pyx_t_8 = 0; - - /* "PyCafe.pyx":5658 - * print(str(sig)) - * for param in sig.parameters.values(): - * print('Parameter:', param) # <<<<<<<<<<<<<< - * print('len1', len(sig.parameters.values())) - * print('len2', len(sig.parameters)) - */ - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5658, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_kp_u_Parameter); - __Pyx_GIVEREF(__pyx_kp_u_Parameter); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_Parameter); - __Pyx_INCREF(__pyx_v_param); - __Pyx_GIVEREF(__pyx_v_param); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_param); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5658, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "PyCafe.pyx":5659 - * for param in sig.parameters.values(): - * print('Parameter:', param) - * print('len1', len(sig.parameters.values())) # <<<<<<<<<<<<<< - * print('len2', len(sig.parameters)) - * print('monitorid', mpid) # ( ptr_mpid)[0]) - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5659, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_values); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5659, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5659, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_12 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5659, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5659, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5659, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_n_u_len1); - __Pyx_GIVEREF(__pyx_n_u_len1); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_n_u_len1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5659, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "PyCafe.pyx":5660 - * print('Parameter:', param) - * print('len1', len(sig.parameters.values())) - * print('len2', len(sig.parameters)) # <<<<<<<<<<<<<< - * print('monitorid', mpid) # ( ptr_mpid)[0]) - * - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5660, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_12 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(3, 5660, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5660, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5660, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_n_u_len2); - __Pyx_GIVEREF(__pyx_n_u_len2); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_n_u_len2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5660, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "PyCafe.pyx":5661 - * print('len1', len(sig.parameters.values())) - * print('len2', len(sig.parameters)) - * print('monitorid', mpid) # ( ptr_mpid)[0]) # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __Pyx_PyInt_From_unsigned_long(__pyx_v_mpid); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5661, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5661, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_n_u_monitorid); - __Pyx_GIVEREF(__pyx_n_u_monitorid); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_n_u_monitorid); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5661, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "PyCafe.pyx":5648 + /* "PyCafe.pyx":5855 * * # For setUserArgs pass the address of the variable. * if cb[i]: # <<<<<<<<<<<<<< @@ -100284,7 +103963,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ } - /* "PyCafe.pyx":5664 + /* "PyCafe.pyx":5871 * * * mpV.push_back(mp[i]) # <<<<<<<<<<<<<< @@ -100295,11 +103974,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct __pyx_v_mpV.push_back((__pyx_v_mp[__pyx_v_i])); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 5664, __pyx_L1_error) + __PYX_ERR(3, 5871, __pyx_L1_error) } } - /* "PyCafe.pyx":5667 + /* "PyCafe.pyx":5874 * * cdef vector[int] vStatus * vStatus.reserve(pvg.getNPV()) # <<<<<<<<<<<<<< @@ -100308,7 +103987,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ __pyx_v_vStatus.reserve(__pyx_v_pvg.getNPV()); - /* "PyCafe.pyx":5669 + /* "PyCafe.pyx":5876 * vStatus.reserve(pvg.getNPV()) * * with nogil: # <<<<<<<<<<<<<< @@ -100323,7 +104002,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct #endif /*try:*/ { - /* "PyCafe.pyx":5670 + /* "PyCafe.pyx":5877 * * with nogil: * status = self._c_cafe.groupMonitorStart(ghandle, vStatus, mpV) # <<<<<<<<<<<<<< @@ -100333,7 +104012,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct __pyx_v_status = __pyx_v_self->_c_cafe->groupMonitorStart(__pyx_v_ghandle, __pyx_v_vStatus, __pyx_v_mpV); } - /* "PyCafe.pyx":5669 + /* "PyCafe.pyx":5876 * vStatus.reserve(pvg.getNPV()) * * with nogil: # <<<<<<<<<<<<<< @@ -100346,33 +104025,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif - goto __pyx_L20; + goto __pyx_L18; } - __pyx_L20:; + __pyx_L18:; } } - /* "PyCafe.pyx":5672 + /* "PyCafe.pyx":5879 * status = self._c_cafe.groupMonitorStart(ghandle, vStatus, mpV) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) */ - __pyx_t_3 = ((__pyx_v_status != ICAFE_NORMAL) != 0); - if (__pyx_t_3) { + __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5673 + /* "PyCafe.pyx":5880 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * */ - __pyx_t_3 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); - if (__pyx_t_3) { + __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); + if (__pyx_t_1) { - /* "PyCafe.pyx":5674 + /* "PyCafe.pyx":5881 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -100381,7 +104060,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5673 + /* "PyCafe.pyx":5880 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -100390,7 +104069,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ } - /* "PyCafe.pyx":5672 + /* "PyCafe.pyx":5879 * status = self._c_cafe.groupMonitorStart(ghandle, vStatus, mpV) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -100399,7 +104078,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct */ } - /* "PyCafe.pyx":5676 + /* "PyCafe.pyx":5883 * self._c_cafe.printStatusMessage(status) * * return status, vStatus # <<<<<<<<<<<<<< @@ -100407,23 +104086,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5676, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5676, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __pyx_convert_vector_to_py_int(__pyx_v_vStatus); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 5883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5676, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_8); - __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_5); + __pyx_t_6 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_8; __pyx_t_8 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5583 + /* "PyCafe.pyx":5790 * ############################################################################ * * def groupMonitorStartWithCBList(self, # <<<<<<<<<<<<<< @@ -100435,8 +104114,8 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("PyCafe.CyCafe.groupMonitorStartWithCBList", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -100446,13 +104125,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_336groupMonitorStartWithCBList(struct __Pyx_XDECREF((PyObject *)__pyx_v__cafeException); __Pyx_XDECREF(__pyx_v_handleList); __Pyx_XDECREF(__pyx_v_sig); - __Pyx_XDECREF(__pyx_v_param); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "PyCafe.pyx":5679 +/* "PyCafe.pyx":5886 * * ################################################################################## * def getHandleFromPVWithinGroup(self, str pv, ghandleName): # <<<<<<<<<<<<<< @@ -100491,11 +104169,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_339getHandleFromPVWithinGroup(PyObject case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ghandleName)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("getHandleFromPVWithinGroup", 1, 2, 2, 1); __PYX_ERR(3, 5679, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getHandleFromPVWithinGroup", 1, 2, 2, 1); __PYX_ERR(3, 5886, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getHandleFromPVWithinGroup") < 0)) __PYX_ERR(3, 5679, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getHandleFromPVWithinGroup") < 0)) __PYX_ERR(3, 5886, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -100508,13 +104186,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_339getHandleFromPVWithinGroup(PyObject } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getHandleFromPVWithinGroup", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5679, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getHandleFromPVWithinGroup", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5886, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getHandleFromPVWithinGroup", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pv), (&PyUnicode_Type), 1, "pv", 1))) __PYX_ERR(3, 5679, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pv), (&PyUnicode_Type), 1, "pv", 1))) __PYX_ERR(3, 5886, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_pv, __pyx_v_ghandleName); /* function exit code */ @@ -100542,7 +104220,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ unsigned int __pyx_t_8; __Pyx_RefNannySetupContext("getHandleFromPVWithinGroup", 0); - /* "PyCafe.pyx":5680 + /* "PyCafe.pyx":5887 * ################################################################################## * def getHandleFromPVWithinGroup(self, str pv, ghandleName): * cdef str _METHOD = "getHandleFromPVWithinGroup(pv. ghandleName)" # <<<<<<<<<<<<<< @@ -100552,7 +104230,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ __Pyx_INCREF(__pyx_kp_u_getHandleFromPVWithinGroup_pv_gh); __pyx_v__METHOD = __pyx_kp_u_getHandleFromPVWithinGroup_pv_gh; - /* "PyCafe.pyx":5681 + /* "PyCafe.pyx":5888 * def getHandleFromPVWithinGroup(self, str pv, ghandleName): * cdef str _METHOD = "getHandleFromPVWithinGroup(pv. ghandleName)" * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -100573,7 +104251,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5682 + /* "PyCafe.pyx":5889 * cdef str _METHOD = "getHandleFromPVWithinGroup(pv. ghandleName)" * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< @@ -100583,7 +104261,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ __Pyx_INCREF(__pyx_v_ghandleName); __pyx_v_ghandle = __pyx_v_ghandleName; - /* "PyCafe.pyx":5681 + /* "PyCafe.pyx":5888 * def getHandleFromPVWithinGroup(self, str pv, ghandleName): * cdef str _METHOD = "getHandleFromPVWithinGroup(pv. ghandleName)" * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -100593,7 +104271,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ goto __pyx_L3; } - /* "PyCafe.pyx":5683 + /* "PyCafe.pyx":5890 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -100604,20 +104282,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5684 + /* "PyCafe.pyx":5891 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.hh.getGroupHandleFromGroupName(ghandleName) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - __pyx_t_4 = __Pyx_PyObject_AsString(__pyx_v_ghandleName); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(3, 5684, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getGroupHandleFromGroupName(__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5684, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsString(__pyx_v_ghandleName); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(3, 5891, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getGroupHandleFromGroupName(__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_ghandle = __pyx_t_5; __pyx_t_5 = 0; - /* "PyCafe.pyx":5683 + /* "PyCafe.pyx":5890 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -100627,7 +104305,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ goto __pyx_L3; } - /* "PyCafe.pyx":5686 + /* "PyCafe.pyx":5893 * ghandle = self.hh.getGroupHandleFromGroupName(ghandleName) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -100635,18 +104313,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ * raise _cafeException */ /*else*/ { - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5686, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5686, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5686, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 5686, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5686, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5893, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5893, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 5893, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5688 + /* "PyCafe.pyx":5895 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if group handle, else if group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -100654,11 +104332,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5688, __pyx_L1_error) + __PYX_ERR(3, 5895, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5689 + /* "PyCafe.pyx":5896 * _error_info="First input argument, should be of type if group handle, else if group name") * raise _cafeException * return self.hh.getHandleFromPVWithinGroup(pv, ghandle) # <<<<<<<<<<<<<< @@ -100666,15 +104344,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_pv); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(3, 5689, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandle); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5689, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getHandleFromPVWithinGroup(__pyx_t_7, __pyx_t_8)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5689, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_pv); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(3, 5896, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandle); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5896, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getHandleFromPVWithinGroup(__pyx_t_7, __pyx_t_8)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5679 + /* "PyCafe.pyx":5886 * * ################################################################################## * def getHandleFromPVWithinGroup(self, str pv, ghandleName): # <<<<<<<<<<<<<< @@ -100699,7 +104377,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_338getHandleFromPVWithinGroup(struct _ return __pyx_r; } -/* "PyCafe.pyx":5693 +/* "PyCafe.pyx":5900 * ################################################################################## * * def getGroupStr(self, ghandleName): # <<<<<<<<<<<<<< @@ -100730,7 +104408,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_340getGroupStr(struct __pyx_obj_6PyCaf PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getGroupStr", 0); - /* "PyCafe.pyx":5694 + /* "PyCafe.pyx":5901 * * def getGroupStr(self, ghandleName): * return self.getGroup(ghandleName, 'str') # <<<<<<<<<<<<<< @@ -100738,7 +104416,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_340getGroupStr(struct __pyx_obj_6PyCaf * def getGroupInt(self, ghandleName): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getGroup); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5694, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getGroup); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -100755,7 +104433,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_340getGroupStr(struct __pyx_obj_6PyCaf #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_ghandleName, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5694, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5901, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -100763,13 +104441,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_340getGroupStr(struct __pyx_obj_6PyCaf #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_ghandleName, __pyx_n_u_str}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5694, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5901, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5694, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -100780,7 +104458,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_340getGroupStr(struct __pyx_obj_6PyCaf __Pyx_INCREF(__pyx_n_u_str); __Pyx_GIVEREF(__pyx_n_u_str); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_str); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5694, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -100789,7 +104467,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_340getGroupStr(struct __pyx_obj_6PyCaf __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5693 + /* "PyCafe.pyx":5900 * ################################################################################## * * def getGroupStr(self, ghandleName): # <<<<<<<<<<<<<< @@ -100813,7 +104491,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_340getGroupStr(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":5696 +/* "PyCafe.pyx":5903 * return self.getGroup(ghandleName, 'str') * * def getGroupInt(self, ghandleName): # <<<<<<<<<<<<<< @@ -100844,7 +104522,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_342getGroupInt(struct __pyx_obj_6PyCaf PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getGroupInt", 0); - /* "PyCafe.pyx":5697 + /* "PyCafe.pyx":5904 * * def getGroupInt(self, ghandleName): * return self.getGroup(ghandleName, 'int') # <<<<<<<<<<<<<< @@ -100852,7 +104530,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_342getGroupInt(struct __pyx_obj_6PyCaf * def getGroupFloat(self, ghandleName): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getGroup); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5697, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getGroup); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5904, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -100869,7 +104547,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_342getGroupInt(struct __pyx_obj_6PyCaf #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_ghandleName, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5697, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5904, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -100877,13 +104555,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_342getGroupInt(struct __pyx_obj_6PyCaf #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_ghandleName, __pyx_n_u_int}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5697, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5904, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5697, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5904, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -100894,7 +104572,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_342getGroupInt(struct __pyx_obj_6PyCaf __Pyx_INCREF(__pyx_n_u_int); __Pyx_GIVEREF(__pyx_n_u_int); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_int); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5697, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5904, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -100903,7 +104581,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_342getGroupInt(struct __pyx_obj_6PyCaf __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5696 + /* "PyCafe.pyx":5903 * return self.getGroup(ghandleName, 'str') * * def getGroupInt(self, ghandleName): # <<<<<<<<<<<<<< @@ -100927,7 +104605,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_342getGroupInt(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":5699 +/* "PyCafe.pyx":5906 * return self.getGroup(ghandleName, 'int') * * def getGroupFloat(self, ghandleName): # <<<<<<<<<<<<<< @@ -100958,7 +104636,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_344getGroupFloat(struct __pyx_obj_6PyC PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("getGroupFloat", 0); - /* "PyCafe.pyx":5700 + /* "PyCafe.pyx":5907 * * def getGroupFloat(self, ghandleName): * return self.getGroup(ghandleName, 'float') # <<<<<<<<<<<<<< @@ -100966,7 +104644,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_344getGroupFloat(struct __pyx_obj_6PyC * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getGroup); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5700, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getGroup); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5907, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; @@ -100983,7 +104661,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_344getGroupFloat(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_ghandleName, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5700, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5907, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -100991,13 +104669,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_344getGroupFloat(struct __pyx_obj_6PyC #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_ghandleName, __pyx_n_u_float}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5700, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5907, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5700, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5907, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -101008,7 +104686,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_344getGroupFloat(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_float); __Pyx_GIVEREF(__pyx_n_u_float); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_n_u_float); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5700, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5907, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -101017,7 +104695,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_344getGroupFloat(struct __pyx_obj_6PyC __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5699 + /* "PyCafe.pyx":5906 * return self.getGroup(ghandleName, 'int') * * def getGroupFloat(self, ghandleName): # <<<<<<<<<<<<<< @@ -101041,7 +104719,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_344getGroupFloat(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":5703 +/* "PyCafe.pyx":5910 * * ################################################################################## * def getGroup(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -101085,7 +104763,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_347getGroup(PyObject *__pyx_v_self, Py } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getGroup") < 0)) __PYX_ERR(3, 5703, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getGroup") < 0)) __PYX_ERR(3, 5910, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -101101,13 +104779,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_347getGroup(PyObject *__pyx_v_self, Py } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getGroup", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5703, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getGroup", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5910, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getGroup", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 5703, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 5910, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_346getGroup(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_ghandleName, __pyx_v_dt); /* function exit code */ @@ -101159,7 +104837,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C long __pyx_t_19; __Pyx_RefNannySetupContext("getGroup", 0); - /* "PyCafe.pyx":5704 + /* "PyCafe.pyx":5911 * ################################################################################## * def getGroup(self, ghandleName, str dt='native'): * cdef str _METHOD = "getGroup(ghandleName, str dt='native')" # <<<<<<<<<<<<<< @@ -101169,7 +104847,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_kp_u_getGroup_ghandleName_str_dt_nati); __pyx_v__METHOD = __pyx_kp_u_getGroup_ghandleName_str_dt_nati; - /* "PyCafe.pyx":5705 + /* "PyCafe.pyx":5912 * def getGroup(self, ghandleName, str dt='native'): * cdef str _METHOD = "getGroup(ghandleName, str dt='native')" * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -101178,7 +104856,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":5706 + /* "PyCafe.pyx":5913 * cdef str _METHOD = "getGroup(ghandleName, str dt='native')" * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -101199,17 +104877,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5707 + /* "PyCafe.pyx":5914 * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5707, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5914, __pyx_L1_error) __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5706 + /* "PyCafe.pyx":5913 * cdef str _METHOD = "getGroup(ghandleName, str dt='native')" * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -101219,7 +104897,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L3; } - /* "PyCafe.pyx":5708 + /* "PyCafe.pyx":5915 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -101230,21 +104908,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5709 + /* "PyCafe.pyx":5916 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 5709, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5709, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 5916, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5916, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5709, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5916, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5708 + /* "PyCafe.pyx":5915 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -101254,7 +104932,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L3; } - /* "PyCafe.pyx":5711 + /* "PyCafe.pyx":5918 * ghandle = self.checkForGroupHandle(ghandleName) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -101262,18 +104940,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C * raise _cafeException */ /*else*/ { - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5711, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5918, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5711, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5711, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 5711, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5711, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5918, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5918, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 5918, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5918, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5713 + /* "PyCafe.pyx":5920 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if group handle, else if group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -101281,11 +104959,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C * cdef PVGroup pvg */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5713, __pyx_L1_error) + __PYX_ERR(3, 5920, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5717 + /* "PyCafe.pyx":5924 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -101300,7 +104978,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C #endif /*try:*/ { - /* "PyCafe.pyx":5718 + /* "PyCafe.pyx":5925 * * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) # <<<<<<<<<<<<<< @@ -101310,7 +104988,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C (void)(__pyx_v_self->_c_cafe->groupAttach(__pyx_v_ghandle, __pyx_v_pvg)); } - /* "PyCafe.pyx":5717 + /* "PyCafe.pyx":5924 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -101329,7 +105007,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C } } - /* "PyCafe.pyx":5721 + /* "PyCafe.pyx":5928 * * cdef PVDataHolder * pvd * pvd = pvg.getPVData() # <<<<<<<<<<<<<< @@ -101338,7 +105016,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_pvd = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":5722 + /* "PyCafe.pyx":5929 * cdef PVDataHolder * pvd * pvd = pvg.getPVData() * for i in range(0, pvg.getNPV()): # <<<<<<<<<<<<<< @@ -101350,7 +105028,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":5723 + /* "PyCafe.pyx":5930 * pvd = pvg.getPVData() * for i in range(0, pvg.getNPV()): * pvd[i].setHasAlarm(False) # <<<<<<<<<<<<<< @@ -101359,7 +105037,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ (__pyx_v_pvd[__pyx_v_i]).setHasAlarm(0); - /* "PyCafe.pyx":5724 + /* "PyCafe.pyx":5931 * for i in range(0, pvg.getNPV()): * pvd[i].setHasAlarm(False) * pvd[i].setHasTS(False) # <<<<<<<<<<<<<< @@ -101369,7 +105047,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C (__pyx_v_pvd[__pyx_v_i]).setHasTS(0); } - /* "PyCafe.pyx":5727 + /* "PyCafe.pyx":5934 * # pvd[i].setRule(False) * * pvg.setPVData(pvd) # <<<<<<<<<<<<<< @@ -101378,7 +105056,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_pvg.setPVData(__pyx_v_pvd); - /* "PyCafe.pyx":5734 + /* "PyCafe.pyx":5941 * ## * * with nogil: # <<<<<<<<<<<<<< @@ -101393,7 +105071,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C #endif /*try:*/ { - /* "PyCafe.pyx":5735 + /* "PyCafe.pyx":5942 * * with nogil: * status = self._c_cafe.groupGet(ghandle, pvg) # <<<<<<<<<<<<<< @@ -101403,7 +105081,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_v_status = __pyx_v_self->_c_cafe->groupGet(__pyx_v_ghandle, __pyx_v_pvg); } - /* "PyCafe.pyx":5734 + /* "PyCafe.pyx":5941 * ## * * with nogil: # <<<<<<<<<<<<<< @@ -101422,7 +105100,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C } } - /* "PyCafe.pyx":5737 + /* "PyCafe.pyx":5944 * status = self._c_cafe.groupGet(ghandle, pvg) * * if status == ECA_TIMEOUT: # <<<<<<<<<<<<<< @@ -101432,18 +105110,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((__pyx_v_status == ECA_TIMEOUT) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5738 + /* "PyCafe.pyx":5945 * * if status == ECA_TIMEOUT: * print("======================================================") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * print("TIMEOUT in getGroup; switching to getCompoundList") */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__107, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5738, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__102, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5739 + /* "PyCafe.pyx":5946 * if status == ECA_TIMEOUT: * print("======================================================") * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -101452,29 +105130,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5740 + /* "PyCafe.pyx":5947 * print("======================================================") * self._c_cafe.printStatusMessage(status) * print("TIMEOUT in getGroup; switching to getCompoundList") # <<<<<<<<<<<<<< * print("======================================================") * return self.getCompoundList(pvg.getNameAsString(), dt) */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__108, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5740, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__103, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5947, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5741 + /* "PyCafe.pyx":5948 * self._c_cafe.printStatusMessage(status) * print("TIMEOUT in getGroup; switching to getCompoundList") * print("======================================================") # <<<<<<<<<<<<<< * return self.getCompoundList(pvg.getNameAsString(), dt) * */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__107, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5741, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__102, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5948, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5742 + /* "PyCafe.pyx":5949 * print("TIMEOUT in getGroup; switching to getCompoundList") * print("======================================================") * return self.getCompoundList(pvg.getNameAsString(), dt) # <<<<<<<<<<<<<< @@ -101482,9 +105160,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C * if status != ICAFE_NORMAL: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCompoundList); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5742, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCompoundList); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvg.getNameAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5742, __pyx_L1_error) + __pyx_t_9 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_pvg.getNameAsString()); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 5949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = NULL; __pyx_t_11 = 0; @@ -101501,7 +105179,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_9, __pyx_v_dt}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5742, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5949, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; @@ -101510,14 +105188,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_9, __pyx_v_dt}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5742, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5949, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else #endif { - __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 5742, __pyx_L1_error) + __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 5949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); if (__pyx_t_10) { __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL; @@ -101528,7 +105206,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_GIVEREF(__pyx_v_dt); PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_v_dt); __pyx_t_9 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5742, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } @@ -101537,7 +105215,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5737 + /* "PyCafe.pyx":5944 * status = self._c_cafe.groupGet(ghandle, pvg) * * if status == ECA_TIMEOUT: # <<<<<<<<<<<<<< @@ -101546,7 +105224,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5744 + /* "PyCafe.pyx":5951 * return self.getCompoundList(pvg.getNameAsString(), dt) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -101556,7 +105234,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5745 + /* "PyCafe.pyx":5952 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -101566,7 +105244,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5746 + /* "PyCafe.pyx":5953 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -101575,7 +105253,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5745 + /* "PyCafe.pyx":5952 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -101584,7 +105262,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5744 + /* "PyCafe.pyx":5951 * return self.getCompoundList(pvg.getNameAsString(), dt) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -101593,7 +105271,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5752 + /* "PyCafe.pyx":5959 * # pvg.showMaxMax(5,10) * * pvd = pvg.getPVData() # <<<<<<<<<<<<<< @@ -101602,31 +105280,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_pvd = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":5754 + /* "PyCafe.pyx":5961 * pvd = pvg.getPVData() * * localList = [] # <<<<<<<<<<<<<< * statusList = [] * cdef unsigned int dtn, dtcheck */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5754, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5961, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_localList = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5755 + /* "PyCafe.pyx":5962 * * localList = [] * statusList = [] # <<<<<<<<<<<<<< * cdef unsigned int dtn, dtcheck * cdef bytes bytesVal */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5755, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5962, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_statusList = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5759 + /* "PyCafe.pyx":5966 * cdef bytes bytesVal * * for i in range(0, pvg.getNPV()): # <<<<<<<<<<<<<< @@ -101638,7 +105316,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":5760 + /* "PyCafe.pyx":5967 * * for i in range(0, pvg.getNPV()): * dtn = pvd[i].getDataType() # <<<<<<<<<<<<<< @@ -101647,35 +105325,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_dtn = (__pyx_v_pvd[__pyx_v_i]).getDataType(); - /* "PyCafe.pyx":5762 + /* "PyCafe.pyx":5969 * dtn = pvd[i].getDataType() * * dtcheck = getMatchedDataType(dt, dtn) # <<<<<<<<<<<<<< * * statusList.append(pvd[i].getStatus()) */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5762, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5762, __pyx_L1_error) + __pyx_t_5 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5762, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_13 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5969, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_dtcheck = __pyx_t_13; - /* "PyCafe.pyx":5764 + /* "PyCafe.pyx":5971 * dtcheck = getMatchedDataType(dt, dtn) * * statusList.append(pvd[i].getStatus()) # <<<<<<<<<<<<<< * * if pvd[i].getNelem() == 1: */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5764, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5764, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5971, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5766 + /* "PyCafe.pyx":5973 * statusList.append(pvd[i].getStatus()) * * if pvd[i].getNelem() == 1: # <<<<<<<<<<<<<< @@ -101685,7 +105363,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (((__pyx_v_pvd[__pyx_v_i]).getNelem() == 1) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5767 + /* "PyCafe.pyx":5974 * * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -101695,14 +105373,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":5769 + /* "PyCafe.pyx":5976 * if dtcheck == CAFE_STRING: * * bytesVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in pvd[i].getPVName(): */ - __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5769, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __pyx_t_5; __Pyx_INCREF(__pyx_t_6); @@ -101710,7 +105388,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_6)); __pyx_t_6 = 0; - /* "PyCafe.pyx":5770 + /* "PyCafe.pyx":5977 * * bytesVal = pvd[i].getAsString() * encoding = False # <<<<<<<<<<<<<< @@ -101719,21 +105397,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":5771 + /* "PyCafe.pyx":5978 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in pvd[i].getPVName(): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_6 = __Pyx_PyStr_FromString((__pyx_v_pvd[__pyx_v_i]).getPVName()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5771, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString((__pyx_v_pvd[__pyx_v_i]).getPVName()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5978, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_6, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5771, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_6, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5978, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5772 + /* "PyCafe.pyx":5979 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -101749,7 +105427,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_17); /*try:*/ { - /* "PyCafe.pyx":5773 + /* "PyCafe.pyx":5980 * if '.EGU' in pvd[i].getPVName(): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -101758,14 +105436,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 5773, __pyx_L21_error) + __PYX_ERR(3, 5980, __pyx_L21_error) } - __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5773, __pyx_L21_error) + __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5980, __pyx_L21_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5774 + /* "PyCafe.pyx":5981 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -101774,7 +105452,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5772 + /* "PyCafe.pyx":5979 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -101793,7 +105471,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5775 + /* "PyCafe.pyx":5982 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -101808,7 +105486,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L23_except_error; __pyx_L23_except_error:; - /* "PyCafe.pyx":5772 + /* "PyCafe.pyx":5979 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -101828,7 +105506,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_L28_try_end:; } - /* "PyCafe.pyx":5771 + /* "PyCafe.pyx":5978 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in pvd[i].getPVName(): # <<<<<<<<<<<<<< @@ -101837,7 +105515,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5777 + /* "PyCafe.pyx":5984 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -101847,7 +105525,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5778 + /* "PyCafe.pyx":5985 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -101863,7 +105541,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_15); /*try:*/ { - /* "PyCafe.pyx":5779 + /* "PyCafe.pyx":5986 * if not encoding: * try: * strVal = (bytesVal).decode('utf_8') # <<<<<<<<<<<<<< @@ -101872,14 +105550,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 5779, __pyx_L30_error) + __PYX_ERR(3, 5986, __pyx_L30_error) } - __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5779, __pyx_L30_error) + __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5986, __pyx_L30_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5780 + /* "PyCafe.pyx":5987 * try: * strVal = (bytesVal).decode('utf_8') * encoding = True # <<<<<<<<<<<<<< @@ -101888,7 +105566,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5778 + /* "PyCafe.pyx":5985 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -101907,7 +105585,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5781 + /* "PyCafe.pyx":5988 * strVal = (bytesVal).decode('utf_8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -101922,7 +105600,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L32_except_error; __pyx_L32_except_error:; - /* "PyCafe.pyx":5778 + /* "PyCafe.pyx":5985 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -101942,7 +105620,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_L37_try_end:; } - /* "PyCafe.pyx":5777 + /* "PyCafe.pyx":5984 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -101951,7 +105629,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5783 + /* "PyCafe.pyx":5990 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -101961,7 +105639,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5784 + /* "PyCafe.pyx":5991 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -101977,7 +105655,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_17); /*try:*/ { - /* "PyCafe.pyx":5785 + /* "PyCafe.pyx":5992 * if not encoding: * try: * strVal = (bytesVal).decode('utf_16') # <<<<<<<<<<<<<< @@ -101986,14 +105664,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 5785, __pyx_L39_error) + __PYX_ERR(3, 5992, __pyx_L39_error) } - __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5785, __pyx_L39_error) + __pyx_t_6 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5992, __pyx_L39_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5786 + /* "PyCafe.pyx":5993 * try: * strVal = (bytesVal).decode('utf_16') * encoding = True # <<<<<<<<<<<<<< @@ -102002,7 +105680,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5784 + /* "PyCafe.pyx":5991 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -102021,7 +105699,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5787 + /* "PyCafe.pyx":5994 * strVal = (bytesVal).decode('utf_16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -102036,7 +105714,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L41_except_error; __pyx_L41_except_error:; - /* "PyCafe.pyx":5784 + /* "PyCafe.pyx":5991 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -102056,7 +105734,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_L46_try_end:; } - /* "PyCafe.pyx":5783 + /* "PyCafe.pyx":5990 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -102065,7 +105743,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5789 + /* "PyCafe.pyx":5996 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -102075,19 +105753,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5790 + /* "PyCafe.pyx":5997 * pass * if not encoding: * strVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * * localList.append(strVal) #pvd[i].getAsString()) */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5790, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5789 + /* "PyCafe.pyx":5996 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -102096,17 +105774,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5792 + /* "PyCafe.pyx":5999 * strVal = pvd[i].getAsString() * * localList.append(strVal) #pvd[i].getAsString()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 5792, __pyx_L1_error) } - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5792, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 5999, __pyx_L1_error) } + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5999, __pyx_L1_error) - /* "PyCafe.pyx":5767 + /* "PyCafe.pyx":5974 * * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -102116,19 +105794,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_SHORT: - /* "PyCafe.pyx":5794 + /* "PyCafe.pyx":6001 * localList.append(strVal) #pvd[i].getAsString()) * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5794, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5794, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6001, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5793 + /* "PyCafe.pyx":6000 * * localList.append(strVal) #pvd[i].getAsString()) * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -102138,19 +105816,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_FLOAT: - /* "PyCafe.pyx":5796 + /* "PyCafe.pyx":6003 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native */ - __pyx_t_6 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5796, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5796, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6003, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5795 + /* "PyCafe.pyx":6002 * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -102160,7 +105838,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_ENUM: - /* "PyCafe.pyx":5800 + /* "PyCafe.pyx":6007 * # if enum, string taken as native * * if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(), ghandle)): # <<<<<<<<<<<<<< @@ -102170,19 +105848,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_v_self->_c_cafe->isEnum(__pyx_v_self->hh.getHandleFromPVWithinGroup((__pyx_v_pvd[__pyx_v_i]).getPVName(), __pyx_v_ghandle)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5801 + /* "PyCafe.pyx":6008 * * if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(), ghandle)): * localList.append(pvd[i].getAsString()) # <<<<<<<<<<<<<< * else: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5801, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6008, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5801, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6008, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5800 + /* "PyCafe.pyx":6007 * # if enum, string taken as native * * if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(), ghandle)): # <<<<<<<<<<<<<< @@ -102192,7 +105870,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L48; } - /* "PyCafe.pyx":5803 + /* "PyCafe.pyx":6010 * localList.append(pvd[i].getAsString()) * else: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< @@ -102200,14 +105878,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C * elif dtcheck == CAFE_CHAR: */ /*else*/ { - __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5803, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6010, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5803, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6010, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_L48:; - /* "PyCafe.pyx":5797 + /* "PyCafe.pyx":6004 * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -102217,19 +105895,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_CHAR: - /* "PyCafe.pyx":5806 + /* "PyCafe.pyx":6013 * * elif dtcheck == CAFE_CHAR: * localList.append(< unsigned char > pvd[i].getAsChar()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_char(((unsigned char)(__pyx_v_pvd[__pyx_v_i]).getAsChar())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5806, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_char(((unsigned char)(__pyx_v_pvd[__pyx_v_i]).getAsChar())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5806, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6013, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5805 + /* "PyCafe.pyx":6012 * localList.append(pvd[i].getAsLong()) * * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -102239,19 +105917,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_LONG: - /* "PyCafe.pyx":5808 + /* "PyCafe.pyx":6015 * localList.append(< unsigned char > pvd[i].getAsChar()) * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5808, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5808, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6015, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5807 + /* "PyCafe.pyx":6014 * elif dtcheck == CAFE_CHAR: * localList.append(< unsigned char > pvd[i].getAsChar()) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -102261,19 +105939,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_DOUBLE: - /* "PyCafe.pyx":5810 + /* "PyCafe.pyx":6017 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * else: * localList.append(None) # no data */ - __pyx_t_6 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5810, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6017, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5810, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6017, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5809 + /* "PyCafe.pyx":6016 * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -102283,18 +105961,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; default: - /* "PyCafe.pyx":5812 + /* "PyCafe.pyx":6019 * localList.append(pvd[i].getAsDouble()) * else: * localList.append(None) # no data # <<<<<<<<<<<<<< * else: * localListInner = [] */ - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, Py_None); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5812, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, Py_None); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6019, __pyx_L1_error) break; } - /* "PyCafe.pyx":5766 + /* "PyCafe.pyx":5973 * statusList.append(pvd[i].getStatus()) * * if pvd[i].getNelem() == 1: # <<<<<<<<<<<<<< @@ -102304,7 +105982,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L19; } - /* "PyCafe.pyx":5814 + /* "PyCafe.pyx":6021 * localList.append(None) # no data * else: * localListInner = [] # <<<<<<<<<<<<<< @@ -102312,12 +105990,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C * for j in range(0, pvd[i].getNelem()): */ /*else*/ { - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5814, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6021, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_localListInner, ((PyObject*)__pyx_t_6)); __pyx_t_6 = 0; - /* "PyCafe.pyx":5815 + /* "PyCafe.pyx":6022 * else: * localListInner = [] * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -102327,7 +106005,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":5816 + /* "PyCafe.pyx":6023 * localListInner = [] * if dtcheck == CAFE_STRING: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -102339,14 +106017,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) { __pyx_v_j = __pyx_t_19; - /* "PyCafe.pyx":5818 + /* "PyCafe.pyx":6025 * for j in range(0, pvd[i].getNelem()): * * bytesVal = pvd[i].getAsString(j) # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in pvd[i].getPVName(): */ - __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5818, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6025, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __pyx_t_6; __Pyx_INCREF(__pyx_t_5); @@ -102354,7 +106032,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF_SET(__pyx_v_bytesVal, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":5819 + /* "PyCafe.pyx":6026 * * bytesVal = pvd[i].getAsString(j) * encoding = False # <<<<<<<<<<<<<< @@ -102363,21 +106041,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":5820 + /* "PyCafe.pyx":6027 * bytesVal = pvd[i].getAsString(j) * encoding = False * if '.EGU' in pvd[i].getPVName(): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_5 = __Pyx_PyStr_FromString((__pyx_v_pvd[__pyx_v_i]).getPVName()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5820, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyStr_FromString((__pyx_v_pvd[__pyx_v_i]).getPVName()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6027, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5820, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 6027, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5821 + /* "PyCafe.pyx":6028 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -102393,7 +106071,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_15); /*try:*/ { - /* "PyCafe.pyx":5822 + /* "PyCafe.pyx":6029 * if '.EGU' in pvd[i].getPVName(): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< @@ -102402,14 +106080,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 5822, __pyx_L52_error) + __PYX_ERR(3, 6029, __pyx_L52_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5822, __pyx_L52_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeLatin1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6029, __pyx_L52_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5823 + /* "PyCafe.pyx":6030 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -102418,7 +106096,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5821 + /* "PyCafe.pyx":6028 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -102437,7 +106115,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5824 + /* "PyCafe.pyx":6031 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -102452,7 +106130,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L54_except_error; __pyx_L54_except_error:; - /* "PyCafe.pyx":5821 + /* "PyCafe.pyx":6028 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -102472,7 +106150,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_L59_try_end:; } - /* "PyCafe.pyx":5820 + /* "PyCafe.pyx":6027 * bytesVal = pvd[i].getAsString(j) * encoding = False * if '.EGU' in pvd[i].getPVName(): # <<<<<<<<<<<<<< @@ -102481,7 +106159,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5826 + /* "PyCafe.pyx":6033 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -102491,7 +106169,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5827 + /* "PyCafe.pyx":6034 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -102507,7 +106185,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_17); /*try:*/ { - /* "PyCafe.pyx":5828 + /* "PyCafe.pyx":6035 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< @@ -102516,14 +106194,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 5828, __pyx_L61_error) + __PYX_ERR(3, 6035, __pyx_L61_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5828, __pyx_L61_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6035, __pyx_L61_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5829 + /* "PyCafe.pyx":6036 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -102532,7 +106210,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5827 + /* "PyCafe.pyx":6034 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -102551,7 +106229,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5830 + /* "PyCafe.pyx":6037 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -102566,7 +106244,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L63_except_error; __pyx_L63_except_error:; - /* "PyCafe.pyx":5827 + /* "PyCafe.pyx":6034 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -102586,7 +106264,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_L68_try_end:; } - /* "PyCafe.pyx":5826 + /* "PyCafe.pyx":6033 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -102595,7 +106273,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5832 + /* "PyCafe.pyx":6039 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -102605,7 +106283,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5833 + /* "PyCafe.pyx":6040 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -102621,7 +106299,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_15); /*try:*/ { - /* "PyCafe.pyx":5834 + /* "PyCafe.pyx":6041 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< @@ -102630,14 +106308,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_bytesVal == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "decode"); - __PYX_ERR(3, 5834, __pyx_L70_error) + __PYX_ERR(3, 6041, __pyx_L70_error) } - __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5834, __pyx_L70_error) + __pyx_t_5 = __Pyx_decode_bytes(__pyx_v_bytesVal, 0, PY_SSIZE_T_MAX, NULL, NULL, __Pyx_PyUnicode_DecodeUTF16); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6041, __pyx_L70_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5835 + /* "PyCafe.pyx":6042 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -102646,7 +106324,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5833 + /* "PyCafe.pyx":6040 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -102665,7 +106343,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5836 + /* "PyCafe.pyx":6043 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -102680,7 +106358,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L72_except_error; __pyx_L72_except_error:; - /* "PyCafe.pyx":5833 + /* "PyCafe.pyx":6040 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -102700,7 +106378,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_L77_try_end:; } - /* "PyCafe.pyx":5832 + /* "PyCafe.pyx":6039 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -102709,7 +106387,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5838 + /* "PyCafe.pyx":6045 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -102719,19 +106397,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5839 + /* "PyCafe.pyx":6046 * pass * if not encoding: * strVal = pvd[i].getAsString(j) # <<<<<<<<<<<<<< * * localListInner.append(strVal) #pvd[i].getAsString(j)) */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5839, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5838 + /* "PyCafe.pyx":6045 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -102740,18 +106418,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":5841 + /* "PyCafe.pyx":6048 * strVal = pvd[i].getAsString(j) * * localListInner.append(strVal) #pvd[i].getAsString(j)) # <<<<<<<<<<<<<< * * elif dtcheck == CAFE_SHORT: */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 5841, __pyx_L1_error) } - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_v_strVal); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5841, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 6048, __pyx_L1_error) } + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_v_strVal); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6048, __pyx_L1_error) } - /* "PyCafe.pyx":5815 + /* "PyCafe.pyx":6022 * else: * localListInner = [] * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -102761,7 +106439,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_SHORT: - /* "PyCafe.pyx":5844 + /* "PyCafe.pyx":6051 * * elif dtcheck == CAFE_SHORT: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -102773,20 +106451,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) { __pyx_v_j = __pyx_t_19; - /* "PyCafe.pyx":5845 + /* "PyCafe.pyx":6052 * 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()): */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5845, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6052, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5845, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6052, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":5843 + /* "PyCafe.pyx":6050 * localListInner.append(strVal) #pvd[i].getAsString(j)) * * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -102796,7 +106474,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_FLOAT: - /* "PyCafe.pyx":5847 + /* "PyCafe.pyx":6054 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_FLOAT: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -102808,20 +106486,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) { __pyx_v_j = __pyx_t_19; - /* "PyCafe.pyx":5848 + /* "PyCafe.pyx":6055 * elif dtcheck == CAFE_FLOAT: * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsDouble(j)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * */ - __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5848, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6055, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5848, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6055, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":5846 + /* "PyCafe.pyx":6053 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -102831,7 +106509,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_ENUM: - /* "PyCafe.pyx":5851 + /* "PyCafe.pyx":6058 * elif dtcheck == CAFE_ENUM: * * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -102843,7 +106521,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) { __pyx_v_j = __pyx_t_19; - /* "PyCafe.pyx":5853 + /* "PyCafe.pyx":6060 * 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)): # <<<<<<<<<<<<<< @@ -102853,19 +106531,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (__pyx_v_self->_c_cafe->isEnum(__pyx_v_self->hh.getHandleFromPVWithinGroup((__pyx_v_pvd[__pyx_v_i]).getPVName(), __pyx_v_ghandle)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5854 + /* "PyCafe.pyx":6061 * # if enum, string taken as native * if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(), ghandle)): * localListInner.append(pvd[i].getAsString(j)) # <<<<<<<<<<<<<< * else: * localListInner.append(pvd[i].getAsLong(j)) */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5854, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5854, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6061, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5853 + /* "PyCafe.pyx":6060 * 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)): # <<<<<<<<<<<<<< @@ -102875,7 +106553,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L85; } - /* "PyCafe.pyx":5856 + /* "PyCafe.pyx":6063 * localListInner.append(pvd[i].getAsString(j)) * else: * localListInner.append(pvd[i].getAsLong(j)) # <<<<<<<<<<<<<< @@ -102883,15 +106561,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C * elif dtcheck == CAFE_CHAR: */ /*else*/ { - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5856, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6063, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5856, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6063, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_L85:; } - /* "PyCafe.pyx":5849 + /* "PyCafe.pyx":6056 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsDouble(j)) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -102901,7 +106579,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_CHAR: - /* "PyCafe.pyx":5859 + /* "PyCafe.pyx":6066 * * elif dtcheck == CAFE_CHAR: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -102913,20 +106591,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) { __pyx_v_j = __pyx_t_19; - /* "PyCafe.pyx":5861 + /* "PyCafe.pyx":6068 * for j in range(0, pvd[i].getNelem()): * # pvd[i].getAsChar(j)) * localListInner.append(pvd[i].getAsLong(j)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * for j in range(0, pvd[i].getNelem()): */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5861, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6068, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5861, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6068, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":5858 + /* "PyCafe.pyx":6065 * localListInner.append(pvd[i].getAsLong(j)) * * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -102936,7 +106614,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_LONG: - /* "PyCafe.pyx":5863 + /* "PyCafe.pyx":6070 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_LONG: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -102948,20 +106626,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) { __pyx_v_j = __pyx_t_19; - /* "PyCafe.pyx":5864 + /* "PyCafe.pyx":6071 * 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()): */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5864, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6071, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5864, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6071, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":5862 + /* "PyCafe.pyx":6069 * # pvd[i].getAsChar(j)) * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -102971,7 +106649,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_DOUBLE: - /* "PyCafe.pyx":5866 + /* "PyCafe.pyx":6073 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_DOUBLE: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -102983,20 +106661,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) { __pyx_v_j = __pyx_t_19; - /* "PyCafe.pyx":5867 + /* "PyCafe.pyx":6074 * 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()): */ - __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5867, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6074, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5867, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6074, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":5865 + /* "PyCafe.pyx":6072 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -103006,7 +106684,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C break; default: - /* "PyCafe.pyx":5869 + /* "PyCafe.pyx":6076 * localListInner.append(pvd[i].getAsDouble(j)) * else: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -103018,31 +106696,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) { __pyx_v_j = __pyx_t_19; - /* "PyCafe.pyx":5870 + /* "PyCafe.pyx":6077 * else: * for j in range(0, pvd[i].getNelem()): * localListInner.append(None) # no data # <<<<<<<<<<<<<< * localList.append(localListInner) * */ - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, Py_None); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5870, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localListInner, Py_None); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6077, __pyx_L1_error) } break; } - /* "PyCafe.pyx":5871 + /* "PyCafe.pyx":6078 * for j in range(0, pvd[i].getNelem()): * localListInner.append(None) # no data * localList.append(localListInner) # <<<<<<<<<<<<<< * * return localList, status, statusList */ - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_localListInner); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 5871, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_localListInner); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6078, __pyx_L1_error) } __pyx_L19:; } - /* "PyCafe.pyx":5873 + /* "PyCafe.pyx":6080 * localList.append(localListInner) * * return localList, status, statusList # <<<<<<<<<<<<<< @@ -103050,9 +106728,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5873, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5873, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -103067,7 +106745,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5703 + /* "PyCafe.pyx":5910 * * ################################################################################## * def getGroup(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -103099,7 +106777,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_346getGroup(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":5881 +/* "PyCafe.pyx":6088 * ################################################################################## * * def getGroupCache(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -103143,7 +106821,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_349getGroupCache(PyObject *__pyx_v_sel } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getGroupCache") < 0)) __PYX_ERR(3, 5881, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getGroupCache") < 0)) __PYX_ERR(3, 6088, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -103159,13 +106837,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_349getGroupCache(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getGroupCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5881, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getGroupCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6088, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getGroupCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 5881, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 6088, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_348getGroupCache(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_ghandleName, __pyx_v_dt); /* function exit code */ @@ -103215,7 +106893,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC long __pyx_t_17; __Pyx_RefNannySetupContext("getGroupCache", 0); - /* "PyCafe.pyx":5882 + /* "PyCafe.pyx":6089 * * def getGroupCache(self, ghandleName, str dt='native'): * cdef str _METHOD = "getGroupCache(self, ghandleName, str dt='native')" # <<<<<<<<<<<<<< @@ -103225,7 +106903,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_kp_u_getGroupCache_self_ghandleName_s); __pyx_v__METHOD = __pyx_kp_u_getGroupCache_self_ghandleName_s; - /* "PyCafe.pyx":5883 + /* "PyCafe.pyx":6090 * def getGroupCache(self, ghandleName, str dt='native'): * cdef str _METHOD = "getGroupCache(self, ghandleName, str dt='native')" * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -103234,7 +106912,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":5884 + /* "PyCafe.pyx":6091 * cdef str _METHOD = "getGroupCache(self, ghandleName, str dt='native')" * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -103255,17 +106933,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5885 + /* "PyCafe.pyx":6092 * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5885, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6092, __pyx_L1_error) __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5884 + /* "PyCafe.pyx":6091 * cdef str _METHOD = "getGroupCache(self, ghandleName, str dt='native')" * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -103275,7 +106953,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":5886 + /* "PyCafe.pyx":6093 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -103286,21 +106964,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5887 + /* "PyCafe.pyx":6094 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 5887, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5887, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 6094, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6094, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5887, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6094, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":5886 + /* "PyCafe.pyx":6093 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -103310,7 +106988,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":5889 + /* "PyCafe.pyx":6096 * ghandle = self.checkForGroupHandle(ghandleName) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -103318,18 +106996,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC * raise _cafeException */ /*else*/ { - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5889, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6096, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 5889, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 5889, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 5889, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5889, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6096, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6096, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 6096, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6096, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5891 + /* "PyCafe.pyx":6098 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if group handle, else if group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -103337,11 +107015,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC * cdef PVGroup pvg */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 5891, __pyx_L1_error) + __PYX_ERR(3, 6098, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":5895 + /* "PyCafe.pyx":6102 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -103356,7 +107034,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":5896 + /* "PyCafe.pyx":6103 * * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) # <<<<<<<<<<<<<< @@ -103366,7 +107044,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC (void)(__pyx_v_self->_c_cafe->groupAttach(__pyx_v_ghandle, __pyx_v_pvg)); } - /* "PyCafe.pyx":5895 + /* "PyCafe.pyx":6102 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -103385,7 +107063,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":5900 + /* "PyCafe.pyx":6107 * cdef PVDataHolder * pvd * * with nogil: # <<<<<<<<<<<<<< @@ -103400,7 +107078,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":5901 + /* "PyCafe.pyx":6108 * * with nogil: * status = self._c_cafe.groupGetCache(ghandle, pvg) # <<<<<<<<<<<<<< @@ -103410,7 +107088,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_v_status = __pyx_v_self->_c_cafe->groupGetCache(__pyx_v_ghandle, __pyx_v_pvg); } - /* "PyCafe.pyx":5900 + /* "PyCafe.pyx":6107 * cdef PVDataHolder * pvd * * with nogil: # <<<<<<<<<<<<<< @@ -103429,7 +107107,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":5903 + /* "PyCafe.pyx":6110 * status = self._c_cafe.groupGetCache(ghandle, pvg) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -103439,7 +107117,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5904 + /* "PyCafe.pyx":6111 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -103449,7 +107127,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5905 + /* "PyCafe.pyx":6112 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -103458,7 +107136,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":5904 + /* "PyCafe.pyx":6111 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -103467,7 +107145,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5903 + /* "PyCafe.pyx":6110 * status = self._c_cafe.groupGetCache(ghandle, pvg) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -103476,7 +107154,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5910 + /* "PyCafe.pyx":6117 * #raise Exception("EXCEPTION RAISED in PyCafe def getGroup. Status = %d" %status) * * pvd = pvg.getPVData() # <<<<<<<<<<<<<< @@ -103485,31 +107163,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_pvd = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":5912 + /* "PyCafe.pyx":6119 * pvd = pvg.getPVData() * * localList = [] # <<<<<<<<<<<<<< * statusList = [] * cdef unsigned int dtn, dtcheck */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5912, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_localList = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5913 + /* "PyCafe.pyx":6120 * * localList = [] * statusList = [] # <<<<<<<<<<<<<< * cdef unsigned int dtn, dtcheck * cdef bytesVal */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5913, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_statusList = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5917 + /* "PyCafe.pyx":6124 * cdef bytesVal * * for i in range(0, pvg.getNPV()): # <<<<<<<<<<<<<< @@ -103521,7 +107199,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "PyCafe.pyx":5918 + /* "PyCafe.pyx":6125 * * for i in range(0, pvg.getNPV()): * dtn = pvd[i].getDataType() # <<<<<<<<<<<<<< @@ -103530,35 +107208,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_dtn = (__pyx_v_pvd[__pyx_v_i]).getDataType(); - /* "PyCafe.pyx":5920 + /* "PyCafe.pyx":6127 * dtn = pvd[i].getDataType() * * dtcheck = getMatchedDataType(dt, dtn) # <<<<<<<<<<<<<< * * statusList.append(pvd[i].getStatus()) */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5920, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_dtn); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5920, __pyx_L1_error) + __pyx_t_5 = __pyx_f_6PyCafe_getMatchedDataType(__pyx_v_dt, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5920, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6127, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_dtcheck = __pyx_t_9; - /* "PyCafe.pyx":5922 + /* "PyCafe.pyx":6129 * dtcheck = getMatchedDataType(dt, dtn) * * statusList.append(pvd[i].getStatus()) # <<<<<<<<<<<<<< * * if pvd[i].getNelem() == 1: */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5922, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5922, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6129, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5924 + /* "PyCafe.pyx":6131 * statusList.append(pvd[i].getStatus()) * * if pvd[i].getNelem() == 1: # <<<<<<<<<<<<<< @@ -103568,7 +107246,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_1 = (((__pyx_v_pvd[__pyx_v_i]).getNelem() == 1) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5925 + /* "PyCafe.pyx":6132 * * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -103578,14 +107256,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":5927 + /* "PyCafe.pyx":6134 * if dtcheck == CAFE_STRING: * * bytesVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in pvd[i].getPVName(): */ - __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5927, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __pyx_t_5; __Pyx_INCREF(__pyx_t_6); @@ -103593,7 +107271,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_bytesVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5928 + /* "PyCafe.pyx":6135 * * bytesVal = pvd[i].getAsString() * encoding = False # <<<<<<<<<<<<<< @@ -103602,21 +107280,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":5929 + /* "PyCafe.pyx":6136 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in pvd[i].getPVName(): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_6 = __Pyx_PyStr_FromString((__pyx_v_pvd[__pyx_v_i]).getPVName()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5929, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString((__pyx_v_pvd[__pyx_v_i]).getPVName()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_6, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 5929, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_6, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 6136, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5930 + /* "PyCafe.pyx":6137 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -103632,14 +107310,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_13); /*try:*/ { - /* "PyCafe.pyx":5931 + /* "PyCafe.pyx":6138 * if '.EGU' in pvd[i].getPVName(): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5931, __pyx_L18_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6138, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { @@ -103653,13 +107331,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC } __pyx_t_6 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_14, __pyx_kp_u_latin_1) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_u_latin_1); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5931, __pyx_L18_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6138, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5932 + /* "PyCafe.pyx":6139 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -103668,7 +107346,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5930 + /* "PyCafe.pyx":6137 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -103685,7 +107363,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5933 + /* "PyCafe.pyx":6140 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -103700,7 +107378,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L20_except_error; __pyx_L20_except_error:; - /* "PyCafe.pyx":5930 + /* "PyCafe.pyx":6137 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -103720,7 +107398,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_L25_try_end:; } - /* "PyCafe.pyx":5929 + /* "PyCafe.pyx":6136 * bytesVal = pvd[i].getAsString() * encoding = False * if '.EGU' in pvd[i].getPVName(): # <<<<<<<<<<<<<< @@ -103729,7 +107407,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5935 + /* "PyCafe.pyx":6142 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -103739,7 +107417,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5936 + /* "PyCafe.pyx":6143 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -103755,14 +107433,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { - /* "PyCafe.pyx":5937 + /* "PyCafe.pyx":6144 * if not encoding: * try: * strVal = (bytesVal).decode('utf_8') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5937, __pyx_L27_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6144, __pyx_L27_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { @@ -103774,15 +107452,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_DECREF_SET(__pyx_t_5, function); } } - __pyx_t_6 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_14, __pyx_n_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_u_utf_8); + __pyx_t_6 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_14, __pyx_n_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_u_utf_8_2); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5937, __pyx_L27_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6144, __pyx_L27_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5938 + /* "PyCafe.pyx":6145 * try: * strVal = (bytesVal).decode('utf_8') * encoding = True # <<<<<<<<<<<<<< @@ -103791,7 +107469,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5936 + /* "PyCafe.pyx":6143 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -103808,7 +107486,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5939 + /* "PyCafe.pyx":6146 * strVal = (bytesVal).decode('utf_8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -103823,7 +107501,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L29_except_error; __pyx_L29_except_error:; - /* "PyCafe.pyx":5936 + /* "PyCafe.pyx":6143 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -103843,7 +107521,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_L34_try_end:; } - /* "PyCafe.pyx":5935 + /* "PyCafe.pyx":6142 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -103852,7 +107530,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5941 + /* "PyCafe.pyx":6148 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -103862,7 +107540,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5942 + /* "PyCafe.pyx":6149 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -103878,14 +107556,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_13); /*try:*/ { - /* "PyCafe.pyx":5943 + /* "PyCafe.pyx":6150 * if not encoding: * try: * strVal = (bytesVal).decode('utf_16') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5943, __pyx_L36_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6150, __pyx_L36_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { @@ -103897,15 +107575,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_DECREF_SET(__pyx_t_5, function); } } - __pyx_t_6 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_14, __pyx_n_u_utf_16) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_u_utf_16); + __pyx_t_6 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_14, __pyx_n_u_utf_16_2) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_u_utf_16_2); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5943, __pyx_L36_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6150, __pyx_L36_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5944 + /* "PyCafe.pyx":6151 * try: * strVal = (bytesVal).decode('utf_16') * encoding = True # <<<<<<<<<<<<<< @@ -103914,7 +107592,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5942 + /* "PyCafe.pyx":6149 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -103931,7 +107609,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5945 + /* "PyCafe.pyx":6152 * strVal = (bytesVal).decode('utf_16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -103946,7 +107624,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L38_except_error; __pyx_L38_except_error:; - /* "PyCafe.pyx":5942 + /* "PyCafe.pyx":6149 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -103966,7 +107644,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_L43_try_end:; } - /* "PyCafe.pyx":5941 + /* "PyCafe.pyx":6148 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -103975,7 +107653,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5947 + /* "PyCafe.pyx":6154 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -103985,19 +107663,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5948 + /* "PyCafe.pyx":6155 * pass * if not encoding: * strVal = pvd[i].getAsString() # <<<<<<<<<<<<<< * * localList.append(strVal) #pvd[i].getAsString()) */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5948, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5947 + /* "PyCafe.pyx":6154 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -104006,17 +107684,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5950 + /* "PyCafe.pyx":6157 * strVal = pvd[i].getAsString() * * localList.append(strVal) #pvd[i].getAsString()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 5950, __pyx_L1_error) } - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5950, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 6157, __pyx_L1_error) } + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_strVal); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6157, __pyx_L1_error) - /* "PyCafe.pyx":5925 + /* "PyCafe.pyx":6132 * * if pvd[i].getNelem() == 1: * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -104026,19 +107704,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_SHORT: - /* "PyCafe.pyx":5952 + /* "PyCafe.pyx":6159 * localList.append(strVal) #pvd[i].getAsString()) * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5952, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5952, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6159, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5951 + /* "PyCafe.pyx":6158 * * localList.append(strVal) #pvd[i].getAsString()) * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -104048,19 +107726,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_FLOAT: - /* "PyCafe.pyx":5954 + /* "PyCafe.pyx":6161 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * # if enum, string taken as native */ - __pyx_t_6 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5954, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5954, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6161, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5953 + /* "PyCafe.pyx":6160 * elif dtcheck == CAFE_SHORT: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -104070,7 +107748,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_ENUM: - /* "PyCafe.pyx":5958 + /* "PyCafe.pyx":6165 * # if enum, string taken as native * * if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(), ghandle)): # <<<<<<<<<<<<<< @@ -104080,19 +107758,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_2 = (__pyx_v_self->_c_cafe->isEnum(__pyx_v_self->hh.getHandleFromPVWithinGroup((__pyx_v_pvd[__pyx_v_i]).getPVName(), __pyx_v_ghandle)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":5959 + /* "PyCafe.pyx":6166 * * if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(), ghandle)): * localList.append(pvd[i].getAsString()) # <<<<<<<<<<<<<< * else: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5959, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5959, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6166, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5958 + /* "PyCafe.pyx":6165 * # if enum, string taken as native * * if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(), ghandle)): # <<<<<<<<<<<<<< @@ -104102,7 +107780,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L45; } - /* "PyCafe.pyx":5961 + /* "PyCafe.pyx":6168 * localList.append(pvd[i].getAsString()) * else: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< @@ -104110,14 +107788,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC * elif dtcheck == CAFE_CHAR: */ /*else*/ { - __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5961, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5961, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6168, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_L45:; - /* "PyCafe.pyx":5955 + /* "PyCafe.pyx":6162 * elif dtcheck == CAFE_FLOAT: * localList.append(pvd[i].getAsDouble()) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -104127,19 +107805,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_CHAR: - /* "PyCafe.pyx":5964 + /* "PyCafe.pyx":6171 * * elif dtcheck == CAFE_CHAR: * localList.append(< unsigned char > pvd[i].getAsChar()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_char(((unsigned char)(__pyx_v_pvd[__pyx_v_i]).getAsChar())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5964, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_char(((unsigned char)(__pyx_v_pvd[__pyx_v_i]).getAsChar())); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5964, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6171, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5963 + /* "PyCafe.pyx":6170 * localList.append(pvd[i].getAsLong()) * * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -104149,19 +107827,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_LONG: - /* "PyCafe.pyx":5966 + /* "PyCafe.pyx":6173 * localList.append(< unsigned char > pvd[i].getAsChar()) * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) */ - __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5966, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6173, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5966, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6173, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5965 + /* "PyCafe.pyx":6172 * elif dtcheck == CAFE_CHAR: * localList.append(< unsigned char > pvd[i].getAsChar()) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -104171,19 +107849,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_DOUBLE: - /* "PyCafe.pyx":5968 + /* "PyCafe.pyx":6175 * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: * localList.append(pvd[i].getAsDouble()) # <<<<<<<<<<<<<< * else: * localList.append(None) # no data */ - __pyx_t_6 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5968, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5968, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6175, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":5967 + /* "PyCafe.pyx":6174 * elif dtcheck == CAFE_LONG: * localList.append(pvd[i].getAsLong()) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -104193,18 +107871,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; default: - /* "PyCafe.pyx":5970 + /* "PyCafe.pyx":6177 * localList.append(pvd[i].getAsDouble()) * else: * localList.append(None) # no data # <<<<<<<<<<<<<< * else: * localListInner = [] */ - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, Py_None); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5970, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, Py_None); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6177, __pyx_L1_error) break; } - /* "PyCafe.pyx":5924 + /* "PyCafe.pyx":6131 * statusList.append(pvd[i].getStatus()) * * if pvd[i].getNelem() == 1: # <<<<<<<<<<<<<< @@ -104214,7 +107892,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L16; } - /* "PyCafe.pyx":5972 + /* "PyCafe.pyx":6179 * localList.append(None) # no data * else: * localListInner = [] # <<<<<<<<<<<<<< @@ -104222,12 +107900,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC * for j in range(0, pvd[i].getNelem()): */ /*else*/ { - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5972, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_localListInner, ((PyObject*)__pyx_t_6)); __pyx_t_6 = 0; - /* "PyCafe.pyx":5973 + /* "PyCafe.pyx":6180 * else: * localListInner = [] * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -104237,7 +107915,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC switch (__pyx_v_dtcheck) { case CAFE_STRING: - /* "PyCafe.pyx":5974 + /* "PyCafe.pyx":6181 * localListInner = [] * if dtcheck == CAFE_STRING: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -104249,14 +107927,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_j = __pyx_t_17; - /* "PyCafe.pyx":5976 + /* "PyCafe.pyx":6183 * for j in range(0, pvd[i].getNelem()): * * bytesVal = pvd[i].getAsString(j) # <<<<<<<<<<<<<< * encoding = False * if '.EGU' in pvd[i].getPVName(): */ - __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5976, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __pyx_t_6; __Pyx_INCREF(__pyx_t_5); @@ -104264,7 +107942,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XDECREF_SET(__pyx_v_bytesVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5977 + /* "PyCafe.pyx":6184 * * bytesVal = pvd[i].getAsString(j) * encoding = False # <<<<<<<<<<<<<< @@ -104273,21 +107951,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":5978 + /* "PyCafe.pyx":6185 * bytesVal = pvd[i].getAsString(j) * encoding = False * if '.EGU' in pvd[i].getPVName(): # <<<<<<<<<<<<<< * try: * strVal = (bytesVal).decode('latin-1') */ - __pyx_t_5 = __Pyx_PyStr_FromString((__pyx_v_pvd[__pyx_v_i]).getPVName()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5978, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyStr_FromString((__pyx_v_pvd[__pyx_v_i]).getPVName()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6185, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 5978, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_kp_u_EGU, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 6185, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5979 + /* "PyCafe.pyx":6186 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -104303,14 +107981,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { - /* "PyCafe.pyx":5980 + /* "PyCafe.pyx":6187 * if '.EGU' in pvd[i].getPVName(): * try: * strVal = (bytesVal).decode('latin-1') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5980, __pyx_L49_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6187, __pyx_L49_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -104324,13 +108002,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC } __pyx_t_5 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_14, __pyx_kp_u_latin_1) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_latin_1); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5980, __pyx_L49_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6187, __pyx_L49_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5981 + /* "PyCafe.pyx":6188 * try: * strVal = (bytesVal).decode('latin-1') * encoding = True # <<<<<<<<<<<<<< @@ -104339,7 +108017,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5979 + /* "PyCafe.pyx":6186 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -104356,7 +108034,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5982 + /* "PyCafe.pyx":6189 * strVal = (bytesVal).decode('latin-1') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -104371,7 +108049,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L51_except_error; __pyx_L51_except_error:; - /* "PyCafe.pyx":5979 + /* "PyCafe.pyx":6186 * encoding = False * if '.EGU' in pvd[i].getPVName(): * try: # <<<<<<<<<<<<<< @@ -104391,7 +108069,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_L56_try_end:; } - /* "PyCafe.pyx":5978 + /* "PyCafe.pyx":6185 * bytesVal = pvd[i].getAsString(j) * encoding = False * if '.EGU' in pvd[i].getPVName(): # <<<<<<<<<<<<<< @@ -104400,7 +108078,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5984 + /* "PyCafe.pyx":6191 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -104410,7 +108088,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5985 + /* "PyCafe.pyx":6192 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -104426,14 +108104,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_13); /*try:*/ { - /* "PyCafe.pyx":5986 + /* "PyCafe.pyx":6193 * if not encoding: * try: * strVal = (bytesVal).decode('utf-8') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5986, __pyx_L58_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6193, __pyx_L58_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -104445,15 +108123,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_5 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_14, __pyx_kp_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_utf_8_2); + __pyx_t_5 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_14, __pyx_kp_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_utf_8); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5986, __pyx_L58_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6193, __pyx_L58_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5987 + /* "PyCafe.pyx":6194 * try: * strVal = (bytesVal).decode('utf-8') * encoding = True # <<<<<<<<<<<<<< @@ -104462,7 +108140,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5985 + /* "PyCafe.pyx":6192 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -104479,7 +108157,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5988 + /* "PyCafe.pyx":6195 * strVal = (bytesVal).decode('utf-8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -104494,7 +108172,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L60_except_error; __pyx_L60_except_error:; - /* "PyCafe.pyx":5985 + /* "PyCafe.pyx":6192 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -104514,7 +108192,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_L65_try_end:; } - /* "PyCafe.pyx":5984 + /* "PyCafe.pyx":6191 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -104523,7 +108201,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5990 + /* "PyCafe.pyx":6197 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -104533,7 +108211,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5991 + /* "PyCafe.pyx":6198 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -104549,14 +108227,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { - /* "PyCafe.pyx":5992 + /* "PyCafe.pyx":6199 * if not encoding: * try: * strVal = (bytesVal).decode('utf-16') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 5992, __pyx_L67_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytesVal, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6199, __pyx_L67_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -104568,15 +108246,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_5 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_14, __pyx_kp_u_utf_16_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_utf_16_2); + __pyx_t_5 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_14, __pyx_kp_u_utf_16) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_utf_16); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5992, __pyx_L67_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6199, __pyx_L67_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5993 + /* "PyCafe.pyx":6200 * try: * strVal = (bytesVal).decode('utf-16') * encoding = True # <<<<<<<<<<<<<< @@ -104585,7 +108263,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":5991 + /* "PyCafe.pyx":6198 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -104602,7 +108280,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5994 + /* "PyCafe.pyx":6201 * strVal = (bytesVal).decode('utf-16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -104617,7 +108295,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L69_except_error; __pyx_L69_except_error:; - /* "PyCafe.pyx":5991 + /* "PyCafe.pyx":6198 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -104637,7 +108315,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_L74_try_end:; } - /* "PyCafe.pyx":5990 + /* "PyCafe.pyx":6197 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -104646,7 +108324,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5996 + /* "PyCafe.pyx":6203 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -104656,19 +108334,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_1 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":5997 + /* "PyCafe.pyx":6204 * pass * if not encoding: * strVal = pvd[i].getAsString(j) # <<<<<<<<<<<<<< * * localListInner.append(strVal) #pvd[i].getAsString(j)) */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 5997, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_strVal, __pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":5996 + /* "PyCafe.pyx":6203 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -104677,18 +108355,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":5999 + /* "PyCafe.pyx":6206 * strVal = pvd[i].getAsString(j) * * localListInner.append(strVal) #pvd[i].getAsString(j)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_SHORT: * for j in range(0, pvd[i].getNelem()): */ - if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 5999, __pyx_L1_error) } - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_v_strVal); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 5999, __pyx_L1_error) + if (unlikely(!__pyx_v_strVal)) { __Pyx_RaiseUnboundLocalError("strVal"); __PYX_ERR(3, 6206, __pyx_L1_error) } + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_v_strVal); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6206, __pyx_L1_error) } - /* "PyCafe.pyx":5973 + /* "PyCafe.pyx":6180 * else: * localListInner = [] * if dtcheck == CAFE_STRING: # <<<<<<<<<<<<<< @@ -104698,7 +108376,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_SHORT: - /* "PyCafe.pyx":6001 + /* "PyCafe.pyx":6208 * localListInner.append(strVal) #pvd[i].getAsString(j)) * elif dtcheck == CAFE_SHORT: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -104710,20 +108388,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_j = __pyx_t_17; - /* "PyCafe.pyx":6002 + /* "PyCafe.pyx":6209 * 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()): */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6002, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6002, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6209, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":6000 + /* "PyCafe.pyx":6207 * * localListInner.append(strVal) #pvd[i].getAsString(j)) * elif dtcheck == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -104733,7 +108411,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_FLOAT: - /* "PyCafe.pyx":6004 + /* "PyCafe.pyx":6211 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_FLOAT: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -104745,20 +108423,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_j = __pyx_t_17; - /* "PyCafe.pyx":6005 + /* "PyCafe.pyx":6212 * elif dtcheck == CAFE_FLOAT: * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsDouble(j)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_ENUM: * */ - __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6005, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6005, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6212, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":6003 + /* "PyCafe.pyx":6210 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -104768,7 +108446,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_ENUM: - /* "PyCafe.pyx":6008 + /* "PyCafe.pyx":6215 * elif dtcheck == CAFE_ENUM: * * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -104780,7 +108458,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_j = __pyx_t_17; - /* "PyCafe.pyx":6010 + /* "PyCafe.pyx":6217 * 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)): # <<<<<<<<<<<<<< @@ -104790,19 +108468,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_1 = (__pyx_v_self->_c_cafe->isEnum(__pyx_v_self->hh.getHandleFromPVWithinGroup((__pyx_v_pvd[__pyx_v_i]).getPVName(), __pyx_v_ghandle)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6011 + /* "PyCafe.pyx":6218 * # if enum, string taken as native * if self._c_cafe.isEnum(self.hh.getHandleFromPVWithinGroup(pvd[i].getPVName(), ghandle)): * localListInner.append(pvd[i].getAsString(j)) # <<<<<<<<<<<<<< * else: * localListInner.append(pvd[i].getAsLong(j)) */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6011, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string((__pyx_v_pvd[__pyx_v_i]).getAsString(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6011, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6218, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6010 + /* "PyCafe.pyx":6217 * 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)): # <<<<<<<<<<<<<< @@ -104812,7 +108490,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC goto __pyx_L82; } - /* "PyCafe.pyx":6013 + /* "PyCafe.pyx":6220 * localListInner.append(pvd[i].getAsString(j)) * else: * localListInner.append(pvd[i].getAsLong(j)) # <<<<<<<<<<<<<< @@ -104820,15 +108498,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC * elif dtcheck == CAFE_CHAR: */ /*else*/ { - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6013, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6013, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6220, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_L82:; } - /* "PyCafe.pyx":6006 + /* "PyCafe.pyx":6213 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsDouble(j)) * elif dtcheck == CAFE_ENUM: # <<<<<<<<<<<<<< @@ -104838,7 +108516,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_CHAR: - /* "PyCafe.pyx":6016 + /* "PyCafe.pyx":6223 * * elif dtcheck == CAFE_CHAR: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -104850,20 +108528,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_j = __pyx_t_17; - /* "PyCafe.pyx":6018 + /* "PyCafe.pyx":6225 * for j in range(0, pvd[i].getNelem()): * # pvd[i].getAsChar(j)) * localListInner.append(pvd[i].getAsLong(j)) # <<<<<<<<<<<<<< * elif dtcheck == CAFE_LONG: * for j in range(0, pvd[i].getNelem()): */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6018, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6018, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6225, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":6015 + /* "PyCafe.pyx":6222 * localListInner.append(pvd[i].getAsLong(j)) * * elif dtcheck == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -104873,7 +108551,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_LONG: - /* "PyCafe.pyx":6020 + /* "PyCafe.pyx":6227 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_LONG: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -104885,20 +108563,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_j = __pyx_t_17; - /* "PyCafe.pyx":6021 + /* "PyCafe.pyx":6228 * 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()): */ - __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6021, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getAsLong(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6021, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6228, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":6019 + /* "PyCafe.pyx":6226 * # pvd[i].getAsChar(j)) * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_LONG: # <<<<<<<<<<<<<< @@ -104908,7 +108586,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; case CAFE_DOUBLE: - /* "PyCafe.pyx":6023 + /* "PyCafe.pyx":6230 * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_DOUBLE: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -104920,20 +108598,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_j = __pyx_t_17; - /* "PyCafe.pyx":6024 + /* "PyCafe.pyx":6231 * 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()): */ - __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6024, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_pvd[__pyx_v_i]).getAsDouble(__pyx_v_j)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6024, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, __pyx_t_5); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6231, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":6022 + /* "PyCafe.pyx":6229 * for j in range(0, pvd[i].getNelem()): * localListInner.append(pvd[i].getAsLong(j)) * elif dtcheck == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -104943,7 +108621,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC break; default: - /* "PyCafe.pyx":6026 + /* "PyCafe.pyx":6233 * localListInner.append(pvd[i].getAsDouble(j)) * else: * for j in range(0, pvd[i].getNelem()): # <<<<<<<<<<<<<< @@ -104955,31 +108633,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_j = __pyx_t_17; - /* "PyCafe.pyx":6027 + /* "PyCafe.pyx":6234 * else: * for j in range(0, pvd[i].getNelem()): * localListInner.append(None) # no data # <<<<<<<<<<<<<< * localList.append(localListInner) * */ - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, Py_None); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6027, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localListInner, Py_None); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6234, __pyx_L1_error) } break; } - /* "PyCafe.pyx":6028 + /* "PyCafe.pyx":6235 * for j in range(0, pvd[i].getNelem()): * localListInner.append(None) # no data * localList.append(localListInner) # <<<<<<<<<<<<<< * * return localList, status, statusList */ - __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_localListInner); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6028, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_v_localListInner); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(3, 6235, __pyx_L1_error) } __pyx_L16:; } - /* "PyCafe.pyx":6030 + /* "PyCafe.pyx":6237 * localList.append(localListInner) * * return localList, status, statusList # <<<<<<<<<<<<<< @@ -104987,9 +108665,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6030, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6030, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_v_localList); __Pyx_GIVEREF(__pyx_v_localList); @@ -105004,7 +108682,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":5881 + /* "PyCafe.pyx":6088 * ################################################################################## * * def getGroupCache(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -105034,7 +108712,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_348getGroupCache(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":6038 +/* "PyCafe.pyx":6245 * ################################################################################## * * def getPVGroupStr(self, ghandleName): # <<<<<<<<<<<<<< @@ -105064,7 +108742,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_350getPVGroupStr(struct __pyx_obj_6PyC PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getPVGroupStr", 0); - /* "PyCafe.pyx":6039 + /* "PyCafe.pyx":6246 * * def getPVGroupStr(self, ghandleName): * return self.getPVGroup(ghandleName, dt='str') # <<<<<<<<<<<<<< @@ -105072,17 +108750,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_350getPVGroupStr(struct __pyx_obj_6PyC * def getPVGroupInt(self, ghandleName): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVGroup); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6039, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVGroup); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6039, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_ghandleName); __Pyx_GIVEREF(__pyx_v_ghandleName); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_ghandleName); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6039, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 6039, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6039, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_str) < 0) __PYX_ERR(3, 6246, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -105091,7 +108769,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_350getPVGroupStr(struct __pyx_obj_6PyC __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6038 + /* "PyCafe.pyx":6245 * ################################################################################## * * def getPVGroupStr(self, ghandleName): # <<<<<<<<<<<<<< @@ -105115,7 +108793,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_350getPVGroupStr(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":6041 +/* "PyCafe.pyx":6248 * return self.getPVGroup(ghandleName, dt='str') * * def getPVGroupInt(self, ghandleName): # <<<<<<<<<<<<<< @@ -105145,7 +108823,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_352getPVGroupInt(struct __pyx_obj_6PyC PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getPVGroupInt", 0); - /* "PyCafe.pyx":6042 + /* "PyCafe.pyx":6249 * * def getPVGroupInt(self, ghandleName): * return self.getPVGroup(ghandleName, dt='int') # <<<<<<<<<<<<<< @@ -105153,17 +108831,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_352getPVGroupInt(struct __pyx_obj_6PyC * def getPVGroupFloat(self, ghandleName): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVGroup); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6042, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVGroup); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6042, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_ghandleName); __Pyx_GIVEREF(__pyx_v_ghandleName); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_ghandleName); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6042, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 6042, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6042, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_int) < 0) __PYX_ERR(3, 6249, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -105172,7 +108850,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_352getPVGroupInt(struct __pyx_obj_6PyC __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6041 + /* "PyCafe.pyx":6248 * return self.getPVGroup(ghandleName, dt='str') * * def getPVGroupInt(self, ghandleName): # <<<<<<<<<<<<<< @@ -105196,7 +108874,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_352getPVGroupInt(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":6044 +/* "PyCafe.pyx":6251 * return self.getPVGroup(ghandleName, dt='int') * * def getPVGroupFloat(self, ghandleName): # <<<<<<<<<<<<<< @@ -105226,7 +108904,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_354getPVGroupFloat(struct __pyx_obj_6P PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("getPVGroupFloat", 0); - /* "PyCafe.pyx":6045 + /* "PyCafe.pyx":6252 * * def getPVGroupFloat(self, ghandleName): * return self.getPVGroup(ghandleName, dt='float') # <<<<<<<<<<<<<< @@ -105234,17 +108912,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_354getPVGroupFloat(struct __pyx_obj_6P * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVGroup); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6045, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPVGroup); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6045, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_ghandleName); __Pyx_GIVEREF(__pyx_v_ghandleName); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_ghandleName); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6045, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 6045, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6045, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dt, __pyx_n_u_float) < 0) __PYX_ERR(3, 6252, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -105253,7 +108931,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_354getPVGroupFloat(struct __pyx_obj_6P __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6044 + /* "PyCafe.pyx":6251 * return self.getPVGroup(ghandleName, dt='int') * * def getPVGroupFloat(self, ghandleName): # <<<<<<<<<<<<<< @@ -105277,7 +108955,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_354getPVGroupFloat(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":6048 +/* "PyCafe.pyx":6255 * * ################################################################################## * def getPVGroup(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -105321,7 +108999,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_357getPVGroup(PyObject *__pyx_v_self, } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPVGroup") < 0)) __PYX_ERR(3, 6048, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPVGroup") < 0)) __PYX_ERR(3, 6255, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -105337,13 +109015,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_357getPVGroup(PyObject *__pyx_v_self, } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getPVGroup", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6048, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getPVGroup", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6255, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getPVGroup", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 6048, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 6255, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_356getPVGroup(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_ghandleName, __pyx_v_dt); /* function exit code */ @@ -105383,7 +109061,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe int __pyx_t_14; __Pyx_RefNannySetupContext("getPVGroup", 0); - /* "PyCafe.pyx":6049 + /* "PyCafe.pyx":6256 * ################################################################################## * def getPVGroup(self, ghandleName, str dt='native'): * cdef str _METHOD = "getPVGroup(ghandleName, str dt='native')" # <<<<<<<<<<<<<< @@ -105393,7 +109071,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __Pyx_INCREF(__pyx_kp_u_getPVGroup_ghandleName_str_dt_na); __pyx_v__METHOD = __pyx_kp_u_getPVGroup_ghandleName_str_dt_na; - /* "PyCafe.pyx":6051 + /* "PyCafe.pyx":6258 * cdef str _METHOD = "getPVGroup(ghandleName, str dt='native')" * * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -105402,7 +109080,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":6052 + /* "PyCafe.pyx":6259 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -105423,17 +109101,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6053 + /* "PyCafe.pyx":6260 * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6053, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6260, __pyx_L1_error) __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":6052 + /* "PyCafe.pyx":6259 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -105443,7 +109121,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe goto __pyx_L3; } - /* "PyCafe.pyx":6054 + /* "PyCafe.pyx":6261 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -105454,21 +109132,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6055 + /* "PyCafe.pyx":6262 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) # <<<<<<<<<<<<<< * # elif isinstance(ghandleName, (pvgroup)) == 1: * # print ("We have a PV Group ", type(ghandleName) ) */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 6055, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6055, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 6262, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6055, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6262, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":6054 + /* "PyCafe.pyx":6261 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -105478,7 +109156,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe goto __pyx_L3; } - /* "PyCafe.pyx":6059 + /* "PyCafe.pyx":6266 * # print ("We have a PV Group ", type(ghandleName) ) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -105486,18 +109164,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe * raise _cafeException */ /*else*/ { - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6059, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6059, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6059, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 6059, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6059, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6266, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6266, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 6266, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6061 + /* "PyCafe.pyx":6268 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if group handle, else if group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -105505,11 +109183,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe * cdef PVGroup pvg */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6061, __pyx_L1_error) + __PYX_ERR(3, 6268, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":6067 + /* "PyCafe.pyx":6274 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -105524,7 +109202,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6068 + /* "PyCafe.pyx":6275 * * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) # <<<<<<<<<<<<<< @@ -105534,7 +109212,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe (void)(__pyx_v_self->_c_cafe->groupAttach(__pyx_v_ghandle, __pyx_v_pvg)); } - /* "PyCafe.pyx":6067 + /* "PyCafe.pyx":6274 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -105553,7 +109231,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe } } - /* "PyCafe.pyx":6070 + /* "PyCafe.pyx":6277 * self._c_cafe.groupAttach(ghandle, pvg) * * pvd = pvg.getPVData() # <<<<<<<<<<<<<< @@ -105562,7 +109240,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ __pyx_v_pvd = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":6081 + /* "PyCafe.pyx":6288 * ''' * * with nogil: # <<<<<<<<<<<<<< @@ -105577,7 +109255,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6082 + /* "PyCafe.pyx":6289 * * with nogil: * status = self._c_cafe.groupGet(ghandle, pvg) # <<<<<<<<<<<<<< @@ -105587,7 +109265,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __pyx_v_status = __pyx_v_self->_c_cafe->groupGet(__pyx_v_ghandle, __pyx_v_pvg); } - /* "PyCafe.pyx":6081 + /* "PyCafe.pyx":6288 * ''' * * with nogil: # <<<<<<<<<<<<<< @@ -105606,7 +109284,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe } } - /* "PyCafe.pyx":6084 + /* "PyCafe.pyx":6291 * status = self._c_cafe.groupGet(ghandle, pvg) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -105616,7 +109294,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6085 + /* "PyCafe.pyx":6292 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -105626,24 +109304,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6086 + /* "PyCafe.pyx":6293 * 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 */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6086, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyUnicode_Format(__pyx_kp_u_Error_in_PyCafe_def_getPVGroup_S, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6086, __pyx_L1_error) + __pyx_t_5 = PyUnicode_Format(__pyx_kp_u_Error_in_PyCafe_def_getPVGroup_S, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6086, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6087 + /* "PyCafe.pyx":6294 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in PyCafe def getPVGroup. Status = %d" % status) * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -105652,7 +109330,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6085 + /* "PyCafe.pyx":6292 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -105661,7 +109339,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":6084 + /* "PyCafe.pyx":6291 * status = self._c_cafe.groupGet(ghandle, pvg) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -105670,7 +109348,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":6091 + /* "PyCafe.pyx":6298 * #raise Exception("EXCEPTION RAISED in PyCafe def getPVGroup. Status = %d" %status) * * if status == ECA_TIMEOUT: # <<<<<<<<<<<<<< @@ -105680,40 +109358,40 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_status == ECA_TIMEOUT) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6092 + /* "PyCafe.pyx":6299 * * if status == ECA_TIMEOUT: * print("======================================================") # <<<<<<<<<<<<<< * print("TIMEOUT in getGroup; swithing to getCompoundPVGroup") * print("======================================================") */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__107, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6092, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__102, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6093 + /* "PyCafe.pyx":6300 * if status == ECA_TIMEOUT: * print("======================================================") * print("TIMEOUT in getGroup; swithing to getCompoundPVGroup") # <<<<<<<<<<<<<< * print("======================================================") * return self.getCompoundPVGroup(ghandle, dt) */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__109, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6093, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__104, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6094 + /* "PyCafe.pyx":6301 * print("======================================================") * print("TIMEOUT in getGroup; swithing to getCompoundPVGroup") * print("======================================================") # <<<<<<<<<<<<<< * return self.getCompoundPVGroup(ghandle, dt) * */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__107, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6094, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__102, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6095 + /* "PyCafe.pyx":6302 * print("TIMEOUT in getGroup; swithing to getCompoundPVGroup") * print("======================================================") * return self.getCompoundPVGroup(ghandle, dt) # <<<<<<<<<<<<<< @@ -105721,9 +109399,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe * pvd = pvg.getPVData() */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCompoundPVGroup); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6095, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCompoundPVGroup); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6095, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; @@ -105740,7 +109418,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_v_dt}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6095, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6302, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -105749,14 +109427,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_v_dt}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6095, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6302, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { - __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6095, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -105767,7 +109445,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __Pyx_GIVEREF(__pyx_v_dt); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_v_dt); __pyx_t_7 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6095, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } @@ -105776,7 +109454,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6091 + /* "PyCafe.pyx":6298 * #raise Exception("EXCEPTION RAISED in PyCafe def getPVGroup. Status = %d" %status) * * if status == ECA_TIMEOUT: # <<<<<<<<<<<<<< @@ -105785,7 +109463,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":6097 + /* "PyCafe.pyx":6304 * return self.getCompoundPVGroup(ghandle, dt) * * pvd = pvg.getPVData() # <<<<<<<<<<<<<< @@ -105794,19 +109472,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ __pyx_v_pvd = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":6099 + /* "PyCafe.pyx":6306 * pvd = pvg.getPVData() * * localList = [] # <<<<<<<<<<<<<< * * for i in range(0, pvg.getNPV()): */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6099, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_localList = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6101 + /* "PyCafe.pyx":6308 * localList = [] * * for i in range(0, pvg.getNPV()): # <<<<<<<<<<<<<< @@ -105818,7 +109496,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; - /* "PyCafe.pyx":6104 + /* "PyCafe.pyx":6311 * #print(pvd[i].getAsString(0), " " , pvd[i].getStatus()) * #print(pvd[i].getEpicsTimeStampAsUInt32().secPastEpoch, " ", pvd[i].getEpicsTimeStampAsUInt32().nsec) * localList.append(PVDataHolderToStruct(pvd[i], dt)) # <<<<<<<<<<<<<< @@ -105827,25 +109505,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ __pyx_t_13.__pyx_n = 1; __pyx_t_13.dt = __pyx_v_dt; - __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct((__pyx_v_pvd[__pyx_v_i]), &__pyx_t_13)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6104, __pyx_L1_error) + __pyx_t_6 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct((__pyx_v_pvd[__pyx_v_i]), &__pyx_t_13)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6104, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 6311, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } - /* "PyCafe.pyx":6107 + /* "PyCafe.pyx":6314 * cpdef pvgroup pg * * pg = pvgroup() # <<<<<<<<<<<<<< * * pg.pvdata = localList */ - __pyx_t_6 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvgroup)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6107, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvgroup)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_pg = ((struct __pyx_obj_6PyCafe_pvgroup *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6109 + /* "PyCafe.pyx":6316 * pg = pvgroup() * * pg.pvdata = localList # <<<<<<<<<<<<<< @@ -105858,7 +109536,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __Pyx_DECREF(__pyx_v_pg->pvdata); __pyx_v_pg->pvdata = __pyx_v_localList; - /* "PyCafe.pyx":6111 + /* "PyCafe.pyx":6318 * pg.pvdata = localList * * pg.npv = pvg.getNPV() # <<<<<<<<<<<<<< @@ -105867,7 +109545,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ __pyx_v_pg->npv = __pyx_v_pvg.getNPV(); - /* "PyCafe.pyx":6112 + /* "PyCafe.pyx":6319 * * pg.npv = pvg.getNPV() * pg.name = pvg.getNameAsString() # <<<<<<<<<<<<<< @@ -105876,7 +109554,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ __pyx_v_pg->name = __pyx_v_pvg.getNameAsString(); - /* "PyCafe.pyx":6113 + /* "PyCafe.pyx":6320 * pg.npv = pvg.getNPV() * pg.name = pvg.getNameAsString() * pg.groupStatus = pvg.getStatusGroup() # <<<<<<<<<<<<<< @@ -105885,7 +109563,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ __pyx_v_pg->groupStatus = __pyx_v_pvg.getStatusGroup(); - /* "PyCafe.pyx":6114 + /* "PyCafe.pyx":6321 * pg.name = pvg.getNameAsString() * pg.groupStatus = pvg.getStatusGroup() * pg.groupHandle = pvg.getGroupHandle() # <<<<<<<<<<<<<< @@ -105894,7 +109572,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe */ __pyx_v_pg->groupHandle = __pyx_v_pvg.getGroupHandle(); - /* "PyCafe.pyx":6118 + /* "PyCafe.pyx":6325 * # pg.showMax(1) * * return pg # localList, status # <<<<<<<<<<<<<< @@ -105906,7 +109584,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe __pyx_r = ((PyObject *)__pyx_v_pg); goto __pyx_L0; - /* "PyCafe.pyx":6048 + /* "PyCafe.pyx":6255 * * ################################################################################## * def getPVGroup(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -105935,7 +109613,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_356getPVGroup(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":6125 +/* "PyCafe.pyx":6332 * ################################################################################## * * def getPVGroupCache(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -105979,7 +109657,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_359getPVGroupCache(PyObject *__pyx_v_s } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPVGroupCache") < 0)) __PYX_ERR(3, 6125, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getPVGroupCache") < 0)) __PYX_ERR(3, 6332, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -105995,13 +109673,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_359getPVGroupCache(PyObject *__pyx_v_s } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("getPVGroupCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6125, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("getPVGroupCache", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6332, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.getPVGroupCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 6125, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dt), (&PyUnicode_Type), 1, "dt", 1))) __PYX_ERR(3, 6332, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_ghandleName, __pyx_v_dt); /* function exit code */ @@ -106038,7 +109716,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P int __pyx_t_11; __Pyx_RefNannySetupContext("getPVGroupCache", 0); - /* "PyCafe.pyx":6126 + /* "PyCafe.pyx":6333 * * def getPVGroupCache(self, ghandleName, str dt='native'): * cdef str _METHOD = "getPVGroupCache" # <<<<<<<<<<<<<< @@ -106048,7 +109726,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P __Pyx_INCREF(__pyx_n_u_getPVGroupCache); __pyx_v__METHOD = __pyx_n_u_getPVGroupCache; - /* "PyCafe.pyx":6128 + /* "PyCafe.pyx":6335 * cdef str _METHOD = "getPVGroupCache" * * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -106057,7 +109735,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":6129 + /* "PyCafe.pyx":6336 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -106078,17 +109756,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6130 + /* "PyCafe.pyx":6337 * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6130, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6337, __pyx_L1_error) __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":6129 + /* "PyCafe.pyx":6336 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -106098,7 +109776,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P goto __pyx_L3; } - /* "PyCafe.pyx":6131 + /* "PyCafe.pyx":6338 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -106109,21 +109787,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6132 + /* "PyCafe.pyx":6339 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) # <<<<<<<<<<<<<< * # elif isinstance(ghandleName, (pvgroup)) == 1: * # print ("We have a PV Group ", type(ghandleName) ) */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 6132, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6132, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 6339, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6132, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6339, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":6131 + /* "PyCafe.pyx":6338 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -106133,7 +109811,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P goto __pyx_L3; } - /* "PyCafe.pyx":6136 + /* "PyCafe.pyx":6343 * # print ("We have a PV Group ", type(ghandleName) ) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -106141,18 +109819,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P * raise _cafeException */ /*else*/ { - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6136, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6136, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6136, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 6136, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6136, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6343, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6343, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 6343, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6138 + /* "PyCafe.pyx":6345 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if group handle, else if group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -106160,11 +109838,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P * cdef PVGroup pvg */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6138, __pyx_L1_error) + __PYX_ERR(3, 6345, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":6144 + /* "PyCafe.pyx":6351 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -106179,7 +109857,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":6145 + /* "PyCafe.pyx":6352 * * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) # <<<<<<<<<<<<<< @@ -106189,7 +109867,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P (void)(__pyx_v_self->_c_cafe->groupAttach(__pyx_v_ghandle, __pyx_v_pvg)); } - /* "PyCafe.pyx":6144 + /* "PyCafe.pyx":6351 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -106208,29 +109886,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P } } - /* "PyCafe.pyx":6146 + /* "PyCafe.pyx":6353 * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) * print("==============" ) # <<<<<<<<<<<<<< * print(_METHOD) * pvg.showMax(1) */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__111, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6146, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__106, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6147 + /* "PyCafe.pyx":6354 * self._c_cafe.groupAttach(ghandle, pvg) * print("==============" ) * print(_METHOD) # <<<<<<<<<<<<<< * pvg.showMax(1) * */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_v__METHOD); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6147, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_v__METHOD); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6354, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6148 + /* "PyCafe.pyx":6355 * print("==============" ) * print(_METHOD) * pvg.showMax(1) # <<<<<<<<<<<<<< @@ -106239,7 +109917,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_pvg.showMax(1); - /* "PyCafe.pyx":6150 + /* "PyCafe.pyx":6357 * pvg.showMax(1) * * pvd = pvg.getPVData() # <<<<<<<<<<<<<< @@ -106248,7 +109926,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_pvd = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":6152 + /* "PyCafe.pyx":6359 * pvd = pvg.getPVData() * * status = self._c_cafe.groupGetCache(ghandle, pvg) # <<<<<<<<<<<<<< @@ -106257,7 +109935,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_status = __pyx_v_self->_c_cafe->groupGetCache(__pyx_v_ghandle, __pyx_v_pvg); - /* "PyCafe.pyx":6153 + /* "PyCafe.pyx":6360 * * status = self._c_cafe.groupGetCache(ghandle, pvg) * pvg.showMax(1) # <<<<<<<<<<<<<< @@ -106266,29 +109944,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_pvg.showMax(1); - /* "PyCafe.pyx":6154 + /* "PyCafe.pyx":6361 * status = self._c_cafe.groupGetCache(ghandle, pvg) * pvg.showMax(1) * print("==============" ) # <<<<<<<<<<<<<< * print(status, pvg.getStatusGroup()) * print("==============" ) */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__111, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6154, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__106, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6155 + /* "PyCafe.pyx":6362 * pvg.showMax(1) * print("==============" ) * print(status, pvg.getStatusGroup()) # <<<<<<<<<<<<<< * print("==============" ) * if status != ICAFE_NORMAL: */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6155, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_pvg.getStatusGroup()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6155, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_pvg.getStatusGroup()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6155, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); @@ -106296,23 +109974,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5); __pyx_t_6 = 0; __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6155, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6156 + /* "PyCafe.pyx":6363 * print("==============" ) * print(status, pvg.getStatusGroup()) * print("==============" ) # <<<<<<<<<<<<<< * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__111, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6156, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__106, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6363, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6157 + /* "PyCafe.pyx":6364 * print(status, pvg.getStatusGroup()) * print("==============" ) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -106322,7 +110000,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6158 + /* "PyCafe.pyx":6365 * print("==============" ) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -106332,24 +110010,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6159 + /* "PyCafe.pyx":6366 * 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 */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6159, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = PyUnicode_Format(__pyx_kp_u_Error_in_PyCafe_def_getPVGroupCa, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6159, __pyx_L1_error) + __pyx_t_7 = PyUnicode_Format(__pyx_kp_u_Error_in_PyCafe_def_getPVGroupCa, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6159, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6160 + /* "PyCafe.pyx":6367 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in PyCafe def getPVGroupCache. Status = %d" % status) * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -106358,7 +110036,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6158 + /* "PyCafe.pyx":6365 * print("==============" ) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -106367,7 +110045,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":6157 + /* "PyCafe.pyx":6364 * print(status, pvg.getStatusGroup()) * print("==============" ) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -106376,7 +110054,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":6164 + /* "PyCafe.pyx":6371 * #raise Exception("EXCEPTION RAISED in PyCafe def getPVGroup. Status = %d" %status) * * pvd = pvg.getPVData() # <<<<<<<<<<<<<< @@ -106385,19 +110063,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_pvd = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":6166 + /* "PyCafe.pyx":6373 * pvd = pvg.getPVData() * * localList = [] # <<<<<<<<<<<<<< * * for i in range(0, pvg.getNPV()): */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6166, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_localList = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6168 + /* "PyCafe.pyx":6375 * localList = [] * * for i in range(0, pvg.getNPV()): # <<<<<<<<<<<<<< @@ -106409,7 +110087,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":6171 + /* "PyCafe.pyx":6378 * #print(pvd[i].getAsString(0), " " , pvd[i].getStatus()) * #print(pvd[i].getEpicsTimeStampAsUInt32().secPastEpoch, " ", pvd[i].getEpicsTimeStampAsUInt32().nsec) * localList.append(PVDataHolderToStruct(pvd[i], dt)) # <<<<<<<<<<<<<< @@ -106418,25 +110096,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_t_10.__pyx_n = 1; __pyx_t_10.dt = __pyx_v_dt; - __pyx_t_5 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct((__pyx_v_pvd[__pyx_v_i]), &__pyx_t_10)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6171, __pyx_L1_error) + __pyx_t_5 = ((PyObject *)__pyx_f_6PyCafe_PVDataHolderToStruct((__pyx_v_pvd[__pyx_v_i]), &__pyx_t_10)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_5); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(3, 6171, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_localList, __pyx_t_5); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(3, 6378, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - /* "PyCafe.pyx":6174 + /* "PyCafe.pyx":6381 * cpdef pvgroup pg * * pg = pvgroup() # <<<<<<<<<<<<<< * * pg.pvdata = localList */ - __pyx_t_5 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvgroup)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6174, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_6PyCafe_pvgroup)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_pg = ((struct __pyx_obj_6PyCafe_pvgroup *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6176 + /* "PyCafe.pyx":6383 * pg = pvgroup() * * pg.pvdata = localList # <<<<<<<<<<<<<< @@ -106449,7 +110127,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P __Pyx_DECREF(__pyx_v_pg->pvdata); __pyx_v_pg->pvdata = __pyx_v_localList; - /* "PyCafe.pyx":6178 + /* "PyCafe.pyx":6385 * pg.pvdata = localList * * pg.npv = pvg.getNPV() # <<<<<<<<<<<<<< @@ -106458,7 +110136,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_pg->npv = __pyx_v_pvg.getNPV(); - /* "PyCafe.pyx":6179 + /* "PyCafe.pyx":6386 * * pg.npv = pvg.getNPV() * pg.name = pvg.getNameAsString() # <<<<<<<<<<<<<< @@ -106467,7 +110145,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_pg->name = __pyx_v_pvg.getNameAsString(); - /* "PyCafe.pyx":6180 + /* "PyCafe.pyx":6387 * pg.npv = pvg.getNPV() * pg.name = pvg.getNameAsString() * pg.groupStatus = pvg.getStatusGroup() # <<<<<<<<<<<<<< @@ -106476,7 +110154,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_pg->groupStatus = __pyx_v_pvg.getStatusGroup(); - /* "PyCafe.pyx":6181 + /* "PyCafe.pyx":6388 * pg.name = pvg.getNameAsString() * pg.groupStatus = pvg.getStatusGroup() * pg.groupHandle = pvg.getGroupHandle() # <<<<<<<<<<<<<< @@ -106485,7 +110163,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P */ __pyx_v_pg->groupHandle = __pyx_v_pvg.getGroupHandle(); - /* "PyCafe.pyx":6183 + /* "PyCafe.pyx":6390 * pg.groupHandle = pvg.getGroupHandle() * * return pg # <<<<<<<<<<<<<< @@ -106497,7 +110175,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P __pyx_r = ((PyObject *)__pyx_v_pg); goto __pyx_L0; - /* "PyCafe.pyx":6125 + /* "PyCafe.pyx":6332 * ################################################################################## * * def getPVGroupCache(self, ghandleName, str dt='native'): # <<<<<<<<<<<<<< @@ -106524,7 +110202,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_358getPVGroupCache(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":6190 +/* "PyCafe.pyx":6397 * ################################################################################## * * def PVGroupValuesToList(self, pvgroup pg): # <<<<<<<<<<<<<< @@ -106538,7 +110216,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_361PVGroupValuesToList(PyObject *__pyx PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("PVGroupValuesToList (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pg), __pyx_ptype_6PyCafe_pvgroup, 1, "pg", 0))) __PYX_ERR(3, 6190, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pg), __pyx_ptype_6PyCafe_pvgroup, 1, "pg", 0))) __PYX_ERR(3, 6397, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), ((struct __pyx_obj_6PyCafe_pvgroup *)__pyx_v_pg)); /* function exit code */ @@ -106569,19 +110247,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s Py_ssize_t __pyx_t_10; __Pyx_RefNannySetupContext("PVGroupValuesToList", 0); - /* "PyCafe.pyx":6191 + /* "PyCafe.pyx":6398 * * def PVGroupValuesToList(self, pvgroup pg): * glist = [] # <<<<<<<<<<<<<< * for i in range(0, pg.npv): * if len(pg.pvdata[i].value) == 1: */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6191, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_glist = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":6192 + /* "PyCafe.pyx":6399 * def PVGroupValuesToList(self, pvgroup pg): * glist = [] * for i in range(0, pg.npv): # <<<<<<<<<<<<<< @@ -106593,7 +110271,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "PyCafe.pyx":6193 + /* "PyCafe.pyx":6400 * glist = [] * for i in range(0, pg.npv): * if len(pg.pvdata[i].value) == 1: # <<<<<<<<<<<<<< @@ -106602,19 +110280,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s */ if (unlikely(__pyx_v_pg->pvdata == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6193, __pyx_L1_error) + __PYX_ERR(3, 6400, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_pg->pvdata, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6193, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_pg->pvdata, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6400, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6193, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6400, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6193, __pyx_L1_error) + __pyx_t_6 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6400, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_7 = ((__pyx_t_6 == 1) != 0); if (__pyx_t_7) { - /* "PyCafe.pyx":6194 + /* "PyCafe.pyx":6401 * for i in range(0, pg.npv): * if len(pg.pvdata[i].value) == 1: * glist.append(pg.pvdata[i].value[0]) # <<<<<<<<<<<<<< @@ -106623,20 +110301,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s */ if (unlikely(__pyx_v_pg->pvdata == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6194, __pyx_L1_error) + __PYX_ERR(3, 6401, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_pg->pvdata, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6194, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_pg->pvdata, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_value_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6194, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_value_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6194, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_glist, __pyx_t_5); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(3, 6194, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_glist, __pyx_t_5); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(3, 6401, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6193 + /* "PyCafe.pyx":6400 * glist = [] * for i in range(0, pg.npv): * if len(pg.pvdata[i].value) == 1: # <<<<<<<<<<<<<< @@ -106646,7 +110324,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s goto __pyx_L5; } - /* "PyCafe.pyx":6196 + /* "PyCafe.pyx":6403 * glist.append(pg.pvdata[i].value[0]) * else: * iL = [] # <<<<<<<<<<<<<< @@ -106654,12 +110332,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s * iL.append(pg.pvdata[i].value[j]) */ /*else*/ { - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6196, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_iL, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":6197 + /* "PyCafe.pyx":6404 * else: * iL = [] * for j in range(0, len(pg.pvdata[i].value)): # <<<<<<<<<<<<<< @@ -106668,20 +110346,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s */ if (unlikely(__pyx_v_pg->pvdata == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6197, __pyx_L1_error) + __PYX_ERR(3, 6404, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_pg->pvdata, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6197, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_pg->pvdata, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_value_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6197, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_value_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_6 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6197, __pyx_L1_error) + __pyx_t_6 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6404, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = __pyx_t_6; for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { __pyx_v_j = __pyx_t_10; - /* "PyCafe.pyx":6198 + /* "PyCafe.pyx":6405 * iL = [] * for j in range(0, len(pg.pvdata[i].value)): * iL.append(pg.pvdata[i].value[j]) # <<<<<<<<<<<<<< @@ -106690,33 +110368,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s */ if (unlikely(__pyx_v_pg->pvdata == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6198, __pyx_L1_error) + __PYX_ERR(3, 6405, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_pg->pvdata, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6198, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_pg->pvdata, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6198, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_j, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6198, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_j, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_iL, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(3, 6198, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_iL, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(3, 6405, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "PyCafe.pyx":6199 + /* "PyCafe.pyx":6406 * for j in range(0, len(pg.pvdata[i].value)): * iL.append(pg.pvdata[i].value[j]) * glist.append(iL) # <<<<<<<<<<<<<< * return glist * ################################################################################## */ - __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_glist, __pyx_v_iL); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(3, 6199, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_glist, __pyx_v_iL); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(3, 6406, __pyx_L1_error) } __pyx_L5:; } - /* "PyCafe.pyx":6200 + /* "PyCafe.pyx":6407 * iL.append(pg.pvdata[i].value[j]) * glist.append(iL) * return glist # <<<<<<<<<<<<<< @@ -106728,7 +110406,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s __pyx_r = __pyx_v_glist; goto __pyx_L0; - /* "PyCafe.pyx":6190 + /* "PyCafe.pyx":6397 * ################################################################################## * * def PVGroupValuesToList(self, pvgroup pg): # <<<<<<<<<<<<<< @@ -106752,7 +110430,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_360PVGroupValuesToList(CYTHON_UNUSED s return __pyx_r; } -/* "PyCafe.pyx":6205 +/* "PyCafe.pyx":6412 * ################################################################################## * * def groupMemberList(self, str gname): # <<<<<<<<<<<<<< @@ -106766,7 +110444,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_363groupMemberList(PyObject *__pyx_v_s PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("groupMemberList (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gname), (&PyUnicode_Type), 1, "gname", 1))) __PYX_ERR(3, 6205, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_gname), (&PyUnicode_Type), 1, "gname", 1))) __PYX_ERR(3, 6412, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_362groupMemberList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), ((PyObject*)__pyx_v_gname)); /* function exit code */ @@ -106789,7 +110467,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_362groupMemberList(struct __pyx_obj_6P PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("groupMemberList", 0); - /* "PyCafe.pyx":6206 + /* "PyCafe.pyx":6413 * * def groupMemberList(self, str gname): * cdef str _METHOD = "groupMemberList(self, str gname)" # <<<<<<<<<<<<<< @@ -106799,17 +110477,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_362groupMemberList(struct __pyx_obj_6P __Pyx_INCREF(__pyx_kp_u_groupMemberList_self_str_gname); __pyx_v__METHOD = __pyx_kp_u_groupMemberList_self_str_gname; - /* "PyCafe.pyx":6208 + /* "PyCafe.pyx":6415 * 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: */ - __pyx_t_1 = __Pyx_PyObject_AsString(__pyx_v_gname); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(3, 6208, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_AsString(__pyx_v_gname); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(3, 6415, __pyx_L1_error) __pyx_v_status = __pyx_v_self->_c_cafe->groupMemberList(__pyx_t_1, __pyx_v_pvlist); - /* "PyCafe.pyx":6209 + /* "PyCafe.pyx":6416 * cdef vector[string] pvlist * status = self._c_cafe.groupMemberList(gname, pvlist) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -106819,7 +110497,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_362groupMemberList(struct __pyx_obj_6P __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6210 + /* "PyCafe.pyx":6417 * status = self._c_cafe.groupMemberList(gname, pvlist) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -106829,7 +110507,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_362groupMemberList(struct __pyx_obj_6P __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6211 + /* "PyCafe.pyx":6418 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -106838,7 +110516,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_362groupMemberList(struct __pyx_obj_6P */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6210 + /* "PyCafe.pyx":6417 * status = self._c_cafe.groupMemberList(gname, pvlist) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -106847,7 +110525,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_362groupMemberList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":6209 + /* "PyCafe.pyx":6416 * cdef vector[string] pvlist * status = self._c_cafe.groupMemberList(gname, pvlist) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -106856,7 +110534,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_362groupMemberList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":6213 + /* "PyCafe.pyx":6420 * self._c_cafe.printStatusMessage(status) * * return pvlist # <<<<<<<<<<<<<< @@ -106864,13 +110542,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_362groupMemberList(struct __pyx_obj_6P * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvlist); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6213, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_pvlist); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6205 + /* "PyCafe.pyx":6412 * ################################################################################## * * def groupMemberList(self, str gname): # <<<<<<<<<<<<<< @@ -106892,7 +110570,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_362groupMemberList(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":6217 +/* "PyCafe.pyx":6424 * ################################################################################## * * def grouping(self, char * gname, list _pvlist): # <<<<<<<<<<<<<< @@ -106931,11 +110609,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_365grouping(PyObject *__pyx_v_self, Py case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pvlist)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("grouping", 1, 2, 2, 1); __PYX_ERR(3, 6217, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("grouping", 1, 2, 2, 1); __PYX_ERR(3, 6424, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "grouping") < 0)) __PYX_ERR(3, 6217, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "grouping") < 0)) __PYX_ERR(3, 6424, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -106943,18 +110621,18 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_365grouping(PyObject *__pyx_v_self, Py values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } - __pyx_v_gname = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6217, __pyx_L3_error) + __pyx_v_gname = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6424, __pyx_L3_error) __pyx_v__pvlist = ((PyObject*)values[1]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("grouping", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6217, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("grouping", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6424, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.grouping", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v__pvlist), (&PyList_Type), 1, "_pvlist", 1))) __PYX_ERR(3, 6217, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v__pvlist), (&PyList_Type), 1, "_pvlist", 1))) __PYX_ERR(3, 6424, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_364grouping(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_gname, __pyx_v__pvlist); /* function exit code */ @@ -106995,7 +110673,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C Py_ssize_t __pyx_t_15; __Pyx_RefNannySetupContext("grouping", 0); - /* "PyCafe.pyx":6218 + /* "PyCafe.pyx":6425 * * def grouping(self, char * gname, list _pvlist): * cdef str _METHOD = "grouping(char * gname, list _pvlist)" # <<<<<<<<<<<<<< @@ -107005,17 +110683,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_kp_u_grouping_char_gname_list__pvlist); __pyx_v__METHOD = __pyx_kp_u_grouping_char_gname_list__pvlist; - /* "PyCafe.pyx":6220 + /* "PyCafe.pyx":6427 * cdef str _METHOD = "grouping(char * gname, list _pvlist)" * * cdef int status = self._c_cafe.groupDefine(gname, _pvlist) # <<<<<<<<<<<<<< * * if status != ICAFE_NORMAL: */ - __pyx_t_1 = __pyx_convert_vector_from_py_char__const___2a_(__pyx_v__pvlist); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6220, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_from_py_char__const___2a_(__pyx_v__pvlist); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6427, __pyx_L1_error) __pyx_v_status = __pyx_v_self->_c_cafe->groupDefine(__pyx_v_gname, __pyx_t_1); - /* "PyCafe.pyx":6222 + /* "PyCafe.pyx":6429 * cdef int status = self._c_cafe.groupDefine(gname, _pvlist) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -107025,7 +110703,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6223 + /* "PyCafe.pyx":6430 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -107035,7 +110713,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6224 + /* "PyCafe.pyx":6431 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -107044,7 +110722,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6223 + /* "PyCafe.pyx":6430 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -107053,7 +110731,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":6222 + /* "PyCafe.pyx":6429 * cdef int status = self._c_cafe.groupDefine(gname, _pvlist) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -107062,7 +110740,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":6226 + /* "PyCafe.pyx":6433 * self._c_cafe.printStatusMessage(status) * * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -107071,7 +110749,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":6227 + /* "PyCafe.pyx":6434 * * cdef unsigned int ghandle = 0 * cdef char * _gname = gname # <<<<<<<<<<<<<< @@ -107080,7 +110758,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ __pyx_v__gname = __pyx_v_gname; - /* "PyCafe.pyx":6229 + /* "PyCafe.pyx":6436 * cdef char * _gname = gname * * try: # <<<<<<<<<<<<<< @@ -107096,7 +110774,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { - /* "PyCafe.pyx":6231 + /* "PyCafe.pyx":6438 * try: * IF PY_EXT_C: * with nogil: # <<<<<<<<<<<<<< @@ -107111,7 +110789,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C #endif /*try:*/ { - /* "PyCafe.pyx":6232 + /* "PyCafe.pyx":6439 * IF PY_EXT_C: * with nogil: * status = self._c_cafe.groupOpen(_gname, ghandle) # <<<<<<<<<<<<<< @@ -107128,12 +110806,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif - __PYX_ERR(3, 6232, __pyx_L12_error) + __PYX_ERR(3, 6439, __pyx_L12_error) } __pyx_v_status = __pyx_t_6; } - /* "PyCafe.pyx":6231 + /* "PyCafe.pyx":6438 * try: * IF PY_EXT_C: * with nogil: # <<<<<<<<<<<<<< @@ -107159,7 +110837,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C } } - /* "PyCafe.pyx":6229 + /* "PyCafe.pyx":6436 * cdef char * _gname = gname * * try: # <<<<<<<<<<<<<< @@ -107173,7 +110851,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C goto __pyx_L10_try_end; __pyx_L5_error:; - /* "PyCafe.pyx":6237 + /* "PyCafe.pyx":6444 * #with nogil: * status = self._c_cafe.groupOpen(_gname, ghandle) * except: # <<<<<<<<<<<<<< @@ -107182,81 +110860,81 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ /*except:*/ { __Pyx_AddTraceback("PyCafe.CyCafe.grouping", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(3, 6237, __pyx_L7_except_error) + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(3, 6444, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_9); - /* "PyCafe.pyx":6239 + /* "PyCafe.pyx":6446 * except: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=ghandle, # <<<<<<<<<<<<<< * _pv_name=_gname, * _error_code=ECA_ALLOCMEM, _error_text=self.cs.code(ECA_ALLOCMEM), */ - __pyx_t_10 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6239, __pyx_L7_except_error) + __pyx_t_10 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6446, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_10); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6239, __pyx_L7_except_error) - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6239, __pyx_L7_except_error) - __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6239, __pyx_L7_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6446, __pyx_L7_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6446, __pyx_L7_except_error) + __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6446, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_handle, __pyx_t_11) < 0) __PYX_ERR(3, 6239, __pyx_L7_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_handle, __pyx_t_11) < 0) __PYX_ERR(3, 6446, __pyx_L7_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6240 + /* "PyCafe.pyx":6447 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=ghandle, * _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=ECA_ALLOCMEM, _error_text=self.cs.code(ECA_ALLOCMEM), * _error_info=self.cs.info(ECA_ALLOCMEM)) */ - __pyx_t_11 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6240, __pyx_L7_except_error) + __pyx_t_11 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6447, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_pv_name, __pyx_t_11) < 0) __PYX_ERR(3, 6239, __pyx_L7_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_pv_name, __pyx_t_11) < 0) __PYX_ERR(3, 6446, __pyx_L7_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6241 + /* "PyCafe.pyx":6448 * _type='CafeError', _source=_METHOD, _handle=ghandle, * _pv_name=_gname, * _error_code=ECA_ALLOCMEM, _error_text=self.cs.code(ECA_ALLOCMEM), # <<<<<<<<<<<<<< * _error_info=self.cs.info(ECA_ALLOCMEM)) * raise _cafeException */ - __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(ECA_ALLOCMEM); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6241, __pyx_L7_except_error) + __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(ECA_ALLOCMEM); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6448, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_code, __pyx_t_11) < 0) __PYX_ERR(3, 6239, __pyx_L7_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_code, __pyx_t_11) < 0) __PYX_ERR(3, 6446, __pyx_L7_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECA_ALLOCMEM)); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6241, __pyx_L7_except_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECA_ALLOCMEM)); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6448, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_text, __pyx_t_11) < 0) __PYX_ERR(3, 6239, __pyx_L7_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_text, __pyx_t_11) < 0) __PYX_ERR(3, 6446, __pyx_L7_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6242 + /* "PyCafe.pyx":6449 * _pv_name=_gname, * _error_code=ECA_ALLOCMEM, _error_text=self.cs.code(ECA_ALLOCMEM), * _error_info=self.cs.info(ECA_ALLOCMEM)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECA_ALLOCMEM)); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6242, __pyx_L7_except_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECA_ALLOCMEM)); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6449, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_info, __pyx_t_11) < 0) __PYX_ERR(3, 6239, __pyx_L7_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_info, __pyx_t_11) < 0) __PYX_ERR(3, 6446, __pyx_L7_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6238 + /* "PyCafe.pyx":6445 * status = self._c_cafe.groupOpen(_gname, ghandle) * except: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=ghandle, * _pv_name=_gname, */ - __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6238, __pyx_L7_except_error) + __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6445, __pyx_L7_except_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6243 + /* "PyCafe.pyx":6450 * _error_code=ECA_ALLOCMEM, _error_text=self.cs.code(ECA_ALLOCMEM), * _error_info=self.cs.info(ECA_ALLOCMEM)) * raise _cafeException # <<<<<<<<<<<<<< @@ -107264,7 +110942,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C * if status != ICAFE_NORMAL: */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6243, __pyx_L7_except_error) + __PYX_ERR(3, 6450, __pyx_L7_except_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; @@ -107272,7 +110950,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C } __pyx_L7_except_error:; - /* "PyCafe.pyx":6229 + /* "PyCafe.pyx":6436 * cdef char * _gname = gname * * try: # <<<<<<<<<<<<<< @@ -107292,7 +110970,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __pyx_L10_try_end:; } - /* "PyCafe.pyx":6245 + /* "PyCafe.pyx":6452 * raise _cafeException * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -107302,76 +110980,76 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6247 + /* "PyCafe.pyx":6454 * if status != ICAFE_NORMAL: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=ghandle, # <<<<<<<<<<<<<< * _pv_name=_gname, * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_9 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6247, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6247, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6247, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6454, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6454, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_handle, __pyx_t_8) < 0) __PYX_ERR(3, 6247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_handle, __pyx_t_8) < 0) __PYX_ERR(3, 6454, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6248 + /* "PyCafe.pyx":6455 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=ghandle, * _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_8 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6248, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_pv_name, __pyx_t_8) < 0) __PYX_ERR(3, 6247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_pv_name, __pyx_t_8) < 0) __PYX_ERR(3, 6454, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6249 + /* "PyCafe.pyx":6456 * _type='CafeError', _source=_METHOD, _handle=ghandle, * _pv_name=_gname, * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6249, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_code, __pyx_t_8) < 0) __PYX_ERR(3, 6247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_code, __pyx_t_8) < 0) __PYX_ERR(3, 6454, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6249, __pyx_L1_error) + __pyx_t_8 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_text, __pyx_t_8) < 0) __PYX_ERR(3, 6247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_text, __pyx_t_8) < 0) __PYX_ERR(3, 6454, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6250 + /* "PyCafe.pyx":6457 * _pv_name=_gname, * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_8 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6250, __pyx_L1_error) + __pyx_t_8 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_info, __pyx_t_8) < 0) __PYX_ERR(3, 6247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_info, __pyx_t_8) < 0) __PYX_ERR(3, 6454, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6246 + /* "PyCafe.pyx":6453 * * if status != ICAFE_NORMAL: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=ghandle, * _pv_name=_gname, */ - __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6246, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6251 + /* "PyCafe.pyx":6458 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -107379,9 +111057,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C * # cdef PVGroup pvg */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6251, __pyx_L1_error) + __PYX_ERR(3, 6458, __pyx_L1_error) - /* "PyCafe.pyx":6245 + /* "PyCafe.pyx":6452 * raise _cafeException * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -107390,7 +111068,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":6260 + /* "PyCafe.pyx":6467 * list statusList * * cdef short wtfsb = self._c_cafe.channelOpenGroupPolicy.getWhenToFlushSendBuffer() # <<<<<<<<<<<<<< @@ -107399,7 +111077,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ __pyx_v_wtfsb = __pyx_v_self->_c_cafe->channelOpenGroupPolicy.getWhenToFlushSendBuffer(); - /* "PyCafe.pyx":6262 + /* "PyCafe.pyx":6469 * cdef short wtfsb = self._c_cafe.channelOpenGroupPolicy.getWhenToFlushSendBuffer() * * if wtfsb == FLUSH_NOW: # <<<<<<<<<<<<<< @@ -107409,16 +111087,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_wtfsb == FLUSH_NOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6264 + /* "PyCafe.pyx":6471 * if wtfsb == FLUSH_NOW: * * localList, status, statusList = self.getGroup(ghandle) # <<<<<<<<<<<<<< * * if status != ICAFE_NORMAL: */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getGroup); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6264, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getGroup); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6264, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_11 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { @@ -107433,7 +111111,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __pyx_t_8 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_11, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_7); __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6264, __pyx_L1_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { @@ -107442,7 +111120,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(3, 6264, __pyx_L1_error) + __PYX_ERR(3, 6471, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -107458,17 +111136,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_11); #else - __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6264, __pyx_L1_error) + __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6264, __pyx_L1_error) + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_11 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6264, __pyx_L1_error) + __pyx_t_11 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { Py_ssize_t index = -1; - __pyx_t_10 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6264, __pyx_L1_error) + __pyx_t_10 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_12 = Py_TYPE(__pyx_t_10)->tp_iternext; @@ -107478,7 +111156,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __Pyx_GOTREF(__pyx_t_7); index = 2; __pyx_t_11 = __pyx_t_12(__pyx_t_10); if (unlikely(!__pyx_t_11)) goto __pyx_L18_unpacking_failed; __Pyx_GOTREF(__pyx_t_11); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_10), 3) < 0) __PYX_ERR(3, 6264, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_10), 3) < 0) __PYX_ERR(3, 6471, __pyx_L1_error) __pyx_t_12 = NULL; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L19_unpacking_done; @@ -107486,20 +111164,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_12 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(3, 6264, __pyx_L1_error) + __PYX_ERR(3, 6471, __pyx_L1_error) __pyx_L19_unpacking_done:; } - if (!(likely(PyList_CheckExact(__pyx_t_9))||((__pyx_t_9) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_9)->tp_name), 0))) __PYX_ERR(3, 6264, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6264, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_t_9))||((__pyx_t_9) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_9)->tp_name), 0))) __PYX_ERR(3, 6471, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6471, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!(likely(PyList_CheckExact(__pyx_t_11))||((__pyx_t_11) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_11)->tp_name), 0))) __PYX_ERR(3, 6264, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_t_11))||((__pyx_t_11) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_11)->tp_name), 0))) __PYX_ERR(3, 6471, __pyx_L1_error) __pyx_v_localList = ((PyObject*)__pyx_t_9); __pyx_t_9 = 0; __pyx_v_status = __pyx_t_6; __pyx_v_statusList = ((PyObject*)__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6266 + /* "PyCafe.pyx":6473 * localList, status, statusList = self.getGroup(ghandle) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -107509,7 +111187,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6267 + /* "PyCafe.pyx":6474 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -107519,27 +111197,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6268 + /* "PyCafe.pyx":6475 * 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) */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6268, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6269 + /* "PyCafe.pyx":6476 * 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[]...") */ - __pyx_t_8 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6269, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6269, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_kp_u_Error_in_def_grouping_for_group); __Pyx_GIVEREF(__pyx_kp_u_Error_in_def_grouping_for_group); @@ -107547,12 +111225,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6269, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6270 + /* "PyCafe.pyx":6477 * print("") * print("Error in def grouping for group named", _gname) * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -107561,18 +111239,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6271 + /* "PyCafe.pyx":6478 * 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: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__112, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6271, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__107, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6272 + /* "PyCafe.pyx":6479 * self._c_cafe.printStatusMessage(status) * print("Analysing statusList[]...") * for i in range(0, len(statusList)): # <<<<<<<<<<<<<< @@ -107581,14 +111259,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_statusList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 6272, __pyx_L1_error) + __PYX_ERR(3, 6479, __pyx_L1_error) } - __pyx_t_13 = PyList_GET_SIZE(__pyx_v_statusList); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6272, __pyx_L1_error) + __pyx_t_13 = PyList_GET_SIZE(__pyx_v_statusList); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6479, __pyx_L1_error) __pyx_t_14 = __pyx_t_13; for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { __pyx_v_i = __pyx_t_15; - /* "PyCafe.pyx":6273 + /* "PyCafe.pyx":6480 * print("Analysing statusList[]...") * for i in range(0, len(statusList)): * if statusList[i] != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -107597,20 +111275,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_statusList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6273, __pyx_L1_error) + __PYX_ERR(3, 6480, __pyx_L1_error) } - __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_statusList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6273, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_statusList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_11 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6273, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_int(ICAFE_NORMAL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_t_11, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6273, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_t_11, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6480, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 6273, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 6480, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_2) { - /* "PyCafe.pyx":6274 + /* "PyCafe.pyx":6481 * for i in range(0, len(statusList)): * if statusList[i] != ICAFE_NORMAL: * print("PV", _pvlist[i], # <<<<<<<<<<<<<< @@ -107619,54 +111297,54 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v__pvlist == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6274, __pyx_L1_error) + __PYX_ERR(3, 6481, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v__pvlist, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6274, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v__pvlist, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "PyCafe.pyx":6275 + /* "PyCafe.pyx":6482 * if statusList[i] != ICAFE_NORMAL: * print("PV", _pvlist[i], * "[", i, "]", " has error: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(statusList[i]) * print("") */ - __pyx_t_11 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6275, __pyx_L1_error) + __pyx_t_11 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - /* "PyCafe.pyx":6274 + /* "PyCafe.pyx":6481 * 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]) */ - __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6274, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_n_u_PV_4); __Pyx_GIVEREF(__pyx_n_u_PV_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_n_u_PV_4); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); - __Pyx_INCREF(__pyx_kp_u__113); - __Pyx_GIVEREF(__pyx_kp_u__113); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__113); + __Pyx_INCREF(__pyx_kp_u__108); + __Pyx_GIVEREF(__pyx_kp_u__108); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__108); __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_11); - __Pyx_INCREF(__pyx_kp_u__114); - __Pyx_GIVEREF(__pyx_kp_u__114); - PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_kp_u__114); + __Pyx_INCREF(__pyx_kp_u__109); + __Pyx_GIVEREF(__pyx_kp_u__109); + PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_kp_u__109); __Pyx_INCREF(__pyx_kp_u_has_error); __Pyx_GIVEREF(__pyx_kp_u_has_error); PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_kp_u_has_error); __pyx_t_7 = 0; __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_8, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6274, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_8, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6276 + /* "PyCafe.pyx":6483 * print("PV", _pvlist[i], * "[", i, "]", " has error: ") * self._c_cafe.printStatusMessage(statusList[i]) # <<<<<<<<<<<<<< @@ -107675,26 +111353,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_statusList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6276, __pyx_L1_error) + __PYX_ERR(3, 6483, __pyx_L1_error) } - __pyx_t_11 = __Pyx_GetItemInt_List(__pyx_v_statusList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6276, __pyx_L1_error) + __pyx_t_11 = __Pyx_GetItemInt_List(__pyx_v_statusList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6276, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6483, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_v_self->_c_cafe->printStatusMessage(__pyx_t_6); - /* "PyCafe.pyx":6277 + /* "PyCafe.pyx":6484 * "[", i, "]", " has error: ") * self._c_cafe.printStatusMessage(statusList[i]) * print("") # <<<<<<<<<<<<<< * return ghandle * */ - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6277, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6484, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6273 + /* "PyCafe.pyx":6480 * print("Analysing statusList[]...") * for i in range(0, len(statusList)): * if statusList[i] != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -107704,7 +111382,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C } } - /* "PyCafe.pyx":6267 + /* "PyCafe.pyx":6474 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -107713,7 +111391,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":6266 + /* "PyCafe.pyx":6473 * localList, status, statusList = self.getGroup(ghandle) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -107722,7 +111400,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":6262 + /* "PyCafe.pyx":6469 * cdef short wtfsb = self._c_cafe.channelOpenGroupPolicy.getWhenToFlushSendBuffer() * * if wtfsb == FLUSH_NOW: # <<<<<<<<<<<<<< @@ -107731,7 +111409,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":6278 + /* "PyCafe.pyx":6485 * self._c_cafe.printStatusMessage(statusList[i]) * print("") * return ghandle # <<<<<<<<<<<<<< @@ -107739,13 +111417,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6278, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_r = __pyx_t_11; __pyx_t_11 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6217 + /* "PyCafe.pyx":6424 * ################################################################################## * * def grouping(self, char * gname, list _pvlist): # <<<<<<<<<<<<<< @@ -107774,7 +111452,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_364grouping(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":6282 +/* "PyCafe.pyx":6489 * * ################################################################################## * def groupDefineFromCollection(self, const char * gname, const char * cname, attrib): # <<<<<<<<<<<<<< @@ -107816,17 +111494,17 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_367groupDefineFromCollection(PyObject case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_cname)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("groupDefineFromCollection", 1, 3, 3, 1); __PYX_ERR(3, 6282, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("groupDefineFromCollection", 1, 3, 3, 1); __PYX_ERR(3, 6489, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_attrib)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("groupDefineFromCollection", 1, 3, 3, 2); __PYX_ERR(3, 6282, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("groupDefineFromCollection", 1, 3, 3, 2); __PYX_ERR(3, 6489, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupDefineFromCollection") < 0)) __PYX_ERR(3, 6282, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupDefineFromCollection") < 0)) __PYX_ERR(3, 6489, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; @@ -107835,13 +111513,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_367groupDefineFromCollection(PyObject values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } - __pyx_v_gname = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6282, __pyx_L3_error) - __pyx_v_cname = __Pyx_PyObject_AsString(values[1]); if (unlikely((!__pyx_v_cname) && PyErr_Occurred())) __PYX_ERR(3, 6282, __pyx_L3_error) + __pyx_v_gname = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6489, __pyx_L3_error) + __pyx_v_cname = __Pyx_PyObject_AsString(values[1]); if (unlikely((!__pyx_v_cname) && PyErr_Occurred())) __PYX_ERR(3, 6489, __pyx_L3_error) __pyx_v_attrib = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("groupDefineFromCollection", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6282, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("groupDefineFromCollection", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6489, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.groupDefineFromCollection", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -107868,7 +111546,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ std::vector __pyx_t_5; __Pyx_RefNannySetupContext("groupDefineFromCollection", 0); - /* "PyCafe.pyx":6283 + /* "PyCafe.pyx":6490 * ################################################################################## * def groupDefineFromCollection(self, const char * gname, const char * cname, attrib): * cdef str _METHOD = "groupDefineFromCollection" # <<<<<<<<<<<<<< @@ -107878,7 +111556,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ __Pyx_INCREF(__pyx_n_u_groupDefineFromCollection); __pyx_v__METHOD = __pyx_n_u_groupDefineFromCollection; - /* "PyCafe.pyx":6285 + /* "PyCafe.pyx":6492 * cdef str _METHOD = "groupDefineFromCollection" * cdef list _attribute_list * if isinstance(attrib, str): # <<<<<<<<<<<<<< @@ -107889,14 +111567,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6286 + /* "PyCafe.pyx":6493 * cdef list _attribute_list * if isinstance(attrib, str): * _attribute_list = [attrib] # <<<<<<<<<<<<<< * elif isinstance(attrib, list): * _attribute_list = attrib */ - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6286, __pyx_L1_error) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_attrib); __Pyx_GIVEREF(__pyx_v_attrib); @@ -107904,7 +111582,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ __pyx_v__attribute_list = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":6285 + /* "PyCafe.pyx":6492 * cdef str _METHOD = "groupDefineFromCollection" * cdef list _attribute_list * if isinstance(attrib, str): # <<<<<<<<<<<<<< @@ -107914,7 +111592,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ goto __pyx_L3; } - /* "PyCafe.pyx":6287 + /* "PyCafe.pyx":6494 * if isinstance(attrib, str): * _attribute_list = [attrib] * elif isinstance(attrib, list): # <<<<<<<<<<<<<< @@ -107925,20 +111603,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6288 + /* "PyCafe.pyx":6495 * _attribute_list = [attrib] * elif isinstance(attrib, list): * _attribute_list = attrib # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyList_CheckExact(__pyx_v_attrib))||((__pyx_v_attrib) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_attrib)->tp_name), 0))) __PYX_ERR(3, 6288, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_attrib))||((__pyx_v_attrib) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_attrib)->tp_name), 0))) __PYX_ERR(3, 6495, __pyx_L1_error) __pyx_t_3 = __pyx_v_attrib; __Pyx_INCREF(__pyx_t_3); __pyx_v__attribute_list = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":6287 + /* "PyCafe.pyx":6494 * if isinstance(attrib, str): * _attribute_list = [attrib] * elif isinstance(attrib, list): # <<<<<<<<<<<<<< @@ -107948,7 +111626,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ goto __pyx_L3; } - /* "PyCafe.pyx":6290 + /* "PyCafe.pyx":6497 * _attribute_list = attrib * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -107956,18 +111634,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ * "else of ")) */ /*else*/ { - __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6290, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6290, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6290, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_kp_u_Third_input_argument_should_be_o) < 0) __PYX_ERR(3, 6290, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6290, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6497, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6497, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_error_info, __pyx_kp_u_Third_input_argument_should_be_o) < 0) __PYX_ERR(3, 6497, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":6293 + /* "PyCafe.pyx":6500 * _error_info=("Third input argument, should be of type " * "else of ")) * raise _cafeException # <<<<<<<<<<<<<< @@ -107975,21 +111653,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ * status = self._c_cafe.groupDefineFromCollection(gname, cname, _attribute_list) */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6293, __pyx_L1_error) + __PYX_ERR(3, 6500, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":6295 + /* "PyCafe.pyx":6502 * raise _cafeException * * status = self._c_cafe.groupDefineFromCollection(gname, cname, _attribute_list) # <<<<<<<<<<<<<< * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: */ - __pyx_t_5 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_v__attribute_list); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6295, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_v__attribute_list); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6502, __pyx_L1_error) __pyx_v_status = __pyx_v_self->_c_cafe->groupDefineFromCollection(__pyx_v_gname, __pyx_v_cname, __pyx_t_5); - /* "PyCafe.pyx":6296 + /* "PyCafe.pyx":6503 * * status = self._c_cafe.groupDefineFromCollection(gname, cname, _attribute_list) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -107999,7 +111677,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6297 + /* "PyCafe.pyx":6504 * status = self._c_cafe.groupDefineFromCollection(gname, cname, _attribute_list) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -108009,7 +111687,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6298 + /* "PyCafe.pyx":6505 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -108018,7 +111696,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6297 + /* "PyCafe.pyx":6504 * status = self._c_cafe.groupDefineFromCollection(gname, cname, _attribute_list) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -108027,7 +111705,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ */ } - /* "PyCafe.pyx":6296 + /* "PyCafe.pyx":6503 * * status = self._c_cafe.groupDefineFromCollection(gname, cname, _attribute_list) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -108036,7 +111714,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ */ } - /* "PyCafe.pyx":6299 + /* "PyCafe.pyx":6506 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * return status # <<<<<<<<<<<<<< @@ -108044,13 +111722,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6299, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6282 + /* "PyCafe.pyx":6489 * * ################################################################################## * def groupDefineFromCollection(self, const char * gname, const char * cname, attrib): # <<<<<<<<<<<<<< @@ -108075,7 +111753,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_366groupDefineFromCollection(struct __ return __pyx_r; } -/* "PyCafe.pyx":6303 +/* "PyCafe.pyx":6510 * * ################################################################################## * def groupDefine(self, char * gname, list _pvlist): # <<<<<<<<<<<<<< @@ -108114,11 +111792,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_369groupDefine(PyObject *__pyx_v_self, case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pvlist)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("groupDefine", 1, 2, 2, 1); __PYX_ERR(3, 6303, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("groupDefine", 1, 2, 2, 1); __PYX_ERR(3, 6510, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupDefine") < 0)) __PYX_ERR(3, 6303, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupDefine") < 0)) __PYX_ERR(3, 6510, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -108126,18 +111804,18 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_369groupDefine(PyObject *__pyx_v_self, values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } - __pyx_v_gname = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6303, __pyx_L3_error) + __pyx_v_gname = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6510, __pyx_L3_error) __pyx_v__pvlist = ((PyObject*)values[1]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("groupDefine", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6303, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("groupDefine", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6510, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.groupDefine", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v__pvlist), (&PyList_Type), 1, "_pvlist", 1))) __PYX_ERR(3, 6303, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v__pvlist), (&PyList_Type), 1, "_pvlist", 1))) __PYX_ERR(3, 6510, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_368groupDefine(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_gname, __pyx_v__pvlist); /* function exit code */ @@ -108158,17 +111836,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_368groupDefine(struct __pyx_obj_6PyCaf PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("groupDefine", 0); - /* "PyCafe.pyx":6304 + /* "PyCafe.pyx":6511 * ################################################################################## * def groupDefine(self, char * gname, list _pvlist): * status = self._c_cafe.groupDefine(gname, _pvlist) # <<<<<<<<<<<<<< * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: */ - __pyx_t_1 = __pyx_convert_vector_from_py_char__const___2a_(__pyx_v__pvlist); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6304, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_from_py_char__const___2a_(__pyx_v__pvlist); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6511, __pyx_L1_error) __pyx_v_status = __pyx_v_self->_c_cafe->groupDefine(__pyx_v_gname, __pyx_t_1); - /* "PyCafe.pyx":6305 + /* "PyCafe.pyx":6512 * def groupDefine(self, char * gname, list _pvlist): * status = self._c_cafe.groupDefine(gname, _pvlist) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -108178,7 +111856,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_368groupDefine(struct __pyx_obj_6PyCaf __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6306 + /* "PyCafe.pyx":6513 * status = self._c_cafe.groupDefine(gname, _pvlist) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -108188,7 +111866,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_368groupDefine(struct __pyx_obj_6PyCaf __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6307 + /* "PyCafe.pyx":6514 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -108197,7 +111875,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_368groupDefine(struct __pyx_obj_6PyCaf */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6306 + /* "PyCafe.pyx":6513 * status = self._c_cafe.groupDefine(gname, _pvlist) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -108206,7 +111884,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_368groupDefine(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":6305 + /* "PyCafe.pyx":6512 * def groupDefine(self, char * gname, list _pvlist): * status = self._c_cafe.groupDefine(gname, _pvlist) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -108215,7 +111893,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_368groupDefine(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":6308 + /* "PyCafe.pyx":6515 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * return status # <<<<<<<<<<<<<< @@ -108223,13 +111901,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_368groupDefine(struct __pyx_obj_6PyCaf * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6308, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6303 + /* "PyCafe.pyx":6510 * * ################################################################################## * def groupDefine(self, char * gname, list _pvlist): # <<<<<<<<<<<<<< @@ -108250,7 +111928,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_368groupDefine(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":6312 +/* "PyCafe.pyx":6519 * * ################################################################################## * def defineGroup(self, char * gname, list _pvlist): # <<<<<<<<<<<<<< @@ -108289,11 +111967,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_371defineGroup(PyObject *__pyx_v_self, case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pvlist)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("defineGroup", 1, 2, 2, 1); __PYX_ERR(3, 6312, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("defineGroup", 1, 2, 2, 1); __PYX_ERR(3, 6519, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "defineGroup") < 0)) __PYX_ERR(3, 6312, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "defineGroup") < 0)) __PYX_ERR(3, 6519, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -108301,18 +111979,18 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_371defineGroup(PyObject *__pyx_v_self, values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } - __pyx_v_gname = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6312, __pyx_L3_error) + __pyx_v_gname = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6519, __pyx_L3_error) __pyx_v__pvlist = ((PyObject*)values[1]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("defineGroup", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6312, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("defineGroup", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6519, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.defineGroup", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v__pvlist), (&PyList_Type), 1, "_pvlist", 1))) __PYX_ERR(3, 6312, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v__pvlist), (&PyList_Type), 1, "_pvlist", 1))) __PYX_ERR(3, 6519, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_370defineGroup(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_gname, __pyx_v__pvlist); /* function exit code */ @@ -108333,17 +112011,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_370defineGroup(struct __pyx_obj_6PyCaf PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("defineGroup", 0); - /* "PyCafe.pyx":6313 + /* "PyCafe.pyx":6520 * ################################################################################## * def defineGroup(self, char * gname, list _pvlist): * status = self._c_cafe.groupDefine(gname, _pvlist) # <<<<<<<<<<<<<< * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: */ - __pyx_t_1 = __pyx_convert_vector_from_py_char__const___2a_(__pyx_v__pvlist); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6313, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_from_py_char__const___2a_(__pyx_v__pvlist); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6520, __pyx_L1_error) __pyx_v_status = __pyx_v_self->_c_cafe->groupDefine(__pyx_v_gname, __pyx_t_1); - /* "PyCafe.pyx":6314 + /* "PyCafe.pyx":6521 * def defineGroup(self, char * gname, list _pvlist): * status = self._c_cafe.groupDefine(gname, _pvlist) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -108353,7 +112031,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_370defineGroup(struct __pyx_obj_6PyCaf __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6315 + /* "PyCafe.pyx":6522 * status = self._c_cafe.groupDefine(gname, _pvlist) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -108363,7 +112041,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_370defineGroup(struct __pyx_obj_6PyCaf __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6316 + /* "PyCafe.pyx":6523 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -108372,7 +112050,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_370defineGroup(struct __pyx_obj_6PyCaf */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6315 + /* "PyCafe.pyx":6522 * status = self._c_cafe.groupDefine(gname, _pvlist) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -108381,7 +112059,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_370defineGroup(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":6314 + /* "PyCafe.pyx":6521 * def defineGroup(self, char * gname, list _pvlist): * status = self._c_cafe.groupDefine(gname, _pvlist) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -108390,7 +112068,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_370defineGroup(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":6317 + /* "PyCafe.pyx":6524 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * return status # <<<<<<<<<<<<<< @@ -108398,13 +112076,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_370defineGroup(struct __pyx_obj_6PyCaf * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6317, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6312 + /* "PyCafe.pyx":6519 * * ################################################################################## * def defineGroup(self, char * gname, list _pvlist): # <<<<<<<<<<<<<< @@ -108425,7 +112103,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_370defineGroup(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":6321 +/* "PyCafe.pyx":6528 * * ################################################################################## * def groupOpen(self, char * gname): # <<<<<<<<<<<<<< @@ -108441,7 +112119,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_373groupOpen(PyObject *__pyx_v_self, P __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("groupOpen (wrapper)", 0); assert(__pyx_arg_gname); { - __pyx_v_gname = __Pyx_PyObject_AsWritableString(__pyx_arg_gname); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6321, __pyx_L3_error) + __pyx_v_gname = __Pyx_PyObject_AsWritableString(__pyx_arg_gname); if (unlikely((!__pyx_v_gname) && PyErr_Occurred())) __PYX_ERR(3, 6528, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -108477,7 +112155,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ PyObject *__pyx_t_11 = NULL; __Pyx_RefNannySetupContext("groupOpen", 0); - /* "PyCafe.pyx":6322 + /* "PyCafe.pyx":6529 * ################################################################################## * def groupOpen(self, char * gname): * cdef str _METHOD = "groupOpen(char * gname)" # <<<<<<<<<<<<<< @@ -108487,39 +112165,39 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ __Pyx_INCREF(__pyx_kp_u_groupOpen_char_gname); __pyx_v__METHOD = __pyx_kp_u_groupOpen_char_gname; - /* "PyCafe.pyx":6324 + /* "PyCafe.pyx":6531 * cdef str _METHOD = "groupOpen(char * gname)" * * if not isinstance(gname, (str)) : # <<<<<<<<<<<<<< * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument should be for group name") */ - __pyx_t_1 = __Pyx_PyStr_FromString(__pyx_v_gname); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6324, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyStr_FromString(__pyx_v_gname); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyUnicode_Check(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6325 + /* "PyCafe.pyx":6532 * * if not isinstance(gname, (str)) : * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _error_info="First input argument should be for group name") * raise _cafeException */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6325, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6325, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6325, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_c) < 0) __PYX_ERR(3, 6325, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6325, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_c) < 0) __PYX_ERR(3, 6532, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":6327 + /* "PyCafe.pyx":6534 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument should be for group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -108527,9 +112205,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ * cdef unsigned int ghandle = 0 */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6327, __pyx_L1_error) + __PYX_ERR(3, 6534, __pyx_L1_error) - /* "PyCafe.pyx":6324 + /* "PyCafe.pyx":6531 * cdef str _METHOD = "groupOpen(char * gname)" * * if not isinstance(gname, (str)) : # <<<<<<<<<<<<<< @@ -108538,7 +112216,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":6329 + /* "PyCafe.pyx":6536 * raise _cafeException * * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -108547,7 +112225,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":6330 + /* "PyCafe.pyx":6537 * * cdef unsigned int ghandle = 0 * cdef char * _gname = gname # <<<<<<<<<<<<<< @@ -108556,7 +112234,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ */ __pyx_v__gname = __pyx_v_gname; - /* "PyCafe.pyx":6332 + /* "PyCafe.pyx":6539 * cdef char * _gname = gname * * try: # <<<<<<<<<<<<<< @@ -108572,7 +112250,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ __Pyx_XGOTREF(__pyx_t_7); /*try:*/ { - /* "PyCafe.pyx":6334 + /* "PyCafe.pyx":6541 * try: * IF PY_EXT_C: * with nogil: # <<<<<<<<<<<<<< @@ -108587,7 +112265,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ #endif /*try:*/ { - /* "PyCafe.pyx":6335 + /* "PyCafe.pyx":6542 * IF PY_EXT_C: * with nogil: * status = self._c_cafe.groupOpen(_gname, ghandle) # <<<<<<<<<<<<<< @@ -108604,12 +112282,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif - __PYX_ERR(3, 6335, __pyx_L11_error) + __PYX_ERR(3, 6542, __pyx_L11_error) } __pyx_v_status = __pyx_t_8; } - /* "PyCafe.pyx":6334 + /* "PyCafe.pyx":6541 * try: * IF PY_EXT_C: * with nogil: # <<<<<<<<<<<<<< @@ -108635,7 +112313,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ } } - /* "PyCafe.pyx":6332 + /* "PyCafe.pyx":6539 * cdef char * _gname = gname * * try: # <<<<<<<<<<<<<< @@ -108651,7 +112329,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":6341 + /* "PyCafe.pyx":6548 * status = self._c_cafe.groupOpen(_gname, ghandle) * * except: # <<<<<<<<<<<<<< @@ -108660,65 +112338,65 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ */ /*except:*/ { __Pyx_AddTraceback("PyCafe.CyCafe.groupOpen", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(3, 6341, __pyx_L6_except_error) + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(3, 6548, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_9); - /* "PyCafe.pyx":6342 + /* "PyCafe.pyx":6549 * * except: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=ghandle, _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=ECA_ALLOCMEM, _error_text=self.cs.code(ECA_ALLOCMEM), _error_info=self.cs.info(ECA_ALLOCMEM)) * raise _cafeException */ - __pyx_t_10 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6342, __pyx_L6_except_error) + __pyx_t_10 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6549, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_10); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6342, __pyx_L6_except_error) - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6342, __pyx_L6_except_error) - __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6342, __pyx_L6_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6549, __pyx_L6_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6549, __pyx_L6_except_error) + __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6549, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_handle, __pyx_t_11) < 0) __PYX_ERR(3, 6342, __pyx_L6_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_handle, __pyx_t_11) < 0) __PYX_ERR(3, 6549, __pyx_L6_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6342, __pyx_L6_except_error) + __pyx_t_11 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6549, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_pv_name, __pyx_t_11) < 0) __PYX_ERR(3, 6342, __pyx_L6_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_pv_name, __pyx_t_11) < 0) __PYX_ERR(3, 6549, __pyx_L6_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6343 + /* "PyCafe.pyx":6550 * except: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=ghandle, _pv_name=_gname, * _error_code=ECA_ALLOCMEM, _error_text=self.cs.code(ECA_ALLOCMEM), _error_info=self.cs.info(ECA_ALLOCMEM)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(ECA_ALLOCMEM); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6343, __pyx_L6_except_error) + __pyx_t_11 = __Pyx_PyInt_From_unsigned_int(ECA_ALLOCMEM); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6550, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_code, __pyx_t_11) < 0) __PYX_ERR(3, 6342, __pyx_L6_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_code, __pyx_t_11) < 0) __PYX_ERR(3, 6549, __pyx_L6_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECA_ALLOCMEM)); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6343, __pyx_L6_except_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECA_ALLOCMEM)); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6550, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_text, __pyx_t_11) < 0) __PYX_ERR(3, 6342, __pyx_L6_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_text, __pyx_t_11) < 0) __PYX_ERR(3, 6549, __pyx_L6_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECA_ALLOCMEM)); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6343, __pyx_L6_except_error) + __pyx_t_11 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECA_ALLOCMEM)); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6550, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_11); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_info, __pyx_t_11) < 0) __PYX_ERR(3, 6342, __pyx_L6_except_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_info, __pyx_t_11) < 0) __PYX_ERR(3, 6549, __pyx_L6_except_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6342 + /* "PyCafe.pyx":6549 * * except: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=ghandle, _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=ECA_ALLOCMEM, _error_text=self.cs.code(ECA_ALLOCMEM), _error_info=self.cs.info(ECA_ALLOCMEM)) * raise _cafeException */ - __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6342, __pyx_L6_except_error) + __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6549, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_11); __pyx_t_11 = 0; - /* "PyCafe.pyx":6344 + /* "PyCafe.pyx":6551 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=ghandle, _pv_name=_gname, * _error_code=ECA_ALLOCMEM, _error_text=self.cs.code(ECA_ALLOCMEM), _error_info=self.cs.info(ECA_ALLOCMEM)) * raise _cafeException # <<<<<<<<<<<<<< @@ -108726,7 +112404,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ * if status != ICAFE_NORMAL: */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6344, __pyx_L6_except_error) + __PYX_ERR(3, 6551, __pyx_L6_except_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; @@ -108734,7 +112412,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ } __pyx_L6_except_error:; - /* "PyCafe.pyx":6332 + /* "PyCafe.pyx":6539 * cdef char * _gname = gname * * try: # <<<<<<<<<<<<<< @@ -108754,7 +112432,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ __pyx_L9_try_end:; } - /* "PyCafe.pyx":6346 + /* "PyCafe.pyx":6553 * raise _cafeException * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -108764,60 +112442,60 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ __pyx_t_3 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6347 + /* "PyCafe.pyx":6554 * * if status != ICAFE_NORMAL: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=ghandle, _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_9 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6347, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6347, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6347, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6347, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6554, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6554, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_handle, __pyx_t_1) < 0) __PYX_ERR(3, 6347, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_handle, __pyx_t_1) < 0) __PYX_ERR(3, 6554, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6347, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyStr_FromString(__pyx_v__gname); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_pv_name, __pyx_t_1) < 0) __PYX_ERR(3, 6347, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_pv_name, __pyx_t_1) < 0) __PYX_ERR(3, 6554, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":6348 + /* "PyCafe.pyx":6555 * if status != ICAFE_NORMAL: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=ghandle, _pv_name=_gname, * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6348, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_code, __pyx_t_1) < 0) __PYX_ERR(3, 6347, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_code, __pyx_t_1) < 0) __PYX_ERR(3, 6554, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6348, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_text, __pyx_t_1) < 0) __PYX_ERR(3, 6347, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_text, __pyx_t_1) < 0) __PYX_ERR(3, 6554, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6348, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_info, __pyx_t_1) < 0) __PYX_ERR(3, 6347, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_info, __pyx_t_1) < 0) __PYX_ERR(3, 6554, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":6347 + /* "PyCafe.pyx":6554 * * if status != ICAFE_NORMAL: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=ghandle, _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6347, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":6349 + /* "PyCafe.pyx":6556 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=ghandle, _pv_name=_gname, * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -108825,9 +112503,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ * return ghandle */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6349, __pyx_L1_error) + __PYX_ERR(3, 6556, __pyx_L1_error) - /* "PyCafe.pyx":6346 + /* "PyCafe.pyx":6553 * raise _cafeException * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -108836,7 +112514,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":6351 + /* "PyCafe.pyx":6558 * raise _cafeException * * return ghandle # <<<<<<<<<<<<<< @@ -108844,13 +112522,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6351, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_ghandle); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6321 + /* "PyCafe.pyx":6528 * * ################################################################################## * def groupOpen(self, char * gname): # <<<<<<<<<<<<<< @@ -108877,7 +112555,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_372groupOpen(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":6356 +/* "PyCafe.pyx":6563 * ################################################################################## * * def groupClose(self, gHandleName, bint keepGroupName=False): # <<<<<<<<<<<<<< @@ -108920,7 +112598,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_375groupClose(PyObject *__pyx_v_self, } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupClose") < 0)) __PYX_ERR(3, 6356, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "groupClose") < 0)) __PYX_ERR(3, 6563, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -108933,14 +112611,14 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_375groupClose(PyObject *__pyx_v_self, } __pyx_v_gHandleName = values[0]; if (values[1]) { - __pyx_v_keepGroupName = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_keepGroupName == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6356, __pyx_L3_error) + __pyx_v_keepGroupName = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_keepGroupName == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6563, __pyx_L3_error) } else { __pyx_v_keepGroupName = ((int)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("groupClose", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6356, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("groupClose", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6563, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.groupClose", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -108970,7 +112648,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe int __pyx_t_7; __Pyx_RefNannySetupContext("groupClose", 0); - /* "PyCafe.pyx":6357 + /* "PyCafe.pyx":6564 * * def groupClose(self, gHandleName, bint keepGroupName=False): * cdef str _METHOD = "groupClose(gHandleName)" # <<<<<<<<<<<<<< @@ -108980,7 +112658,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe __Pyx_INCREF(__pyx_kp_u_groupClose_gHandleName); __pyx_v__METHOD = __pyx_kp_u_groupClose_gHandleName; - /* "PyCafe.pyx":6359 + /* "PyCafe.pyx":6566 * cdef str _METHOD = "groupClose(gHandleName)" * * cdef unsigned int gHandle = 0 # <<<<<<<<<<<<<< @@ -108989,7 +112667,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe */ __pyx_v_gHandle = 0; - /* "PyCafe.pyx":6360 + /* "PyCafe.pyx":6567 * * cdef unsigned int gHandle = 0 * cdef str _gname = None # <<<<<<<<<<<<<< @@ -108999,7 +112677,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe __Pyx_INCREF(Py_None); __pyx_v__gname = ((PyObject*)Py_None); - /* "PyCafe.pyx":6361 + /* "PyCafe.pyx":6568 * cdef unsigned int gHandle = 0 * cdef str _gname = None * status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -109008,7 +112686,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":6363 + /* "PyCafe.pyx":6570 * status = ICAFE_NORMAL * * if isinstance(gHandleName, (int, long)): # <<<<<<<<<<<<<< @@ -109029,17 +112707,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6364 + /* "PyCafe.pyx":6571 * * if isinstance(gHandleName, (int, long)): * gHandle = gHandleName # <<<<<<<<<<<<<< * elif isinstance(gHandleName, (str)): * _gname = gHandleName */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_gHandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6364, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_gHandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6571, __pyx_L1_error) __pyx_v_gHandle = __pyx_t_4; - /* "PyCafe.pyx":6363 + /* "PyCafe.pyx":6570 * status = ICAFE_NORMAL * * if isinstance(gHandleName, (int, long)): # <<<<<<<<<<<<<< @@ -109049,7 +112727,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe goto __pyx_L3; } - /* "PyCafe.pyx":6365 + /* "PyCafe.pyx":6572 * if isinstance(gHandleName, (int, long)): * gHandle = gHandleName * elif isinstance(gHandleName, (str)): # <<<<<<<<<<<<<< @@ -109060,34 +112738,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6366 + /* "PyCafe.pyx":6573 * gHandle = gHandleName * elif isinstance(gHandleName, (str)): * _gname = gHandleName # <<<<<<<<<<<<<< * gHandle = self.checkForGroupHandle(gHandleName) * else: */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_gHandleName))||((__pyx_v_gHandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_gHandleName)->tp_name), 0))) __PYX_ERR(3, 6366, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_gHandleName))||((__pyx_v_gHandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_gHandleName)->tp_name), 0))) __PYX_ERR(3, 6573, __pyx_L1_error) __pyx_t_5 = __pyx_v_gHandleName; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v__gname, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; - /* "PyCafe.pyx":6367 + /* "PyCafe.pyx":6574 * elif isinstance(gHandleName, (str)): * _gname = gHandleName * gHandle = self.checkForGroupHandle(gHandleName) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_gHandleName))||((__pyx_v_gHandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_gHandleName)->tp_name), 0))) __PYX_ERR(3, 6367, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_gHandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6367, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_gHandleName))||((__pyx_v_gHandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_gHandleName)->tp_name), 0))) __PYX_ERR(3, 6574, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_gHandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6367, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6574, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_gHandle = __pyx_t_4; - /* "PyCafe.pyx":6365 + /* "PyCafe.pyx":6572 * if isinstance(gHandleName, (int, long)): * gHandle = gHandleName * elif isinstance(gHandleName, (str)): # <<<<<<<<<<<<<< @@ -109097,7 +112775,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe goto __pyx_L3; } - /* "PyCafe.pyx":6369 + /* "PyCafe.pyx":6576 * gHandle = self.checkForGroupHandle(gHandleName) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -109105,18 +112783,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe * raise _cafeException */ /*else*/ { - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6369, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6369, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6369, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 6369, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6369, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6576, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6576, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_9) < 0) __PYX_ERR(3, 6576, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6371 + /* "PyCafe.pyx":6578 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if group handle, else if group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -109124,11 +112802,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe * if gHandle == 0: */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6371, __pyx_L1_error) + __PYX_ERR(3, 6578, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":6373 + /* "PyCafe.pyx":6580 * raise _cafeException * * if gHandle == 0: # <<<<<<<<<<<<<< @@ -109138,7 +112816,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_gHandle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6374 + /* "PyCafe.pyx":6581 * * if gHandle == 0: * status = ECAFE_INVALID_GROUP_HANDLE # <<<<<<<<<<<<<< @@ -109147,7 +112825,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe */ __pyx_v_status = ECAFE_INVALID_GROUP_HANDLE; - /* "PyCafe.pyx":6376 + /* "PyCafe.pyx":6583 * status = ECAFE_INVALID_GROUP_HANDLE * * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -109157,7 +112835,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6377 + /* "PyCafe.pyx":6584 * * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -109166,7 +112844,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6376 + /* "PyCafe.pyx":6583 * status = ECAFE_INVALID_GROUP_HANDLE * * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -109175,57 +112853,57 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":6378 + /* "PyCafe.pyx":6585 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=gHandle, _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6378, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6378, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6378, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_gHandle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6378, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6585, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6585, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_gHandle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 6378, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 6585, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_v__gname) < 0) __PYX_ERR(3, 6378, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_v__gname) < 0) __PYX_ERR(3, 6585, __pyx_L1_error) - /* "PyCafe.pyx":6379 + /* "PyCafe.pyx":6586 * self._c_cafe.printStatusMessage(status) * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=gHandle, _pv_name=_gname, * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6379, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 6378, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 6585, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6379, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 6378, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 6585, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6379, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 6378, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 6585, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6378 + /* "PyCafe.pyx":6585 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=gHandle, _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6378, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6380 + /* "PyCafe.pyx":6587 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=gHandle, _pv_name=_gname, * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -109233,9 +112911,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6380, __pyx_L1_error) + __PYX_ERR(3, 6587, __pyx_L1_error) - /* "PyCafe.pyx":6373 + /* "PyCafe.pyx":6580 * raise _cafeException * * if gHandle == 0: # <<<<<<<<<<<<<< @@ -109244,7 +112922,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":6383 + /* "PyCafe.pyx":6590 * * * with nogil: # <<<<<<<<<<<<<< @@ -109259,7 +112937,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6384 + /* "PyCafe.pyx":6591 * * with nogil: * status = self._c_cafe.groupCloseKeepName(gHandle, keepGroupName) # <<<<<<<<<<<<<< @@ -109276,12 +112954,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif - __PYX_ERR(3, 6384, __pyx_L9_error) + __PYX_ERR(3, 6591, __pyx_L9_error) } __pyx_v_status = __pyx_t_7; } - /* "PyCafe.pyx":6383 + /* "PyCafe.pyx":6590 * * * with nogil: # <<<<<<<<<<<<<< @@ -109307,7 +112985,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe } } - /* "PyCafe.pyx":6387 + /* "PyCafe.pyx":6594 * #self.ca_pend_io(1.0) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -109317,57 +112995,57 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6388 + /* "PyCafe.pyx":6595 * * if status != ICAFE_NORMAL: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=gHandle, _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6388, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6388, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6388, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_gHandle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6388, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6595, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6595, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_gHandle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 6388, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 6595, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_v__gname) < 0) __PYX_ERR(3, 6388, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_pv_name, __pyx_v__gname) < 0) __PYX_ERR(3, 6595, __pyx_L1_error) - /* "PyCafe.pyx":6389 + /* "PyCafe.pyx":6596 * if status != ICAFE_NORMAL: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=gHandle, _pv_name=_gname, * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6389, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 6388, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 6595, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6389, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 6388, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 6595, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6389, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 6388, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 6595, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6388 + /* "PyCafe.pyx":6595 * * if status != ICAFE_NORMAL: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=gHandle, _pv_name=_gname, # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6388, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6390 + /* "PyCafe.pyx":6597 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=gHandle, _pv_name=_gname, * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -109375,9 +113053,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe * return status */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6390, __pyx_L1_error) + __PYX_ERR(3, 6597, __pyx_L1_error) - /* "PyCafe.pyx":6387 + /* "PyCafe.pyx":6594 * #self.ca_pend_io(1.0) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -109386,7 +113064,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe */ } - /* "PyCafe.pyx":6392 + /* "PyCafe.pyx":6599 * raise _cafeException * * return status # <<<<<<<<<<<<<< @@ -109394,13 +113072,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6392, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6356 + /* "PyCafe.pyx":6563 * ################################################################################## * * def groupClose(self, gHandleName, bint keepGroupName=False): # <<<<<<<<<<<<<< @@ -109425,7 +113103,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_374groupClose(struct __pyx_obj_6PyCafe return __pyx_r; } -/* "PyCafe.pyx":6396 +/* "PyCafe.pyx":6603 * * * def isGroup(self, const char * gName): # <<<<<<<<<<<<<< @@ -109441,7 +113119,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_377isGroup(PyObject *__pyx_v_self, PyO __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("isGroup (wrapper)", 0); assert(__pyx_arg_gName); { - __pyx_v_gName = __Pyx_PyObject_AsString(__pyx_arg_gName); if (unlikely((!__pyx_v_gName) && PyErr_Occurred())) __PYX_ERR(3, 6396, __pyx_L3_error) + __pyx_v_gName = __Pyx_PyObject_AsString(__pyx_arg_gName); if (unlikely((!__pyx_v_gName) && PyErr_Occurred())) __PYX_ERR(3, 6603, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -109462,7 +113140,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_376isGroup(struct __pyx_obj_6PyCafe_Cy PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("isGroup", 0); - /* "PyCafe.pyx":6397 + /* "PyCafe.pyx":6604 * * def isGroup(self, const char * gName): * return self._c_cafe.isGroup(gName) # <<<<<<<<<<<<<< @@ -109470,13 +113148,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_376isGroup(struct __pyx_obj_6PyCafe_Cy * def isCollection(self, const char * cName): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->isGroup(__pyx_v_gName)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6397, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->isGroup(__pyx_v_gName)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6396 + /* "PyCafe.pyx":6603 * * * def isGroup(self, const char * gName): # <<<<<<<<<<<<<< @@ -109497,7 +113175,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_376isGroup(struct __pyx_obj_6PyCafe_Cy return __pyx_r; } -/* "PyCafe.pyx":6399 +/* "PyCafe.pyx":6606 * return self._c_cafe.isGroup(gName) * * def isCollection(self, const char * cName): # <<<<<<<<<<<<<< @@ -109513,7 +113191,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_379isCollection(PyObject *__pyx_v_self __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("isCollection (wrapper)", 0); assert(__pyx_arg_cName); { - __pyx_v_cName = __Pyx_PyObject_AsString(__pyx_arg_cName); if (unlikely((!__pyx_v_cName) && PyErr_Occurred())) __PYX_ERR(3, 6399, __pyx_L3_error) + __pyx_v_cName = __Pyx_PyObject_AsString(__pyx_arg_cName); if (unlikely((!__pyx_v_cName) && PyErr_Occurred())) __PYX_ERR(3, 6606, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -109534,7 +113212,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_378isCollection(struct __pyx_obj_6PyCa PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("isCollection", 0); - /* "PyCafe.pyx":6400 + /* "PyCafe.pyx":6607 * * def isCollection(self, const char * cName): * return self._c_cafe.isCollection(cName) # <<<<<<<<<<<<<< @@ -109542,13 +113220,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_378isCollection(struct __pyx_obj_6PyCa * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->isCollection(__pyx_v_cName)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6400, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_c_cafe->isCollection(__pyx_v_cName)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6607, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6399 + /* "PyCafe.pyx":6606 * return self._c_cafe.isGroup(gName) * * def isCollection(self, const char * cName): # <<<<<<<<<<<<<< @@ -109569,7 +113247,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_378isCollection(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":6405 +/* "PyCafe.pyx":6612 * ################################################################################## * @verify_handlepv * def getNoMonitors(self, handlePV): # <<<<<<<<<<<<<< @@ -109598,17 +113276,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_380getNoMonitors(struct __pyx_obj_6PyC PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getNoMonitors", 0); - /* "PyCafe.pyx":6406 + /* "PyCafe.pyx":6613 * @verify_handlepv * def getNoMonitors(self, handlePV): * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * return self.hh.getNmonitor(handle) * ################################################################################## */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6406, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6613, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":6407 + /* "PyCafe.pyx":6614 * def getNoMonitors(self, handlePV): * cdef unsigned int handle = handlePV * return self.hh.getNmonitor(handle) # <<<<<<<<<<<<<< @@ -109616,13 +113294,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_380getNoMonitors(struct __pyx_obj_6PyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNmonitor(__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6407, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNmonitor(__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6405 + /* "PyCafe.pyx":6612 * ################################################################################## * @verify_handlepv * def getNoMonitors(self, handlePV): # <<<<<<<<<<<<<< @@ -109643,7 +113321,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_380getNoMonitors(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":6413 +/* "PyCafe.pyx":6620 * ################################################################################## * @verify_handlepv * def getMonitorIDsInWaiting(self, handlePV): # <<<<<<<<<<<<<< @@ -109672,17 +113350,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_382getMonitorIDsInWaiting(struct __pyx PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getMonitorIDsInWaiting", 0); - /* "PyCafe.pyx":6414 + /* "PyCafe.pyx":6621 * @verify_handlepv * def getMonitorIDsInWaiting(self, handlePV): * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * return self.hh.getMonitorIDsInWaiting(handle) * ############################################################################ */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6414, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6621, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":6415 + /* "PyCafe.pyx":6622 * def getMonitorIDsInWaiting(self, handlePV): * cdef unsigned int handle = handlePV * return self.hh.getMonitorIDsInWaiting(handle) # <<<<<<<<<<<<<< @@ -109690,13 +113368,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_382getMonitorIDsInWaiting(struct __pyx * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_self->hh.getMonitorIDsInWaiting(__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6415, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_self->hh.getMonitorIDsInWaiting(__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6622, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6413 + /* "PyCafe.pyx":6620 * ################################################################################## * @verify_handlepv * def getMonitorIDsInWaiting(self, handlePV): # <<<<<<<<<<<<<< @@ -109717,7 +113395,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_382getMonitorIDsInWaiting(struct __pyx return __pyx_r; } -/* "PyCafe.pyx":6421 +/* "PyCafe.pyx":6628 * ################################################################################## * @verify_handlepv * def getMonitorIDs(self, handlePV): # <<<<<<<<<<<<<< @@ -109746,17 +113424,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_384getMonitorIDs(struct __pyx_obj_6PyC PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("getMonitorIDs", 0); - /* "PyCafe.pyx":6422 + /* "PyCafe.pyx":6629 * @verify_handlepv * def getMonitorIDs(self, handlePV): * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * return self.hh.getMonitorIDs(handle) * ############################################################################ */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6422, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6629, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":6423 + /* "PyCafe.pyx":6630 * def getMonitorIDs(self, handlePV): * cdef unsigned int handle = handlePV * return self.hh.getMonitorIDs(handle) # <<<<<<<<<<<<<< @@ -109764,13 +113442,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_384getMonitorIDs(struct __pyx_obj_6PyC * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_self->hh.getMonitorIDs(__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6423, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_unsigned_int(__pyx_v_self->hh.getMonitorIDs(__pyx_v_handle)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6630, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6421 + /* "PyCafe.pyx":6628 * ################################################################################## * @verify_handlepv * def getMonitorIDs(self, handlePV): # <<<<<<<<<<<<<< @@ -109791,7 +113469,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_384getMonitorIDs(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":6427 +/* "PyCafe.pyx":6634 * * @verify_handlepv * def updateMonitorPolicyDeltaMS( # <<<<<<<<<<<<<< @@ -109843,7 +113521,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_387updateMonitorPolicyDeltaMS(PyObject } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "updateMonitorPolicyDeltaMS") < 0)) __PYX_ERR(3, 6427, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "updateMonitorPolicyDeltaMS") < 0)) __PYX_ERR(3, 6634, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -109858,19 +113536,19 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_387updateMonitorPolicyDeltaMS(PyObject } __pyx_v_handlePV = values[0]; if (values[1]) { - __pyx_v_monid = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_monid == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6428, __pyx_L3_error) + __pyx_v_monid = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_monid == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6635, __pyx_L3_error) } else { __pyx_v_monid = ((unsigned int)0); } if (values[2]) { - __pyx_v_deltaMS = __Pyx_PyInt_As_unsigned_int(values[2]); if (unlikely((__pyx_v_deltaMS == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6428, __pyx_L3_error) + __pyx_v_deltaMS = __Pyx_PyInt_As_unsigned_int(values[2]); if (unlikely((__pyx_v_deltaMS == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6635, __pyx_L3_error) } else { __pyx_v_deltaMS = ((unsigned int)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("updateMonitorPolicyDeltaMS", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6427, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("updateMonitorPolicyDeltaMS", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6634, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.updateMonitorPolicyDeltaMS", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -109890,17 +113568,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_386updateMonitorPolicyDeltaMS(struct _ unsigned int __pyx_t_1; __Pyx_RefNannySetupContext("updateMonitorPolicyDeltaMS", 0); - /* "PyCafe.pyx":6429 + /* "PyCafe.pyx":6636 * def updateMonitorPolicyDeltaMS( * self, handlePV, unsigned int monid=0, unsigned int deltaMS=0): * cdef unsigned int handle = handlePV # <<<<<<<<<<<<<< * self.hh.updateMonitorPolicyDeltaMS(handle, monid, deltaMS) * */ - __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6429, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6636, __pyx_L1_error) __pyx_v_handle = __pyx_t_1; - /* "PyCafe.pyx":6430 + /* "PyCafe.pyx":6637 * self, handlePV, unsigned int monid=0, unsigned int deltaMS=0): * cdef unsigned int handle = handlePV * self.hh.updateMonitorPolicyDeltaMS(handle, monid, deltaMS) # <<<<<<<<<<<<<< @@ -109909,7 +113587,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_386updateMonitorPolicyDeltaMS(struct _ */ (void)(__pyx_v_self->hh.updateMonitorPolicyDeltaMS(__pyx_v_handle, __pyx_v_monid, __pyx_v_deltaMS)); - /* "PyCafe.pyx":6427 + /* "PyCafe.pyx":6634 * * @verify_handlepv * def updateMonitorPolicyDeltaMS( # <<<<<<<<<<<<<< @@ -109929,7 +113607,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_386updateMonitorPolicyDeltaMS(struct _ return __pyx_r; } -/* "PyCafe.pyx":6435 +/* "PyCafe.pyx":6642 * * ############################################################################ * def monitor( # <<<<<<<<<<<<<< @@ -109952,7 +113630,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_389monitor(PyObject *__pyx_v_self, PyO static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_handlePV,&__pyx_n_s_cb,&__pyx_n_s_dbr,&__pyx_n_s_mask_2,&__pyx_n_s_notify_milliseconds,0}; PyObject* values[5] = {0,0,0,0,0}; - /* "PyCafe.pyx":6436 + /* "PyCafe.pyx":6643 * ############################################################################ * def monitor( * self, handlePV, object cb=None, DBR_TYPE dbr=DBR_TIME, # <<<<<<<<<<<<<< @@ -110008,7 +113686,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_389monitor(PyObject *__pyx_v_self, PyO } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "monitor") < 0)) __PYX_ERR(3, 6435, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "monitor") < 0)) __PYX_ERR(3, 6642, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -110028,24 +113706,24 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_389monitor(PyObject *__pyx_v_self, PyO __pyx_v_handlePV = values[0]; __pyx_v_cb = values[1]; if (values[2]) { - __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6436, __pyx_L3_error) + __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6643, __pyx_L3_error) } else { - __pyx_v_dbr = __pyx_k__115; + __pyx_v_dbr = __pyx_k__110; } if (values[3]) { - __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6437, __pyx_L3_error) + __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6644, __pyx_L3_error) } else { - __pyx_v_mask = __pyx_k__116; + __pyx_v_mask = __pyx_k__111; } if (values[4]) { - __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 6438, __pyx_L3_error) + __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 6645, __pyx_L3_error) } else { __pyx_v_notify_milliseconds = ((unsigned short)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("monitor", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6435, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("monitor", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6642, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.monitor", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -110053,7 +113731,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_389monitor(PyObject *__pyx_v_self, PyO __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6PyCafe_6CyCafe_388monitor(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_cb, __pyx_v_dbr, __pyx_v_mask, __pyx_v_notify_milliseconds); - /* "PyCafe.pyx":6435 + /* "PyCafe.pyx":6642 * * ############################################################################ * def monitor( # <<<<<<<<<<<<<< @@ -110079,7 +113757,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_388monitor(struct __pyx_obj_6PyCafe_Cy PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("monitor", 0); - /* "PyCafe.pyx":6440 + /* "PyCafe.pyx":6647 * unsigned short notify_milliseconds=0): * * return self.monitorStart(handlePV, cb, dbr, mask, notify_milliseconds) # <<<<<<<<<<<<<< @@ -110087,13 +113765,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_388monitor(struct __pyx_obj_6PyCafe_Cy * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_monitorStart); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6440, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_monitorStart); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_From_DBR_TYPE(__pyx_v_dbr); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6440, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_DBR_TYPE(__pyx_v_dbr); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6440, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 6647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyInt_From_unsigned_short(__pyx_v_notify_milliseconds); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6440, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_short(__pyx_v_notify_milliseconds); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; @@ -110110,7 +113788,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_388monitor(struct __pyx_obj_6PyCafe_Cy #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[6] = {__pyx_t_6, __pyx_v_handlePV, __pyx_v_cb, __pyx_t_3, __pyx_t_4, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 5+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6440, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 5+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6647, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -110121,7 +113799,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_388monitor(struct __pyx_obj_6PyCafe_Cy #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[6] = {__pyx_t_6, __pyx_v_handlePV, __pyx_v_cb, __pyx_t_3, __pyx_t_4, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 5+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6440, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 5+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6647, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -110130,7 +113808,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_388monitor(struct __pyx_obj_6PyCafe_Cy } else #endif { - __pyx_t_8 = PyTuple_New(5+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6440, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(5+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; @@ -110150,7 +113828,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_388monitor(struct __pyx_obj_6PyCafe_Cy __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6440, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } @@ -110159,7 +113837,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_388monitor(struct __pyx_obj_6PyCafe_Cy __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6435 + /* "PyCafe.pyx":6642 * * ############################################################################ * def monitor( # <<<<<<<<<<<<<< @@ -110186,7 +113864,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_388monitor(struct __pyx_obj_6PyCafe_Cy return __pyx_r; } -/* "PyCafe.pyx":6443 +/* "PyCafe.pyx":6650 * * ############################################################################ * def monitorStart( # <<<<<<<<<<<<<< @@ -110209,7 +113887,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_391monitorStart(PyObject *__pyx_v_self static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_handlePV,&__pyx_n_s_cb,&__pyx_n_s_dbr,&__pyx_n_s_mask_2,&__pyx_n_s_notify_milliseconds,0}; PyObject* values[5] = {0,0,0,0,0}; - /* "PyCafe.pyx":6444 + /* "PyCafe.pyx":6651 * ############################################################################ * def monitorStart( * self, handlePV, cb: object = None, DBR_TYPE dbr=DBR_TIME, # <<<<<<<<<<<<<< @@ -110265,7 +113943,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_391monitorStart(PyObject *__pyx_v_self } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "monitorStart") < 0)) __PYX_ERR(3, 6443, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "monitorStart") < 0)) __PYX_ERR(3, 6650, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -110285,24 +113963,24 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_391monitorStart(PyObject *__pyx_v_self __pyx_v_handlePV = values[0]; __pyx_v_cb = values[1]; if (values[2]) { - __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6444, __pyx_L3_error) + __pyx_v_dbr = ((DBR_TYPE)__Pyx_PyInt_As_DBR_TYPE(values[2])); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6651, __pyx_L3_error) } else { - __pyx_v_dbr = __pyx_k__117; + __pyx_v_dbr = __pyx_k__112; } if (values[3]) { - __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6445, __pyx_L3_error) + __pyx_v_mask = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_mask == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6652, __pyx_L3_error) } else { - __pyx_v_mask = __pyx_k__118; + __pyx_v_mask = __pyx_k__113; } if (values[4]) { - __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 6446, __pyx_L3_error) + __pyx_v_notify_milliseconds = __Pyx_PyInt_As_unsigned_short(values[4]); if (unlikely((__pyx_v_notify_milliseconds == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 6653, __pyx_L3_error) } else { __pyx_v_notify_milliseconds = ((unsigned short)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("monitorStart", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6443, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("monitorStart", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6650, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.monitorStart", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -110310,7 +113988,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_391monitorStart(PyObject *__pyx_v_self __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6PyCafe_6CyCafe_390monitorStart(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePV, __pyx_v_cb, __pyx_v_dbr, __pyx_v_mask, __pyx_v_notify_milliseconds); - /* "PyCafe.pyx":6443 + /* "PyCafe.pyx":6650 * * ############################################################################ * def monitorStart( # <<<<<<<<<<<<<< @@ -110345,7 +114023,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa Py_ssize_t __pyx_t_8; __Pyx_RefNannySetupContext("monitorStart", 0); - /* "PyCafe.pyx":6448 + /* "PyCafe.pyx":6655 * unsigned short notify_milliseconds=0): * * _METHOD = "monitorStart(handlePV, object cb=None, \ # <<<<<<<<<<<<<< @@ -110355,7 +114033,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_kp_u_monitorStart_handlePV_object_cb); __pyx_v__METHOD = __pyx_kp_u_monitorStart_handlePV_object_cb; - /* "PyCafe.pyx":6452 + /* "PyCafe.pyx":6659 * unsigned int mask=DBE_VALUE|DBE_LOG|DBE_ALARM)" * * pv = None # <<<<<<<<<<<<<< @@ -110365,7 +114043,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __Pyx_INCREF(Py_None); __pyx_v_pv = Py_None; - /* "PyCafe.pyx":6453 + /* "PyCafe.pyx":6660 * * pv = None * cdef int status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -110374,7 +114052,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":6458 + /* "PyCafe.pyx":6665 * # my_callback=callbackHandlerMonitor * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -110383,7 +114061,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_handle = 0; - /* "PyCafe.pyx":6459 + /* "PyCafe.pyx":6666 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -110404,17 +114082,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6460 + /* "PyCafe.pyx":6667 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * pv = handlePV */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6460, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6667, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":6459 + /* "PyCafe.pyx":6666 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -110424,7 +114102,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa goto __pyx_L3; } - /* "PyCafe.pyx":6461 + /* "PyCafe.pyx":6668 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -110435,7 +114113,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6462 + /* "PyCafe.pyx":6669 * handle = handlePV * elif isinstance(handlePV, (str)): * pv = handlePV # <<<<<<<<<<<<<< @@ -110445,21 +114123,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_v_handlePV); __Pyx_DECREF_SET(__pyx_v_pv, __pyx_v_handlePV); - /* "PyCafe.pyx":6463 + /* "PyCafe.pyx":6670 * elif isinstance(handlePV, (str)): * pv = handlePV * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 6463, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6463, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 6670, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6670, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6463, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6670, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":6461 + /* "PyCafe.pyx":6668 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -110469,7 +114147,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa goto __pyx_L3; } - /* "PyCafe.pyx":6465 + /* "PyCafe.pyx":6672 * handle = self.checkForHandle(handlePV) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< @@ -110478,33 +114156,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ /*else*/ { - /* "PyCafe.pyx":6466 + /* "PyCafe.pyx":6673 * else: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _error_info="First input argument, should be of type if handle, \ * else if PV") */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6466, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6673, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6466, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6466, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_10) < 0) __PYX_ERR(3, 6466, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6673, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6673, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_10) < 0) __PYX_ERR(3, 6673, __pyx_L1_error) - /* "PyCafe.pyx":6465 + /* "PyCafe.pyx":6672 * handle = self.checkForHandle(handlePV) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if handle, \ */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6465, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6469 + /* "PyCafe.pyx":6676 * _error_info="First input argument, should be of type if handle, \ * else if PV") * raise _cafeException # <<<<<<<<<<<<<< @@ -110512,11 +114190,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa * # Does channel Exist? */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6469, __pyx_L1_error) + __PYX_ERR(3, 6676, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":6472 + /* "PyCafe.pyx":6679 * * # Does channel Exist? * if not self._c_cafe.isValid(handle): # <<<<<<<<<<<<<< @@ -110526,7 +114204,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_t_1 = ((!(__pyx_v_self->_c_cafe->isValid(__pyx_v_handle) != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6473 + /* "PyCafe.pyx":6680 * # Does channel Exist? * if not self._c_cafe.isValid(handle): * status = ECAFE_INVALID_HANDLE # <<<<<<<<<<<<<< @@ -110535,7 +114213,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_status = ECAFE_INVALID_HANDLE; - /* "PyCafe.pyx":6474 + /* "PyCafe.pyx":6681 * if not self._c_cafe.isValid(handle): * status = ECAFE_INVALID_HANDLE * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -110545,65 +114223,65 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_t_1 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6476 + /* "PyCafe.pyx":6683 * if self._enable_exceptions: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, _pv_name=pv, # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6476, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6683, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6476, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6476, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6476, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6683, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6683, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6683, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 6476, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_handle, __pyx_t_5) < 0) __PYX_ERR(3, 6683, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_v_pv) < 0) __PYX_ERR(3, 6476, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_pv_name, __pyx_v_pv) < 0) __PYX_ERR(3, 6683, __pyx_L1_error) - /* "PyCafe.pyx":6477 + /* "PyCafe.pyx":6684 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _handle=handle, _pv_name=pv, * _error_code=status, _error_text=self.cs.code(status), # <<<<<<<<<<<<<< * _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6477, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 6476, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 6683, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6477, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 6476, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 6683, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6478 + /* "PyCafe.pyx":6685 * _type='CafeError', _source=_METHOD, _handle=handle, _pv_name=pv, * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * return status */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6478, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 6476, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 6683, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6475 + /* "PyCafe.pyx":6682 * status = ECAFE_INVALID_HANDLE * if self._enable_exceptions: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _handle=handle, _pv_name=pv, * _error_code=status, _error_text=self.cs.code(status), */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6475, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6682, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6479 + /* "PyCafe.pyx":6686 * _error_code=status, _error_text=self.cs.code(status), * _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -110611,9 +114289,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6479, __pyx_L1_error) + __PYX_ERR(3, 6686, __pyx_L1_error) - /* "PyCafe.pyx":6474 + /* "PyCafe.pyx":6681 * if not self._c_cafe.isValid(handle): * status = ECAFE_INVALID_HANDLE * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -110622,7 +114300,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":6480 + /* "PyCafe.pyx":6687 * _error_info=self.cs.info(status)) * raise _cafeException * return status # <<<<<<<<<<<<<< @@ -110630,13 +114308,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa * cdef MonitorPolicy mp */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6480, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6472 + /* "PyCafe.pyx":6679 * * # Does channel Exist? * if not self._c_cafe.isValid(handle): # <<<<<<<<<<<<<< @@ -110645,7 +114323,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":6483 + /* "PyCafe.pyx":6690 * * cdef MonitorPolicy mp * cdef unsigned long mpid = mp.getMonitorID() # <<<<<<<<<<<<<< @@ -110654,7 +114332,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_mpid = __pyx_v_mp.getMonitorID(); - /* "PyCafe.pyx":6487 + /* "PyCafe.pyx":6694 * # For setUserArgs pass the address of the variable. * * mp.setMask(mask) # <<<<<<<<<<<<<< @@ -110663,7 +114341,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_mp.setMask(__pyx_v_mask); - /* "PyCafe.pyx":6488 + /* "PyCafe.pyx":6695 * * mp.setMask(mask) * mp.setNotifyDeltaMilliSeconds(notify_milliseconds) # <<<<<<<<<<<<<< @@ -110672,7 +114350,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_mp.setNotifyDeltaMilliSeconds(__pyx_v_notify_milliseconds); - /* "PyCafe.pyx":6491 + /* "PyCafe.pyx":6698 * * #print ("dbr=", dbr) * self._c_cafe.getChannelInfo(handle, self.channelInfo) # <<<<<<<<<<<<<< @@ -110681,7 +114359,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ (void)(__pyx_v_self->_c_cafe->getChannelInfo(__pyx_v_handle, __pyx_v_self->channelInfo)); - /* "PyCafe.pyx":6494 + /* "PyCafe.pyx":6701 * #print ("nativeDataType=", self.channelInfo.getDataType()) * * if dbr in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: # <<<<<<<<<<<<<< @@ -110695,7 +114373,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa case DBR_GR: case DBR_CTRL: - /* "PyCafe.pyx":6496 + /* "PyCafe.pyx":6703 * if dbr in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: * # set Native Datatype first * mp.setDataType(self.channelInfo.getDataType()) # <<<<<<<<<<<<<< @@ -110704,7 +114382,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_mp.setDataType(__pyx_v_self->channelInfo.getDataType()); - /* "PyCafe.pyx":6497 + /* "PyCafe.pyx":6704 * # set Native Datatype first * mp.setDataType(self.channelInfo.getDataType()) * mp.setCafeDbrType(dbr) # <<<<<<<<<<<<<< @@ -110713,7 +114391,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_mp.setCafeDbrType(__pyx_v_dbr); - /* "PyCafe.pyx":6494 + /* "PyCafe.pyx":6701 * #print ("nativeDataType=", self.channelInfo.getDataType()) * * if dbr in [DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL]: # <<<<<<<<<<<<<< @@ -110723,14 +114401,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa break; default: - /* "PyCafe.pyx":6501 + /* "PyCafe.pyx":6708 * #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") */ - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6501, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_kp_u_Warning_from_monitorStart_for_h); __Pyx_GIVEREF(__pyx_kp_u_Warning_from_monitorStart_for_h); @@ -110738,34 +114416,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_v_handlePV); __Pyx_GIVEREF(__pyx_v_handlePV); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_handlePV); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6501, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6502 + /* "PyCafe.pyx":6709 * 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") */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__119, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6502, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__114, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6709, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6504 + /* "PyCafe.pyx":6711 * 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) */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6504, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6505 + /* "PyCafe.pyx":6712 * DBR_PLAIN, DBR_STS, DBR_TIME, DBR_GR, DBR_CTRL") * print("Assuming DBR_TIME") * mp.setDataType(self.channelInfo.getDataType()) # <<<<<<<<<<<<<< @@ -110774,7 +114452,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_mp.setDataType(__pyx_v_self->channelInfo.getDataType()); - /* "PyCafe.pyx":6506 + /* "PyCafe.pyx":6713 * print("Assuming DBR_TIME") * mp.setDataType(self.channelInfo.getDataType()) * mp.setCafeDbrType(DBR_TIME) # <<<<<<<<<<<<<< @@ -110785,7 +114463,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa break; } - /* "PyCafe.pyx":6510 + /* "PyCafe.pyx":6717 * global hmd * * if cb is not None: # <<<<<<<<<<<<<< @@ -110796,32 +114474,32 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6512 + /* "PyCafe.pyx":6719 * if cb is not None: * #Cement to a global dictionary * hmd[cb] = mpid ##otherwise cb gets ovewritten when casting to an object # <<<<<<<<<<<<<< * * sig = inspect.signature(cb) */ - __pyx_t_6 = __Pyx_PyInt_From_unsigned_long(__pyx_v_mpid); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6512, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_long(__pyx_v_mpid); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6512, __pyx_L1_error) + __PYX_ERR(3, 6719, __pyx_L1_error) } - if (unlikely(PyDict_SetItem(__pyx_v_6PyCafe_hmd, __pyx_v_cb, __pyx_t_6) < 0)) __PYX_ERR(3, 6512, __pyx_L1_error) + if (unlikely(PyDict_SetItem(__pyx_v_6PyCafe_hmd, __pyx_v_cb, __pyx_t_6) < 0)) __PYX_ERR(3, 6719, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6514 + /* "PyCafe.pyx":6721 * hmd[cb] = mpid ##otherwise cb gets ovewritten when casting to an object * * sig = inspect.signature(cb) # <<<<<<<<<<<<<< * * # The corresponding setPyHandler has to be set!! */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_inspect); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6514, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_inspect); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_signature); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6514, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_signature); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -110836,13 +114514,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa } __pyx_t_6 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_5, __pyx_v_cb) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_cb); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6514, __pyx_L1_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_sig = __pyx_t_6; __pyx_t_6 = 0; - /* "PyCafe.pyx":6518 + /* "PyCafe.pyx":6725 * # The corresponding setPyHandler has to be set!! * * mp.setUserArgs(< void * > mpid) # <<<<<<<<<<<<<< @@ -110851,20 +114529,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_mp.setUserArgs(((void *)__pyx_v_mpid)); - /* "PyCafe.pyx":6519 + /* "PyCafe.pyx":6726 * * mp.setUserArgs(< void * > mpid) * mp.setNoCyCallbackParameters(len(sig.parameters)) # <<<<<<<<<<<<<< * mp.setPyCyHandler( cb) * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6519, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_parameters); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6726, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = PyObject_Length(__pyx_t_6); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6519, __pyx_L1_error) + __pyx_t_8 = PyObject_Length(__pyx_t_6); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6726, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_mp.setNoCyCallbackParameters(__pyx_t_8); - /* "PyCafe.pyx":6520 + /* "PyCafe.pyx":6727 * mp.setUserArgs(< void * > mpid) * mp.setNoCyCallbackParameters(len(sig.parameters)) * mp.setPyCyHandler( cb) # <<<<<<<<<<<<<< @@ -110873,7 +114551,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_mp.setPyCyHandler(((void *)__pyx_v_cb)); - /* "PyCafe.pyx":6510 + /* "PyCafe.pyx":6717 * global hmd * * if cb is not None: # <<<<<<<<<<<<<< @@ -110882,7 +114560,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":6522 + /* "PyCafe.pyx":6729 * mp.setPyCyHandler( cb) * * with nogil: # <<<<<<<<<<<<<< @@ -110897,7 +114575,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa #endif /*try:*/ { - /* "PyCafe.pyx":6523 + /* "PyCafe.pyx":6730 * * with nogil: * status = self._c_cafe.monitorStart(handle, mp) # <<<<<<<<<<<<<< @@ -110907,7 +114585,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_v_status = __pyx_v_self->_c_cafe->monitorStart(__pyx_v_handle, __pyx_v_mp); } - /* "PyCafe.pyx":6522 + /* "PyCafe.pyx":6729 * mp.setPyCyHandler( cb) * * with nogil: # <<<<<<<<<<<<<< @@ -110926,7 +114604,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa } } - /* "PyCafe.pyx":6527 + /* "PyCafe.pyx":6734 * # Need this to allow a fraction of a second for the callback fn to be called * # if setPyHandler is used * cdef short wtfsb = self._c_cafe.channelOpenGroupPolicy.getWhenToFlushSendBuffer() # <<<<<<<<<<<<<< @@ -110935,7 +114613,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_wtfsb = __pyx_v_self->_c_cafe->channelOpenGroupPolicy.getWhenToFlushSendBuffer(); - /* "PyCafe.pyx":6528 + /* "PyCafe.pyx":6735 * # if setPyHandler is used * cdef short wtfsb = self._c_cafe.channelOpenGroupPolicy.getWhenToFlushSendBuffer() * if wtfsb == FLUSH_NOW: # <<<<<<<<<<<<<< @@ -110945,16 +114623,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_t_2 = ((__pyx_v_wtfsb == FLUSH_NOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6530 + /* "PyCafe.pyx":6737 * if wtfsb == FLUSH_NOW: * # if self.getMonitorWhenToFlushSendBuffer() == FLUSH_NOW: * time.sleep(0.01) # <<<<<<<<<<<<<< * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6530, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_sleep); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6530, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_sleep); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -110969,12 +114647,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa } __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_float_0_01) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_float_0_01); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6530, __pyx_L1_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6528 + /* "PyCafe.pyx":6735 * # if setPyHandler is used * cdef short wtfsb = self._c_cafe.channelOpenGroupPolicy.getWhenToFlushSendBuffer() * if wtfsb == FLUSH_NOW: # <<<<<<<<<<<<<< @@ -110983,7 +114661,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":6531 + /* "PyCafe.pyx":6738 * # if self.getMonitorWhenToFlushSendBuffer() == FLUSH_NOW: * time.sleep(0.01) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -110993,7 +114671,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6532 + /* "PyCafe.pyx":6739 * time.sleep(0.01) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -111003,7 +114681,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6533 + /* "PyCafe.pyx":6740 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -111013,7 +114691,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa __pyx_t_2 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6534 + /* "PyCafe.pyx":6741 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -111022,7 +114700,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6533 + /* "PyCafe.pyx":6740 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -111032,7 +114710,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa goto __pyx_L15; } - /* "PyCafe.pyx":6536 + /* "PyCafe.pyx":6743 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -111044,7 +114722,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa } __pyx_L15:; - /* "PyCafe.pyx":6532 + /* "PyCafe.pyx":6739 * time.sleep(0.01) * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -111053,7 +114731,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":6531 + /* "PyCafe.pyx":6738 * # if self.getMonitorWhenToFlushSendBuffer() == FLUSH_NOW: * time.sleep(0.01) * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -111062,7 +114740,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":6538 + /* "PyCafe.pyx":6745 * self._c_cafe.printStatus(handle, status) * * return mpid # <<<<<<<<<<<<<< @@ -111070,13 +114748,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_unsigned_long(__pyx_v_mpid); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6538, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_long(__pyx_v_mpid); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6443 + /* "PyCafe.pyx":6650 * * ############################################################################ * def monitorStart( # <<<<<<<<<<<<<< @@ -111103,7 +114781,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_390monitorStart(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":6543 +/* "PyCafe.pyx":6750 * ############################################################################ * * def monitorStop(self, handlePV, mpid=None): # <<<<<<<<<<<<<< @@ -111147,7 +114825,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_393monitorStop(PyObject *__pyx_v_self, } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "monitorStop") < 0)) __PYX_ERR(3, 6543, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "monitorStop") < 0)) __PYX_ERR(3, 6750, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -111163,7 +114841,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_393monitorStop(PyObject *__pyx_v_self, } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("monitorStop", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6543, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("monitorStop", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6750, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.monitorStop", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -111199,7 +114877,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf PyObject *__pyx_t_10 = NULL; __Pyx_RefNannySetupContext("monitorStop", 0); - /* "PyCafe.pyx":6544 + /* "PyCafe.pyx":6751 * * def monitorStop(self, handlePV, mpid=None): * cdef str _METHOD = "monitorStop(handlePV, mpid=None)" # <<<<<<<<<<<<<< @@ -111209,7 +114887,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __Pyx_INCREF(__pyx_kp_u_monitorStop_handlePV_mpid_None); __pyx_v__METHOD = __pyx_kp_u_monitorStop_handlePV_mpid_None; - /* "PyCafe.pyx":6546 + /* "PyCafe.pyx":6753 * cdef str _METHOD = "monitorStop(handlePV, mpid=None)" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -111218,7 +114896,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ __pyx_v_handle = 0; - /* "PyCafe.pyx":6547 + /* "PyCafe.pyx":6754 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -111239,17 +114917,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6548 + /* "PyCafe.pyx":6755 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6548, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6755, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":6547 + /* "PyCafe.pyx":6754 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -111259,7 +114937,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf goto __pyx_L3; } - /* "PyCafe.pyx":6549 + /* "PyCafe.pyx":6756 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -111270,21 +114948,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6550 + /* "PyCafe.pyx":6757 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 6550, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6550, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 6757, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6550, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6757, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":6549 + /* "PyCafe.pyx":6756 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -111294,7 +114972,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf goto __pyx_L3; } - /* "PyCafe.pyx":6552 + /* "PyCafe.pyx":6759 * handle = self.checkForHandle(handlePV) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< @@ -111303,33 +114981,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ /*else*/ { - /* "PyCafe.pyx":6553 + /* "PyCafe.pyx":6760 * else: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _error_info="First input argument, should be of type if handle, \ * else if PV") */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6553, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6760, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6553, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6553, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_3) < 0) __PYX_ERR(3, 6553, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6760, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6760, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_3) < 0) __PYX_ERR(3, 6760, __pyx_L1_error) - /* "PyCafe.pyx":6552 + /* "PyCafe.pyx":6759 * handle = self.checkForHandle(handlePV) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if handle, \ */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6552, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6759, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6556 + /* "PyCafe.pyx":6763 * _error_info="First input argument, should be of type if handle, \ * else if PV") * raise _cafeException # <<<<<<<<<<<<<< @@ -111337,31 +115015,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf * cdef int status */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6556, __pyx_L1_error) + __PYX_ERR(3, 6763, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":6563 + /* "PyCafe.pyx":6770 * global hmd * * if mpid: # <<<<<<<<<<<<<< * mpid_no_coercion = mpid * if isinstance(mpid, (int, long)): */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_mpid); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 6563, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_mpid); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 6770, __pyx_L1_error) if (__pyx_t_1) { - /* "PyCafe.pyx":6564 + /* "PyCafe.pyx":6771 * * if mpid: * mpid_no_coercion = mpid # <<<<<<<<<<<<<< * if isinstance(mpid, (int, long)): * mpid_no_coercion = mpid */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_mpid); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6564, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_mpid); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6771, __pyx_L1_error) __pyx_v_mpid_no_coercion = __pyx_t_4; - /* "PyCafe.pyx":6565 + /* "PyCafe.pyx":6772 * if mpid: * mpid_no_coercion = mpid * if isinstance(mpid, (int, long)): # <<<<<<<<<<<<<< @@ -111382,17 +115060,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6566 + /* "PyCafe.pyx":6773 * mpid_no_coercion = mpid * if isinstance(mpid, (int, long)): * mpid_no_coercion = mpid # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.monitorStopWithID(handle, mpid_no_coercion) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_mpid); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6566, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_mpid); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6773, __pyx_L1_error) __pyx_v_mpid_no_coercion = __pyx_t_4; - /* "PyCafe.pyx":6567 + /* "PyCafe.pyx":6774 * if isinstance(mpid, (int, long)): * mpid_no_coercion = mpid * with nogil: # <<<<<<<<<<<<<< @@ -111407,7 +115085,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf #endif /*try:*/ { - /* "PyCafe.pyx":6568 + /* "PyCafe.pyx":6775 * mpid_no_coercion = mpid * with nogil: * status = self._c_cafe.monitorStopWithID(handle, mpid_no_coercion) # <<<<<<<<<<<<<< @@ -111417,7 +115095,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_v_status = __pyx_v_self->_c_cafe->monitorStopWithID(__pyx_v_handle, __pyx_v_mpid_no_coercion); } - /* "PyCafe.pyx":6567 + /* "PyCafe.pyx":6774 * if isinstance(mpid, (int, long)): * mpid_no_coercion = mpid * with nogil: # <<<<<<<<<<<<<< @@ -111436,16 +115114,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf } } - /* "PyCafe.pyx":6569 + /* "PyCafe.pyx":6776 * with nogil: * status = self._c_cafe.monitorStopWithID(handle, mpid_no_coercion) * time.sleep(0.001) # <<<<<<<<<<<<<< * l = None * if mpid not in list(hmd.values()): */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6569, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_sleep); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6569, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_sleep); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -111460,12 +115138,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf } __pyx_t_6 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_5, __pyx_float_0_001) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_float_0_001); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6569, __pyx_L1_error) + if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6570 + /* "PyCafe.pyx":6777 * status = self._c_cafe.monitorStopWithID(handle, mpid_no_coercion) * time.sleep(0.001) * l = None # <<<<<<<<<<<<<< @@ -111475,7 +115153,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __Pyx_INCREF(Py_None); __pyx_v_l = Py_None; - /* "PyCafe.pyx":6571 + /* "PyCafe.pyx":6778 * time.sleep(0.001) * l = None * if mpid not in list(hmd.values()): # <<<<<<<<<<<<<< @@ -111484,21 +115162,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(3, 6571, __pyx_L1_error) + __PYX_ERR(3, 6778, __pyx_L1_error) } - __pyx_t_6 = __Pyx_PyDict_Values(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6571, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_Values(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6778, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6571, __pyx_L1_error) + __pyx_t_7 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6778, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_mpid, __pyx_t_7, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 6571, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_mpid, __pyx_t_7, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 6778, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { goto __pyx_L13; } - /* "PyCafe.pyx":6574 + /* "PyCafe.pyx":6781 * pass #happens when is direct mode in table widget * else: * l = list(hmd.keys())[list(hmd.values()).index(mpid)] # <<<<<<<<<<<<<< @@ -111508,23 +115186,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf /*else*/ { if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); - __PYX_ERR(3, 6574, __pyx_L1_error) + __PYX_ERR(3, 6781, __pyx_L1_error) } - __pyx_t_7 = __Pyx_PyDict_Keys(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6574, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyDict_Keys(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = PySequence_List(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6574, __pyx_L1_error) + __pyx_t_6 = PySequence_List(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(3, 6574, __pyx_L1_error) + __PYX_ERR(3, 6781, __pyx_L1_error) } - __pyx_t_5 = __Pyx_PyDict_Values(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6574, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_Values(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_8 = PySequence_List(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6574, __pyx_L1_error) + __pyx_t_8 = PySequence_List(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_index); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6574, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_index); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; @@ -111539,10 +115217,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf } __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_8, __pyx_v_mpid) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_mpid); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6574, __pyx_L1_error) + if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6574, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -111551,7 +115229,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf } __pyx_L13:; - /* "PyCafe.pyx":6575 + /* "PyCafe.pyx":6782 * else: * l = list(hmd.keys())[list(hmd.values()).index(mpid)] * if l is not None: # <<<<<<<<<<<<<< @@ -111562,7 +115240,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6576 + /* "PyCafe.pyx":6783 * l = list(hmd.keys())[list(hmd.values()).index(mpid)] * if l is not None: * del hmd[l] # <<<<<<<<<<<<<< @@ -111571,11 +115249,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6576, __pyx_L1_error) + __PYX_ERR(3, 6783, __pyx_L1_error) } - if (unlikely(PyDict_DelItem(__pyx_v_6PyCafe_hmd, __pyx_v_l) < 0)) __PYX_ERR(3, 6576, __pyx_L1_error) + if (unlikely(PyDict_DelItem(__pyx_v_6PyCafe_hmd, __pyx_v_l) < 0)) __PYX_ERR(3, 6783, __pyx_L1_error) - /* "PyCafe.pyx":6575 + /* "PyCafe.pyx":6782 * else: * l = list(hmd.keys())[list(hmd.values()).index(mpid)] * if l is not None: # <<<<<<<<<<<<<< @@ -111584,7 +115262,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":6565 + /* "PyCafe.pyx":6772 * if mpid: * mpid_no_coercion = mpid * if isinstance(mpid, (int, long)): # <<<<<<<<<<<<<< @@ -111594,7 +115272,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf goto __pyx_L7; } - /* "PyCafe.pyx":6578 + /* "PyCafe.pyx":6785 * del hmd[l] * else: * raise Exception("EXCEPTION RAISED IN PyCafe def monitorStop. \n \ # <<<<<<<<<<<<<< @@ -111602,15 +115280,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf * else: */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__120, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6578, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__115, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 6578, __pyx_L1_error) + __PYX_ERR(3, 6785, __pyx_L1_error) } __pyx_L7:; - /* "PyCafe.pyx":6563 + /* "PyCafe.pyx":6770 * global hmd * * if mpid: # <<<<<<<<<<<<<< @@ -111620,7 +115298,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf goto __pyx_L6; } - /* "PyCafe.pyx":6581 + /* "PyCafe.pyx":6788 * monitorPolicy ID (mpid) should be of type ") * else: * mids = self.hh.getMonitorIDs(handle) # <<<<<<<<<<<<<< @@ -111630,7 +115308,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf /*else*/ { __pyx_v_mids = __pyx_v_self->hh.getMonitorIDs(__pyx_v_handle); - /* "PyCafe.pyx":6582 + /* "PyCafe.pyx":6789 * else: * mids = self.hh.getMonitorIDs(handle) * with nogil: # <<<<<<<<<<<<<< @@ -111645,7 +115323,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf #endif /*try:*/ { - /* "PyCafe.pyx":6583 + /* "PyCafe.pyx":6790 * mids = self.hh.getMonitorIDs(handle) * with nogil: * status = self._c_cafe.monitorStop(handle) # <<<<<<<<<<<<<< @@ -111655,7 +115333,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_v_status = __pyx_v_self->_c_cafe->monitorStop(__pyx_v_handle); } - /* "PyCafe.pyx":6582 + /* "PyCafe.pyx":6789 * else: * mids = self.hh.getMonitorIDs(handle) * with nogil: # <<<<<<<<<<<<<< @@ -111674,16 +115352,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf } } - /* "PyCafe.pyx":6584 + /* "PyCafe.pyx":6791 * with nogil: * status = self._c_cafe.monitorStop(handle) * time.sleep(0.001) # <<<<<<<<<<<<<< * * for monid in mids: */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6584, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6791, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_sleep); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6584, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_sleep); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6791, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -111698,12 +115376,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf } __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_float_0_001) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_float_0_001); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6584, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6791, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":6586 + /* "PyCafe.pyx":6793 * time.sleep(0.001) * * for monid in mids: # <<<<<<<<<<<<<< @@ -111717,31 +115395,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf ++__pyx_t_9; __pyx_v_monid = __pyx_t_4; - /* "PyCafe.pyx":6587 + /* "PyCafe.pyx":6794 * * for monid in mids: * if monid not in list(hmd.values()): # <<<<<<<<<<<<<< * continue * l = list(hmd.keys())[list(hmd.values()).index(monid)] */ - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_monid); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6587, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_monid); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6794, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(3, 6587, __pyx_L1_error) + __PYX_ERR(3, 6794, __pyx_L1_error) } - __pyx_t_6 = __Pyx_PyDict_Values(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6587, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_Values(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6794, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6587, __pyx_L1_error) + __pyx_t_7 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6794, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_t_7, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 6587, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_t_7, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 6794, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6588 + /* "PyCafe.pyx":6795 * for monid in mids: * if monid not in list(hmd.values()): * continue # <<<<<<<<<<<<<< @@ -111750,7 +115428,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ goto __pyx_L18_continue; - /* "PyCafe.pyx":6587 + /* "PyCafe.pyx":6794 * * for monid in mids: * if monid not in list(hmd.values()): # <<<<<<<<<<<<<< @@ -111759,7 +115437,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":6589 + /* "PyCafe.pyx":6796 * if monid not in list(hmd.values()): * continue * l = list(hmd.keys())[list(hmd.values()).index(monid)] # <<<<<<<<<<<<<< @@ -111768,26 +115446,26 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); - __PYX_ERR(3, 6589, __pyx_L1_error) + __PYX_ERR(3, 6796, __pyx_L1_error) } - __pyx_t_7 = __Pyx_PyDict_Keys(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6589, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyDict_Keys(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_5 = PySequence_List(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6589, __pyx_L1_error) + __pyx_t_5 = PySequence_List(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(3, 6589, __pyx_L1_error) + __PYX_ERR(3, 6796, __pyx_L1_error) } - __pyx_t_6 = __Pyx_PyDict_Values(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6589, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_Values(__pyx_v_6PyCafe_hmd); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6589, __pyx_L1_error) + __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_index); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6589, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_index); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_monid); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6589, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_unsigned_int(__pyx_v_monid); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -111802,17 +115480,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_t_7 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_10, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6589, __pyx_L1_error) + if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6589, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF_SET(__pyx_v_l, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6590 + /* "PyCafe.pyx":6797 * continue * l = list(hmd.keys())[list(hmd.values()).index(monid)] * if l is not None: # <<<<<<<<<<<<<< @@ -111823,7 +115501,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6591 + /* "PyCafe.pyx":6798 * l = list(hmd.keys())[list(hmd.values()).index(monid)] * if l is not None: * del hmd[l] # <<<<<<<<<<<<<< @@ -111832,11 +115510,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 6591, __pyx_L1_error) + __PYX_ERR(3, 6798, __pyx_L1_error) } - if (unlikely(PyDict_DelItem(__pyx_v_6PyCafe_hmd, __pyx_v_l) < 0)) __PYX_ERR(3, 6591, __pyx_L1_error) + if (unlikely(PyDict_DelItem(__pyx_v_6PyCafe_hmd, __pyx_v_l) < 0)) __PYX_ERR(3, 6798, __pyx_L1_error) - /* "PyCafe.pyx":6590 + /* "PyCafe.pyx":6797 * continue * l = list(hmd.keys())[list(hmd.values()).index(monid)] * if l is not None: # <<<<<<<<<<<<<< @@ -111845,7 +115523,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":6586 + /* "PyCafe.pyx":6793 * time.sleep(0.001) * * for monid in mids: # <<<<<<<<<<<<<< @@ -111857,7 +115535,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf } __pyx_L6:; - /* "PyCafe.pyx":6593 + /* "PyCafe.pyx":6800 * del hmd[l] * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -111867,7 +115545,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6594 + /* "PyCafe.pyx":6801 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -111877,7 +115555,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6595 + /* "PyCafe.pyx":6802 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -111887,7 +115565,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf __pyx_t_2 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6596 + /* "PyCafe.pyx":6803 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -111896,7 +115574,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6595 + /* "PyCafe.pyx":6802 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -111906,7 +115584,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf goto __pyx_L24; } - /* "PyCafe.pyx":6598 + /* "PyCafe.pyx":6805 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -111918,7 +115596,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf } __pyx_L24:; - /* "PyCafe.pyx":6594 + /* "PyCafe.pyx":6801 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -111927,7 +115605,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":6593 + /* "PyCafe.pyx":6800 * del hmd[l] * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -111936,7 +115614,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":6600 + /* "PyCafe.pyx":6807 * self._c_cafe.printStatus(handle, status) * * return status # <<<<<<<<<<<<<< @@ -111944,13 +115622,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6600, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6807, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6543 + /* "PyCafe.pyx":6750 * ############################################################################ * * def monitorStop(self, handlePV, mpid=None): # <<<<<<<<<<<<<< @@ -111978,7 +115656,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_392monitorStop(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":6603 +/* "PyCafe.pyx":6810 * * ############################################################################ * def monitorStopAll(self): # <<<<<<<<<<<<<< @@ -112012,7 +115690,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py PyObject *__pyx_t_6 = NULL; __Pyx_RefNannySetupContext("monitorStopAll", 0); - /* "PyCafe.pyx":6605 + /* "PyCafe.pyx":6812 * def monitorStopAll(self): * * cdef str _METHOD = "monitorStopAll()" # <<<<<<<<<<<<<< @@ -112022,7 +115700,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py __Pyx_INCREF(__pyx_kp_u_monitorStopAll); __pyx_v__METHOD = __pyx_kp_u_monitorStopAll; - /* "PyCafe.pyx":6609 + /* "PyCafe.pyx":6816 * * * with nogil: # <<<<<<<<<<<<<< @@ -112037,7 +115715,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py #endif /*try:*/ { - /* "PyCafe.pyx":6610 + /* "PyCafe.pyx":6817 * * with nogil: * status = self._c_cafe.monitorStopAll() # <<<<<<<<<<<<<< @@ -112047,7 +115725,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py __pyx_v_status = __pyx_v_self->_c_cafe->monitorStopAll(); } - /* "PyCafe.pyx":6609 + /* "PyCafe.pyx":6816 * * * with nogil: # <<<<<<<<<<<<<< @@ -112066,16 +115744,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py } } - /* "PyCafe.pyx":6613 + /* "PyCafe.pyx":6820 * * # give plenty of time for monitors to stop! * time.sleep(0.2) # <<<<<<<<<<<<<< * * hmd.clear() */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6613, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_sleep); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6613, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_sleep); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -112090,12 +115768,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_float_0_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_float_0_2); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6613, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":6615 + /* "PyCafe.pyx":6822 * time.sleep(0.2) * * hmd.clear() # <<<<<<<<<<<<<< @@ -112104,11 +115782,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py */ if (unlikely(__pyx_v_6PyCafe_hmd == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "clear"); - __PYX_ERR(3, 6615, __pyx_L1_error) + __PYX_ERR(3, 6822, __pyx_L1_error) } - __pyx_t_4 = __Pyx_PyDict_Clear(__pyx_v_6PyCafe_hmd); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 6615, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_Clear(__pyx_v_6PyCafe_hmd); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 6822, __pyx_L1_error) - /* "PyCafe.pyx":6617 + /* "PyCafe.pyx":6824 * hmd.clear() * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -112118,7 +115796,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py __pyx_t_5 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":6618 + /* "PyCafe.pyx":6825 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -112128,7 +115806,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py __pyx_t_5 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":6619 + /* "PyCafe.pyx":6826 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -112137,7 +115815,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":6618 + /* "PyCafe.pyx":6825 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -112146,16 +115824,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":6622 + /* "PyCafe.pyx":6829 * raise Exception( * "EXCEPTION RAISED in PyCafe def monitorStopAll. Status = {0}" * .format(status)) # <<<<<<<<<<<<<< * * return status */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_m, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6622, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_m, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6829, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6622, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6829, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -112170,25 +115848,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6622, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6829, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":6620 + /* "PyCafe.pyx":6827 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def monitorStopAll. Status = {0}" * .format(status)) */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6620, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6827, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 6620, __pyx_L1_error) + __PYX_ERR(3, 6827, __pyx_L1_error) - /* "PyCafe.pyx":6617 + /* "PyCafe.pyx":6824 * hmd.clear() * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -112197,7 +115875,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py */ } - /* "PyCafe.pyx":6624 + /* "PyCafe.pyx":6831 * .format(status)) * * return status # <<<<<<<<<<<<<< @@ -112205,13 +115883,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6624, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6603 + /* "PyCafe.pyx":6810 * * ############################################################################ * def monitorStopAll(self): # <<<<<<<<<<<<<< @@ -112236,7 +115914,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_394monitorStopAll(struct __pyx_obj_6Py return __pyx_r; } -/* "PyCafe.pyx":6629 +/* "PyCafe.pyx":6836 * ############################################################################## * * def set(self, handlePV, valSet): # <<<<<<<<<<<<<< @@ -112275,11 +115953,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_397set(PyObject *__pyx_v_self, PyObjec case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_valSet)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("set", 1, 2, 2, 1); __PYX_ERR(3, 6629, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set", 1, 2, 2, 1); __PYX_ERR(3, 6836, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set") < 0)) __PYX_ERR(3, 6629, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set") < 0)) __PYX_ERR(3, 6836, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -112292,7 +115970,7 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_397set(PyObject *__pyx_v_self, PyObjec } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("set", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6629, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 6836, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.set", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -112397,7 +116075,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_RefNannySetupContext("set", 0); __Pyx_INCREF(__pyx_v_valSet); - /* "PyCafe.pyx":6630 + /* "PyCafe.pyx":6837 * * def set(self, handlePV, valSet): * cdef str _METHOD = "set(handlePV, valSet)" # <<<<<<<<<<<<<< @@ -112407,7 +116085,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_kp_u_set_handlePV_valSet); __pyx_v__METHOD = __pyx_kp_u_set_handlePV_valSet; - /* "PyCafe.pyx":6632 + /* "PyCafe.pyx":6839 * cdef str _METHOD = "set(handlePV, valSet)" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -112416,7 +116094,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_handle = 0; - /* "PyCafe.pyx":6634 + /* "PyCafe.pyx":6841 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -112437,17 +116115,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6635 + /* "PyCafe.pyx":6842 * * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6635, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6842, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":6634 + /* "PyCafe.pyx":6841 * cdef unsigned int handle = 0 * * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -112457,7 +116135,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L3; } - /* "PyCafe.pyx":6636 + /* "PyCafe.pyx":6843 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -112468,21 +116146,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6637 + /* "PyCafe.pyx":6844 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 6637, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6637, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 6844, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6844, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6637, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":6636 + /* "PyCafe.pyx":6843 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -112492,7 +116170,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L3; } - /* "PyCafe.pyx":6639 + /* "PyCafe.pyx":6846 * handle = self.checkForHandle(handlePV) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< @@ -112501,33 +116179,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ /*else*/ { - /* "PyCafe.pyx":6640 + /* "PyCafe.pyx":6847 * else: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _error_info="First input argument, should be of type if handle, \ * else if PV") */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6640, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6847, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6640, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6640, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_3) < 0) __PYX_ERR(3, 6640, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 6847, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 6847, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_3) < 0) __PYX_ERR(3, 6847, __pyx_L1_error) - /* "PyCafe.pyx":6639 + /* "PyCafe.pyx":6846 * handle = self.checkForHandle(handlePV) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if handle, \ */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6639, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6643 + /* "PyCafe.pyx":6850 * _error_info="First input argument, should be of type if handle, \ * else if PV") * raise _cafeException # <<<<<<<<<<<<<< @@ -112535,11 +116213,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 6643, __pyx_L1_error) + __PYX_ERR(3, 6850, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":6648 + /* "PyCafe.pyx":6855 * # CHECK FOR ALL DATA TYPES! * * cdef unsigned short valType = CAFE_STRING # <<<<<<<<<<<<<< @@ -112548,7 +116226,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_STRING; - /* "PyCafe.pyx":6649 + /* "PyCafe.pyx":6856 * * cdef unsigned short valType = CAFE_STRING * cdef int status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -112557,7 +116235,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":6666 + /* "PyCafe.pyx":6873 * cdef vector[string] vecS * * cdef unsigned int nLA = 0 # <<<<<<<<<<<<<< @@ -112566,29 +116244,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_nLA = 0; - /* "PyCafe.pyx":6668 + /* "PyCafe.pyx":6875 * 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6668, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_wchar); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6668, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_wchar); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6668, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_char_p); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6668, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_char_p); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6668, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_wchar_p); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6668, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_wchar_p); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6668, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6875, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); @@ -112602,34 +116280,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_ctypesString = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6669 + /* "PyCafe.pyx":6876 * * 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6669, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_char); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6669, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_char); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6669, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ubyte); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6669, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ubyte); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6669, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_bool); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6669, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_bool); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6669, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6669, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6669, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6876, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8); @@ -112646,34 +116324,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_ctypesUChar = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6670 + /* "PyCafe.pyx":6877 * 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, */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6670, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6670, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int16); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6670, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6670, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6670, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_short); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6670, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_short); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6670, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_byte); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6670, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_byte); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6670, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_9); @@ -112690,24 +116368,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_ctypesShort = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6671 + /* "PyCafe.pyx":6878 * 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6671, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint16); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6671, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint16); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6671, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ushort); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6671, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ushort); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6671, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8); @@ -112718,50 +116396,50 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_ctypesUShort = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6672 + /* "PyCafe.pyx":6879 * 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, */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6672, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6879, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6672, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6879, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6672, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6879, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int32); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6672, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int32); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6879, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6673 + /* "PyCafe.pyx":6880 * 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, */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6673, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_long); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6673, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_long); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6673, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_size_t); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6673, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_size_t); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6672 + /* "PyCafe.pyx":6879 * 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, */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6672, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6879, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); @@ -112778,101 +116456,101 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_ctypesInt = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6674 + /* "PyCafe.pyx":6881 * 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, */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6674, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6674, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 6881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6674, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint32); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6674, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint32); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 6881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6674, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int64); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6674, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_int64); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6674, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6674, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6675 + /* "PyCafe.pyx":6882 * 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6675, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ulong); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6675, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ulong); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6675, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ulonglong); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6675, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ulonglong); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6675, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_longdouble); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 6675, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_longdouble); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 6882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6676 + /* "PyCafe.pyx":6883 * 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) * */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6676, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_longlong); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6676, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_longlong); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6676, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ssize_t); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6676, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_ssize_t); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6677 + /* "PyCafe.pyx":6884 * 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 */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6677, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_void_p); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6677, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_void_p); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6677, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_voidp); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6677, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_voidp); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6674 + /* "PyCafe.pyx":6881 * 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, */ - __pyx_t_6 = PyTuple_New(11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6674, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(11); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_9); @@ -112910,24 +116588,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_ctypesLongLong = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6681 + /* "PyCafe.pyx":6888 * # 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6681, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_str_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6681, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_str_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6681, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_unicode_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6681, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_unicode_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6681, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_16); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_16); @@ -112938,34 +116616,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_dtypesString = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6682 + /* "PyCafe.pyx":6889 * * 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6682, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ubyte); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6682, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ubyte); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6682, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_bool8); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6682, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_bool8); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6682, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_bool_2); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6682, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_bool_2); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6682, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint8); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6682, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint8); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6682, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_15); @@ -112982,34 +116660,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_dtypesUChar = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6683 + /* "PyCafe.pyx":6890 * 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6683, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_byte); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6683, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_byte); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6683, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_short); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6683, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_short); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6683, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int8); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6683, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int8); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6683, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int16); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6683, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int16); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6683, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_13); @@ -113026,24 +116704,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_dtypesShort = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6684 + /* "PyCafe.pyx":6891 * 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, */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6684, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint16); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6684, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint16); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6684, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ushort); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6684, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ushort); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6684, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_15); @@ -113054,34 +116732,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_dtypesUShort = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6685 + /* "PyCafe.pyx":6892 * 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6685, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6685, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6685, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_intc); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6685, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_intc); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6685, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int32); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6685, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int32); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6685, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uintp); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6685, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uintp); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6685, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_16); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_16); @@ -113098,75 +116776,75 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_dtypesInt = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6686 + /* "PyCafe.pyx":6893 * 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) * */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6686, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6686, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6686, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uintc); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6686, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uintc); if (unlikely(!__pyx_t_14)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6686, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint32); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6686, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint32); if (unlikely(!__pyx_t_15)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6686, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int64); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6686, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int64); if (unlikely(!__pyx_t_16)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6686, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 6686, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6687 + /* "PyCafe.pyx":6894 * 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) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6687, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ulonglong); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6687, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ulonglong); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 6894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6687, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_longlong); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6687, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_longlong); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6687, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_intp); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6687, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_intp); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6687, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uintp); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6687, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uintp); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6686 + /* "PyCafe.pyx":6893 * 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) * */ - __pyx_t_6 = PyTuple_New(9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6686, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(9); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_13); @@ -113198,29 +116876,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_dtypesLongLong = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6689 + /* "PyCafe.pyx":6896 * 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) * */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6689, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_single); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6689, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_single); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6689, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float16); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6689, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float16); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6689, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6689, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6689, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8); @@ -113234,29 +116912,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_dtypesFloat = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6690 + /* "PyCafe.pyx":6897 * * 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] */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6690, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_double); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6690, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_double); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6690, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6690, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6690, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float64); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6690, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float64); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6690, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_10); @@ -113270,7 +116948,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_dtypesDouble = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6695 + /* "PyCafe.pyx":6902 * # print "type= // ", type(valSet) * * cdef bint isGoodType = False # <<<<<<<<<<<<<< @@ -113279,7 +116957,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_isGoodType = 0; - /* "PyCafe.pyx":6696 + /* "PyCafe.pyx":6903 * * cdef bint isGoodType = False * cdef bint isBytesType = False # <<<<<<<<<<<<<< @@ -113288,23 +116966,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_isBytesType = 0; - /* "PyCafe.pyx":6718 + /* "PyCafe.pyx":6925 * # print(type(valSet)) * # print (valSet.__class__) * cdef str classType = (valSet.__class__).__name__ # <<<<<<<<<<<<<< * cdef str substringmv = "_memoryviewslice" * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_class); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6718, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_class); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6925, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_name_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6718, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_name_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6925, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(PyUnicode_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_8)->tp_name), 0))) __PYX_ERR(3, 6718, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_8)->tp_name), 0))) __PYX_ERR(3, 6925, __pyx_L1_error) __pyx_v_classType = ((PyObject*)__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6719 + /* "PyCafe.pyx":6926 * # print (valSet.__class__) * cdef str classType = (valSet.__class__).__name__ * cdef str substringmv = "_memoryviewslice" # <<<<<<<<<<<<<< @@ -113314,38 +116992,38 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_n_u_memoryviewslice_2); __pyx_v_substringmv = __pyx_n_u_memoryviewslice_2; - /* "PyCafe.pyx":6727 + /* "PyCafe.pyx":6934 * # print('OK for memoryview') * * if _python_version > (2,6): # <<<<<<<<<<<<<< * #if ((_python_version[0] > 2) or (_python_version[0] == 2 and _python_version[1] > 6)): * */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_python_version); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6727, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_python_version); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6934, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_6 = PyObject_RichCompare(__pyx_t_8, __pyx_tuple__121, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6727, __pyx_L1_error) + __pyx_t_6 = PyObject_RichCompare(__pyx_t_8, __pyx_tuple__116, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6934, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 6727, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 6934, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_1) { - /* "PyCafe.pyx":6730 + /* "PyCafe.pyx":6937 * #if ((_python_version[0] > 2) or (_python_version[0] == 2 and _python_version[1] > 6)): * * if isinstance(valSet, (list, array.array, np.ndarray, cython.view.memoryview, memoryview, ctypes.Array)): # <<<<<<<<<<<<<< * isGoodType = True * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6730, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6937, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6730, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6937, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6730, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_memoryview); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6937, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6730, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6937, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_Array); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6730, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_Array); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6937, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_2 = PyList_Check(__pyx_v_valSet); @@ -113393,7 +117071,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6731 + /* "PyCafe.pyx":6938 * * if isinstance(valSet, (list, array.array, np.ndarray, cython.view.memoryview, memoryview, ctypes.Array)): * isGoodType = True # <<<<<<<<<<<<<< @@ -113402,7 +117080,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_isGoodType = 1; - /* "PyCafe.pyx":6730 + /* "PyCafe.pyx":6937 * #if ((_python_version[0] > 2) or (_python_version[0] == 2 and _python_version[1] > 6)): * * if isinstance(valSet, (list, array.array, np.ndarray, cython.view.memoryview, memoryview, ctypes.Array)): # <<<<<<<<<<<<<< @@ -113411,7 +117089,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6727 + /* "PyCafe.pyx":6934 * # print('OK for memoryview') * * if _python_version > (2,6): # <<<<<<<<<<<<<< @@ -113421,7 +117099,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L6; } - /* "PyCafe.pyx":6733 + /* "PyCafe.pyx":6940 * isGoodType = True * else: * if isinstance(valSet, (list, array.array, np.ndarray, ctypes.Array)): # <<<<<<<<<<<<<< @@ -113429,14 +117107,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe * */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6733, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6733, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6733, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_Array); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6733, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_Array); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_1 = PyList_Check(__pyx_v_valSet); @@ -113469,7 +117147,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6734 + /* "PyCafe.pyx":6941 * else: * if isinstance(valSet, (list, array.array, np.ndarray, ctypes.Array)): * isGoodType = True # <<<<<<<<<<<<<< @@ -113478,7 +117156,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_isGoodType = 1; - /* "PyCafe.pyx":6733 + /* "PyCafe.pyx":6940 * isGoodType = True * else: * if isinstance(valSet, (list, array.array, np.ndarray, ctypes.Array)): # <<<<<<<<<<<<<< @@ -113489,7 +117167,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L6:; - /* "PyCafe.pyx":6736 + /* "PyCafe.pyx":6943 * isGoodType = True * * if (isGoodType == False): # <<<<<<<<<<<<<< @@ -113499,7 +117177,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_1 = ((__pyx_v_isGoodType == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6737 + /* "PyCafe.pyx":6944 * * if (isGoodType == False): * if (substringmv in classType): # <<<<<<<<<<<<<< @@ -113508,13 +117186,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ if (unlikely(__pyx_v_classType == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(3, 6737, __pyx_L1_error) + __PYX_ERR(3, 6944, __pyx_L1_error) } - __pyx_t_1 = (__Pyx_PyUnicode_ContainsTF(__pyx_v_substringmv, __pyx_v_classType, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 6737, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PyUnicode_ContainsTF(__pyx_v_substringmv, __pyx_v_classType, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 6944, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6738 + /* "PyCafe.pyx":6945 * if (isGoodType == False): * if (substringmv in classType): * isGoodType = True # <<<<<<<<<<<<<< @@ -113523,7 +117201,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_isGoodType = 1; - /* "PyCafe.pyx":6737 + /* "PyCafe.pyx":6944 * * if (isGoodType == False): * if (substringmv in classType): # <<<<<<<<<<<<<< @@ -113532,7 +117210,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6736 + /* "PyCafe.pyx":6943 * isGoodType = True * * if (isGoodType == False): # <<<<<<<<<<<<<< @@ -113541,38 +117219,38 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6742 + /* "PyCafe.pyx":6949 * # 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 */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6742, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_Array); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6742, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_Array); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_t_10); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 6742, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_t_10); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 6949, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":6743 + /* "PyCafe.pyx":6950 * # 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 */ - __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_valSet, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6743, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_valSet, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6950, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_1 = PyBytes_Check(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6744 + /* "PyCafe.pyx":6951 * if isinstance(valSet, ctypes.Array): * if isinstance(valSet[0], bytes): * isGoodType = False # <<<<<<<<<<<<<< @@ -113581,7 +117259,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_isGoodType = 0; - /* "PyCafe.pyx":6745 + /* "PyCafe.pyx":6952 * if isinstance(valSet[0], bytes): * isGoodType = False * isBytesType = True # <<<<<<<<<<<<<< @@ -113590,7 +117268,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_isBytesType = 1; - /* "PyCafe.pyx":6743 + /* "PyCafe.pyx":6950 * # 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): # <<<<<<<<<<<<<< @@ -113599,7 +117277,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6742 + /* "PyCafe.pyx":6949 * # 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): # <<<<<<<<<<<<<< @@ -113608,7 +117286,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6759 + /* "PyCafe.pyx":6966 * #print("isBytesType ", isBytesType) * * self._c_cafe.getChannelInfo(handle, self.channelInfo) # <<<<<<<<<<<<<< @@ -113617,22 +117295,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ (void)(__pyx_v_self->_c_cafe->getChannelInfo(__pyx_v_handle, __pyx_v_self->channelInfo)); - /* "PyCafe.pyx":6760 + /* "PyCafe.pyx":6967 * * self._c_cafe.getChannelInfo(handle, self.channelInfo) * class_name = str(self.channelInfo.getClassNameAsString()) # <<<<<<<<<<<<<< * data_type = self.channelInfo.getDataType() * */ - __pyx_t_10 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->channelInfo.getClassNameAsString()); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6760, __pyx_L1_error) + __pyx_t_10 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->channelInfo.getClassNameAsString()); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6967, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6760, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6967, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_class_name = __pyx_t_6; __pyx_t_6 = 0; - /* "PyCafe.pyx":6761 + /* "PyCafe.pyx":6968 * self._c_cafe.getChannelInfo(handle, self.channelInfo) * class_name = str(self.channelInfo.getClassNameAsString()) * data_type = self.channelInfo.getDataType() # <<<<<<<<<<<<<< @@ -113641,7 +117319,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_data_type = __pyx_v_self->channelInfo.getDataType(); - /* "PyCafe.pyx":6763 + /* "PyCafe.pyx":6970 * data_type = self.channelInfo.getDataType() * * if class_name in ['waveform'] and data_type in [DBR_CHAR]: # <<<<<<<<<<<<<< @@ -113650,7 +117328,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __Pyx_INCREF(__pyx_v_class_name); __pyx_t_6 = __pyx_v_class_name; - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_waveform, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 6763, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_6, __pyx_n_u_waveform, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 6970, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { @@ -113664,7 +117342,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_L24_bool_binop_done:; if (__pyx_t_2) { - /* "PyCafe.pyx":6764 + /* "PyCafe.pyx":6971 * * if class_name in ['waveform'] and data_type in [DBR_CHAR]: * if isinstance(valSet, (str, bytes)): # <<<<<<<<<<<<<< @@ -113685,7 +117363,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6765 + /* "PyCafe.pyx":6972 * if class_name in ['waveform'] and data_type in [DBR_CHAR]: * if isinstance(valSet, (str, bytes)): * isGoodType = True # <<<<<<<<<<<<<< @@ -113694,7 +117372,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_isGoodType = 1; - /* "PyCafe.pyx":6764 + /* "PyCafe.pyx":6971 * * if class_name in ['waveform'] and data_type in [DBR_CHAR]: * if isinstance(valSet, (str, bytes)): # <<<<<<<<<<<<<< @@ -113704,7 +117382,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L26; } - /* "PyCafe.pyx":6766 + /* "PyCafe.pyx":6973 * if isinstance(valSet, (str, bytes)): * isGoodType = True * elif isinstance(valSet, list): # <<<<<<<<<<<<<< @@ -113715,25 +117393,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6767 + /* "PyCafe.pyx":6974 * isGoodType = True * elif isinstance(valSet, list): * if len(valSet) == 1: # <<<<<<<<<<<<<< * if isinstance(valSet[0], (str, bytes)): * isGoodType = True */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6767, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6974, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_18 == 1) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6768 + /* "PyCafe.pyx":6975 * elif isinstance(valSet, list): * if len(valSet) == 1: * if isinstance(valSet[0], (str, bytes)): # <<<<<<<<<<<<<< * isGoodType = True * valSet = valSet[0] */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6768, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6975, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_3 = PyUnicode_Check(__pyx_t_6); __pyx_t_1 = (__pyx_t_3 != 0); @@ -113750,7 +117428,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6769 + /* "PyCafe.pyx":6976 * if len(valSet) == 1: * if isinstance(valSet[0], (str, bytes)): * isGoodType = True # <<<<<<<<<<<<<< @@ -113759,19 +117437,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_isGoodType = 1; - /* "PyCafe.pyx":6770 + /* "PyCafe.pyx":6977 * if isinstance(valSet[0], (str, bytes)): * isGoodType = True * valSet = valSet[0] # <<<<<<<<<<<<<< * * if isGoodType: */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6770, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6977, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_valSet, __pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":6768 + /* "PyCafe.pyx":6975 * elif isinstance(valSet, list): * if len(valSet) == 1: * if isinstance(valSet[0], (str, bytes)): # <<<<<<<<<<<<<< @@ -113780,7 +117458,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6767 + /* "PyCafe.pyx":6974 * isGoodType = True * elif isinstance(valSet, list): * if len(valSet) == 1: # <<<<<<<<<<<<<< @@ -113789,7 +117467,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6766 + /* "PyCafe.pyx":6973 * if isinstance(valSet, (str, bytes)): * isGoodType = True * elif isinstance(valSet, list): # <<<<<<<<<<<<<< @@ -113799,7 +117477,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L26:; - /* "PyCafe.pyx":6763 + /* "PyCafe.pyx":6970 * data_type = self.channelInfo.getDataType() * * if class_name in ['waveform'] and data_type in [DBR_CHAR]: # <<<<<<<<<<<<<< @@ -113808,7 +117486,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6772 + /* "PyCafe.pyx":6979 * valSet = valSet[0] * * if isGoodType: # <<<<<<<<<<<<<< @@ -113818,17 +117496,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_v_isGoodType != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6776 + /* "PyCafe.pyx":6983 * #print('set method', type(valSet[0])) * * nLA = len(valSet) # <<<<<<<<<<<<<< * * # Just check on first element if array.array etc.. */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6776, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6983, __pyx_L1_error) __pyx_v_nLA = __pyx_t_18; - /* "PyCafe.pyx":6779 + /* "PyCafe.pyx":6986 * * # Just check on first element if array.array etc.. * if not isinstance(valSet, (list)): # <<<<<<<<<<<<<< @@ -113839,7 +117517,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6781 + /* "PyCafe.pyx":6988 * if not isinstance(valSet, (list)): * # if isinstance(valSet, (array.array, np.ndarray, cython.view.memoryview, memoryview)): * nLA = 1 # <<<<<<<<<<<<<< @@ -113848,7 +117526,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_nLA = 1; - /* "PyCafe.pyx":6779 + /* "PyCafe.pyx":6986 * * # Just check on first element if array.array etc.. * if not isinstance(valSet, (list)): # <<<<<<<<<<<<<< @@ -113857,7 +117535,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6783 + /* "PyCafe.pyx":6990 * nLA = 1 * * for i in range(0, nLA): # <<<<<<<<<<<<<< @@ -113869,14 +117547,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_19; __pyx_t_18+=1) { __pyx_v_i = __pyx_t_18; - /* "PyCafe.pyx":6785 + /* "PyCafe.pyx":6992 * for i in range(0, nLA): * * if isinstance(valSet[i], (str, bytes)): # <<<<<<<<<<<<<< * valType = CAFE_STRING * break */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6785, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6992, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_3 = PyUnicode_Check(__pyx_t_6); __pyx_t_1 = (__pyx_t_3 != 0); @@ -113893,7 +117571,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6786 + /* "PyCafe.pyx":6993 * * if isinstance(valSet[i], (str, bytes)): * valType = CAFE_STRING # <<<<<<<<<<<<<< @@ -113902,7 +117580,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_STRING; - /* "PyCafe.pyx":6787 + /* "PyCafe.pyx":6994 * if isinstance(valSet[i], (str, bytes)): * valType = CAFE_STRING * break # <<<<<<<<<<<<<< @@ -113911,7 +117589,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ goto __pyx_L36_break; - /* "PyCafe.pyx":6785 + /* "PyCafe.pyx":6992 * for i in range(0, nLA): * * if isinstance(valSet[i], (str, bytes)): # <<<<<<<<<<<<<< @@ -113921,21 +117599,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37; } - /* "PyCafe.pyx":6788 + /* "PyCafe.pyx":6995 * valType = CAFE_STRING * break * elif isinstance(valSet[i], dtypesString): # <<<<<<<<<<<<<< * valType = CAFE_STRING * break */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6788, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6995, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = PyObject_IsInstance(__pyx_t_6, __pyx_v_dtypesString); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 6788, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_t_6, __pyx_v_dtypesString); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 6995, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6789 + /* "PyCafe.pyx":6996 * break * elif isinstance(valSet[i], dtypesString): * valType = CAFE_STRING # <<<<<<<<<<<<<< @@ -113944,7 +117622,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_STRING; - /* "PyCafe.pyx":6790 + /* "PyCafe.pyx":6997 * elif isinstance(valSet[i], dtypesString): * valType = CAFE_STRING * break # <<<<<<<<<<<<<< @@ -113953,7 +117631,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ goto __pyx_L36_break; - /* "PyCafe.pyx":6788 + /* "PyCafe.pyx":6995 * valType = CAFE_STRING * break * elif isinstance(valSet[i], dtypesString): # <<<<<<<<<<<<<< @@ -113963,21 +117641,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37; } - /* "PyCafe.pyx":6791 + /* "PyCafe.pyx":6998 * valType = CAFE_STRING * break * elif isinstance(valSet[i], (float)): # <<<<<<<<<<<<<< * valType = CAFE_DOUBLE * elif isinstance(valSet[i], (dtypesDouble)): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6791, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6998, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyFloat_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6792 + /* "PyCafe.pyx":6999 * break * elif isinstance(valSet[i], (float)): * valType = CAFE_DOUBLE # <<<<<<<<<<<<<< @@ -113986,7 +117664,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_DOUBLE; - /* "PyCafe.pyx":6791 + /* "PyCafe.pyx":6998 * valType = CAFE_STRING * break * elif isinstance(valSet[i], (float)): # <<<<<<<<<<<<<< @@ -113996,21 +117674,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37; } - /* "PyCafe.pyx":6793 + /* "PyCafe.pyx":7000 * elif isinstance(valSet[i], (float)): * valType = CAFE_DOUBLE * elif isinstance(valSet[i], (dtypesDouble)): # <<<<<<<<<<<<<< * valType = CAFE_DOUBLE * elif isinstance(valSet[i], (dtypesFloat)): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6793, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = PyObject_IsInstance(__pyx_t_6, __pyx_v_dtypesDouble); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 6793, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_t_6, __pyx_v_dtypesDouble); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 7000, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6794 + /* "PyCafe.pyx":7001 * valType = CAFE_DOUBLE * elif isinstance(valSet[i], (dtypesDouble)): * valType = CAFE_DOUBLE # <<<<<<<<<<<<<< @@ -114019,7 +117697,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_DOUBLE; - /* "PyCafe.pyx":6793 + /* "PyCafe.pyx":7000 * elif isinstance(valSet[i], (float)): * valType = CAFE_DOUBLE * elif isinstance(valSet[i], (dtypesDouble)): # <<<<<<<<<<<<<< @@ -114029,21 +117707,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37; } - /* "PyCafe.pyx":6795 + /* "PyCafe.pyx":7002 * elif isinstance(valSet[i], (dtypesDouble)): * valType = CAFE_DOUBLE * elif isinstance(valSet[i], (dtypesFloat)): # <<<<<<<<<<<<<< * valType = CAFE_FLOAT * elif isinstance(valSet[i], (long, int)): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6795, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7002, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = PyObject_IsInstance(__pyx_t_6, __pyx_v_dtypesFloat); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 6795, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_t_6, __pyx_v_dtypesFloat); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 7002, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6796 + /* "PyCafe.pyx":7003 * valType = CAFE_DOUBLE * elif isinstance(valSet[i], (dtypesFloat)): * valType = CAFE_FLOAT # <<<<<<<<<<<<<< @@ -114052,7 +117730,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_FLOAT; - /* "PyCafe.pyx":6795 + /* "PyCafe.pyx":7002 * elif isinstance(valSet[i], (dtypesDouble)): * valType = CAFE_DOUBLE * elif isinstance(valSet[i], (dtypesFloat)): # <<<<<<<<<<<<<< @@ -114062,14 +117740,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37; } - /* "PyCafe.pyx":6797 + /* "PyCafe.pyx":7004 * elif isinstance(valSet[i], (dtypesFloat)): * valType = CAFE_FLOAT * elif isinstance(valSet[i], (long, int)): # <<<<<<<<<<<<<< * valType = CAFE_LONG * elif isinstance(valSet[i], dtypesInt+dtypesLongLong+dtypesUChar): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6797, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7004, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyLong_Check(__pyx_t_6); __pyx_t_1 = (__pyx_t_2 != 0); @@ -114086,7 +117764,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6798 + /* "PyCafe.pyx":7005 * valType = CAFE_FLOAT * elif isinstance(valSet[i], (long, int)): * valType = CAFE_LONG # <<<<<<<<<<<<<< @@ -114095,7 +117773,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_LONG; - /* "PyCafe.pyx":6797 + /* "PyCafe.pyx":7004 * elif isinstance(valSet[i], (dtypesFloat)): * valType = CAFE_FLOAT * elif isinstance(valSet[i], (long, int)): # <<<<<<<<<<<<<< @@ -114105,27 +117783,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37; } - /* "PyCafe.pyx":6799 + /* "PyCafe.pyx":7006 * elif isinstance(valSet[i], (long, int)): * valType = CAFE_LONG * elif isinstance(valSet[i], dtypesInt+dtypesLongLong+dtypesUChar): # <<<<<<<<<<<<<< * valType = CAFE_LONG * elif isinstance(valSet[i], dtypesShort): */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6799, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = PyNumber_Add(__pyx_v_dtypesInt, __pyx_v_dtypesLongLong); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6799, __pyx_L1_error) + __pyx_t_10 = PyNumber_Add(__pyx_v_dtypesInt, __pyx_v_dtypesLongLong); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_8 = PyNumber_Add(__pyx_t_10, __pyx_v_dtypesUChar); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6799, __pyx_L1_error) + __pyx_t_8 = PyNumber_Add(__pyx_t_10, __pyx_v_dtypesUChar); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_2 = PyObject_IsInstance(__pyx_t_6, __pyx_t_8); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 6799, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_t_6, __pyx_t_8); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 7006, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6800 + /* "PyCafe.pyx":7007 * valType = CAFE_LONG * elif isinstance(valSet[i], dtypesInt+dtypesLongLong+dtypesUChar): * valType = CAFE_LONG # <<<<<<<<<<<<<< @@ -114134,7 +117812,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_LONG; - /* "PyCafe.pyx":6799 + /* "PyCafe.pyx":7006 * elif isinstance(valSet[i], (long, int)): * valType = CAFE_LONG * elif isinstance(valSet[i], dtypesInt+dtypesLongLong+dtypesUChar): # <<<<<<<<<<<<<< @@ -114144,21 +117822,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37; } - /* "PyCafe.pyx":6801 + /* "PyCafe.pyx":7008 * elif isinstance(valSet[i], dtypesInt+dtypesLongLong+dtypesUChar): * valType = CAFE_LONG * elif isinstance(valSet[i], dtypesShort): # <<<<<<<<<<<<<< * valType = CAFE_SHORT * elif isinstance(valSet[i], dtypesUShort): */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6801, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7008, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = PyObject_IsInstance(__pyx_t_8, __pyx_v_dtypesShort); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 6801, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_t_8, __pyx_v_dtypesShort); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 7008, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6802 + /* "PyCafe.pyx":7009 * valType = CAFE_LONG * elif isinstance(valSet[i], dtypesShort): * valType = CAFE_SHORT # <<<<<<<<<<<<<< @@ -114167,7 +117845,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_SHORT; - /* "PyCafe.pyx":6801 + /* "PyCafe.pyx":7008 * elif isinstance(valSet[i], dtypesInt+dtypesLongLong+dtypesUChar): * valType = CAFE_LONG * elif isinstance(valSet[i], dtypesShort): # <<<<<<<<<<<<<< @@ -114177,21 +117855,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37; } - /* "PyCafe.pyx":6803 + /* "PyCafe.pyx":7010 * elif isinstance(valSet[i], dtypesShort): * valType = CAFE_SHORT * elif isinstance(valSet[i], dtypesUShort): # <<<<<<<<<<<<<< * valType = CAFE_USHORT * else: */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6803, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7010, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_2 = PyObject_IsInstance(__pyx_t_8, __pyx_v_dtypesUShort); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 6803, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_t_8, __pyx_v_dtypesUShort); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 7010, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6804 + /* "PyCafe.pyx":7011 * valType = CAFE_SHORT * elif isinstance(valSet[i], dtypesUShort): * valType = CAFE_USHORT # <<<<<<<<<<<<<< @@ -114200,7 +117878,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_USHORT; - /* "PyCafe.pyx":6803 + /* "PyCafe.pyx":7010 * elif isinstance(valSet[i], dtypesShort): * valType = CAFE_SHORT * elif isinstance(valSet[i], dtypesUShort): # <<<<<<<<<<<<<< @@ -114210,7 +117888,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L37; } - /* "PyCafe.pyx":6807 + /* "PyCafe.pyx":7014 * else: * * print("PyCafe.pyx: We do not cater for type ", # <<<<<<<<<<<<<< @@ -114219,24 +117897,24 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ /*else*/ { - /* "PyCafe.pyx":6808 + /* "PyCafe.pyx":7015 * * print("PyCafe.pyx: We do not cater for type ", * type(valSet[i]), " and thus assume a string") # <<<<<<<<<<<<<< * valType = CAFE_STRING * break */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6808, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "PyCafe.pyx":6807 + /* "PyCafe.pyx":7014 * else: * * print("PyCafe.pyx: We do not cater for type ", # <<<<<<<<<<<<<< * type(valSet[i]), " and thus assume a string") * valType = CAFE_STRING */ - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6807, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7014, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_kp_u_PyCafe_pyx_We_do_not_cater_for_t); __Pyx_GIVEREF(__pyx_kp_u_PyCafe_pyx_We_do_not_cater_for_t); @@ -114248,12 +117926,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_GIVEREF(__pyx_kp_u_and_thus_assume_a_string); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_and_thus_assume_a_string); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6807, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7014, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6809 + /* "PyCafe.pyx":7016 * print("PyCafe.pyx: We do not cater for type ", * type(valSet[i]), " and thus assume a string") * valType = CAFE_STRING # <<<<<<<<<<<<<< @@ -114262,7 +117940,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_valType = CAFE_STRING; - /* "PyCafe.pyx":6810 + /* "PyCafe.pyx":7017 * type(valSet[i]), " and thus assume a string") * valType = CAFE_STRING * break # <<<<<<<<<<<<<< @@ -114275,7 +117953,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L36_break:; - /* "PyCafe.pyx":6816 + /* "PyCafe.pyx":7023 * # valSet to vector since * # coercion from Python not allowed without the GIL * if valType == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -114285,48 +117963,48 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe switch (__pyx_v_valType) { case CAFE_DOUBLE: - /* "PyCafe.pyx":6818 + /* "PyCafe.pyx":7025 * if valType == CAFE_DOUBLE: * * vecD.reserve(len(valSet)) # <<<<<<<<<<<<<< * for i in range(0, len(valSet)): * vecD.push_back(valSet[i]) */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6818, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7025, __pyx_L1_error) __pyx_v_vecD.reserve(__pyx_t_18); - /* "PyCafe.pyx":6819 + /* "PyCafe.pyx":7026 * * vecD.reserve(len(valSet)) * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< * vecD.push_back(valSet[i]) * with nogil: */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6819, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7026, __pyx_L1_error) __pyx_t_20 = __pyx_t_18; for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { __pyx_v_i = __pyx_t_21; - /* "PyCafe.pyx":6820 + /* "PyCafe.pyx":7027 * 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) */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6820, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7027, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_22 = __pyx_PyFloat_AsDouble(__pyx_t_8); if (unlikely((__pyx_t_22 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 6820, __pyx_L1_error) + __pyx_t_22 = __pyx_PyFloat_AsDouble(__pyx_t_8); if (unlikely((__pyx_t_22 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7027, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; try { __pyx_v_vecD.push_back(__pyx_t_22); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6820, __pyx_L1_error) + __PYX_ERR(3, 7027, __pyx_L1_error) } } - /* "PyCafe.pyx":6821 + /* "PyCafe.pyx":7028 * for i in range(0, len(valSet)): * vecD.push_back(valSet[i]) * with nogil: # <<<<<<<<<<<<<< @@ -114341,7 +118019,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6822 + /* "PyCafe.pyx":7029 * vecD.push_back(valSet[i]) * with nogil: * status = self._c_cafe.setVDouble(handle, vecD) # <<<<<<<<<<<<<< @@ -114351,7 +118029,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setVDouble(__pyx_v_handle, __pyx_v_vecD); } - /* "PyCafe.pyx":6821 + /* "PyCafe.pyx":7028 * for i in range(0, len(valSet)): * vecD.push_back(valSet[i]) * with nogil: # <<<<<<<<<<<<<< @@ -114370,7 +118048,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6816 + /* "PyCafe.pyx":7023 * # valSet to vector since * # coercion from Python not allowed without the GIL * if valType == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -114380,48 +118058,48 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe break; case CAFE_FLOAT: - /* "PyCafe.pyx":6826 + /* "PyCafe.pyx":7033 * elif valType == CAFE_FLOAT: * * vecF.reserve(len(valSet)) # <<<<<<<<<<<<<< * for i in range(0, len(valSet)): * vecF.push_back(valSet[i]) */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6826, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7033, __pyx_L1_error) __pyx_v_vecF.reserve(__pyx_t_18); - /* "PyCafe.pyx":6827 + /* "PyCafe.pyx":7034 * * vecF.reserve(len(valSet)) * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< * vecF.push_back(valSet[i]) * with nogil: */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6827, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7034, __pyx_L1_error) __pyx_t_20 = __pyx_t_18; for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { __pyx_v_i = __pyx_t_21; - /* "PyCafe.pyx":6828 + /* "PyCafe.pyx":7035 * 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) */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6828, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7035, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_23 = __pyx_PyFloat_AsFloat(__pyx_t_8); if (unlikely((__pyx_t_23 == (float)-1) && PyErr_Occurred())) __PYX_ERR(3, 6828, __pyx_L1_error) + __pyx_t_23 = __pyx_PyFloat_AsFloat(__pyx_t_8); if (unlikely((__pyx_t_23 == (float)-1) && PyErr_Occurred())) __PYX_ERR(3, 7035, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; try { __pyx_v_vecF.push_back(__pyx_t_23); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6828, __pyx_L1_error) + __PYX_ERR(3, 7035, __pyx_L1_error) } } - /* "PyCafe.pyx":6829 + /* "PyCafe.pyx":7036 * for i in range(0, len(valSet)): * vecF.push_back(valSet[i]) * with nogil: # <<<<<<<<<<<<<< @@ -114436,7 +118114,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6830 + /* "PyCafe.pyx":7037 * vecF.push_back(valSet[i]) * with nogil: * status = self._c_cafe.setVFloat(handle, vecF) # <<<<<<<<<<<<<< @@ -114446,7 +118124,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setVFloat(__pyx_v_handle, __pyx_v_vecF); } - /* "PyCafe.pyx":6829 + /* "PyCafe.pyx":7036 * for i in range(0, len(valSet)): * vecF.push_back(valSet[i]) * with nogil: # <<<<<<<<<<<<<< @@ -114465,7 +118143,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6824 + /* "PyCafe.pyx":7031 * status = self._c_cafe.setVDouble(handle, vecD) * * elif valType == CAFE_FLOAT: # <<<<<<<<<<<<<< @@ -114475,48 +118153,48 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe break; case CAFE_LONG: - /* "PyCafe.pyx":6834 + /* "PyCafe.pyx":7041 * elif valType == CAFE_LONG: * * vecI.reserve(len(valSet)) # <<<<<<<<<<<<<< * for i in range(0, len(valSet)): * vecI.push_back(valSet[i]) */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6834, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7041, __pyx_L1_error) __pyx_v_vecI.reserve(__pyx_t_18); - /* "PyCafe.pyx":6835 + /* "PyCafe.pyx":7042 * * vecI.reserve(len(valSet)) * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< * vecI.push_back(valSet[i]) * */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6835, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7042, __pyx_L1_error) __pyx_t_20 = __pyx_t_18; for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { __pyx_v_i = __pyx_t_21; - /* "PyCafe.pyx":6836 + /* "PyCafe.pyx":7043 * vecI.reserve(len(valSet)) * for i in range(0, len(valSet)): * vecI.push_back(valSet[i]) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6836, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7043, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_24 = __Pyx_PyInt_As_dbr_long_t(__pyx_t_8); if (unlikely((__pyx_t_24 == ((dbr_long_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 6836, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_dbr_long_t(__pyx_t_8); if (unlikely((__pyx_t_24 == ((dbr_long_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 7043, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; try { __pyx_v_vecI.push_back(__pyx_t_24); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6836, __pyx_L1_error) + __PYX_ERR(3, 7043, __pyx_L1_error) } } - /* "PyCafe.pyx":6838 + /* "PyCafe.pyx":7045 * vecI.push_back(valSet[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -114531,7 +118209,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6839 + /* "PyCafe.pyx":7046 * * with nogil: * status = self._c_cafe.setVLong(handle, vecI) # <<<<<<<<<<<<<< @@ -114541,7 +118219,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setVLong(__pyx_v_handle, __pyx_v_vecI); } - /* "PyCafe.pyx":6838 + /* "PyCafe.pyx":7045 * vecI.push_back(valSet[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -114560,7 +118238,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6832 + /* "PyCafe.pyx":7039 * status = self._c_cafe.setVFloat(handle, vecF) * * elif valType == CAFE_LONG: # <<<<<<<<<<<<<< @@ -114570,48 +118248,48 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe break; case CAFE_SHORT: - /* "PyCafe.pyx":6843 + /* "PyCafe.pyx":7050 * elif valType == CAFE_SHORT: * * vecShort.reserve(len(valSet)) # <<<<<<<<<<<<<< * for i in range(0, len(valSet)): * vecShort.push_back(valSet[i]) */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6843, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7050, __pyx_L1_error) __pyx_v_vecShort.reserve(__pyx_t_18); - /* "PyCafe.pyx":6844 + /* "PyCafe.pyx":7051 * * vecShort.reserve(len(valSet)) * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< * vecShort.push_back(valSet[i]) * */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6844, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7051, __pyx_L1_error) __pyx_t_20 = __pyx_t_18; for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { __pyx_v_i = __pyx_t_21; - /* "PyCafe.pyx":6845 + /* "PyCafe.pyx":7052 * vecShort.reserve(len(valSet)) * for i in range(0, len(valSet)): * vecShort.push_back(valSet[i]) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6845, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7052, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_25 = __Pyx_PyInt_As_short(__pyx_t_8); if (unlikely((__pyx_t_25 == (short)-1) && PyErr_Occurred())) __PYX_ERR(3, 6845, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_short(__pyx_t_8); if (unlikely((__pyx_t_25 == (short)-1) && PyErr_Occurred())) __PYX_ERR(3, 7052, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; try { __pyx_v_vecShort.push_back(__pyx_t_25); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6845, __pyx_L1_error) + __PYX_ERR(3, 7052, __pyx_L1_error) } } - /* "PyCafe.pyx":6847 + /* "PyCafe.pyx":7054 * vecShort.push_back(valSet[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -114626,7 +118304,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6848 + /* "PyCafe.pyx":7055 * * with nogil: * status = self._c_cafe.setVShort(handle, vecShort) # <<<<<<<<<<<<<< @@ -114636,7 +118314,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setVShort(__pyx_v_handle, __pyx_v_vecShort); } - /* "PyCafe.pyx":6847 + /* "PyCafe.pyx":7054 * vecShort.push_back(valSet[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -114655,7 +118333,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6841 + /* "PyCafe.pyx":7048 * status = self._c_cafe.setVLong(handle, vecI) * * elif valType == CAFE_SHORT: # <<<<<<<<<<<<<< @@ -114665,48 +118343,48 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe break; case CAFE_USHORT: - /* "PyCafe.pyx":6852 + /* "PyCafe.pyx":7059 * elif valType == CAFE_USHORT: * * vecUShort.reserve(len(valSet)) # <<<<<<<<<<<<<< * for i in range(0, len(valSet)): * vecUShort.push_back(valSet[i]) */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6852, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7059, __pyx_L1_error) __pyx_v_vecUShort.reserve(__pyx_t_18); - /* "PyCafe.pyx":6853 + /* "PyCafe.pyx":7060 * * vecUShort.reserve(len(valSet)) * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< * vecUShort.push_back(valSet[i]) * */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6853, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7060, __pyx_L1_error) __pyx_t_20 = __pyx_t_18; for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { __pyx_v_i = __pyx_t_21; - /* "PyCafe.pyx":6854 + /* "PyCafe.pyx":7061 * vecUShort.reserve(len(valSet)) * for i in range(0, len(valSet)): * vecUShort.push_back(valSet[i]) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6854, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_26 = __Pyx_PyInt_As_unsigned_short(__pyx_t_8); if (unlikely((__pyx_t_26 == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 6854, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyInt_As_unsigned_short(__pyx_t_8); if (unlikely((__pyx_t_26 == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 7061, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; try { __pyx_v_vecUShort.push_back(__pyx_t_26); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6854, __pyx_L1_error) + __PYX_ERR(3, 7061, __pyx_L1_error) } } - /* "PyCafe.pyx":6856 + /* "PyCafe.pyx":7063 * vecUShort.push_back(valSet[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -114721,7 +118399,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6857 + /* "PyCafe.pyx":7064 * * with nogil: * status = self._c_cafe.setVUShort(handle, vecUShort) # <<<<<<<<<<<<<< @@ -114731,7 +118409,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setVUShort(__pyx_v_handle, __pyx_v_vecUShort); } - /* "PyCafe.pyx":6856 + /* "PyCafe.pyx":7063 * vecUShort.push_back(valSet[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -114750,7 +118428,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6850 + /* "PyCafe.pyx":7057 * status = self._c_cafe.setVShort(handle, vecShort) * * elif valType == CAFE_USHORT: # <<<<<<<<<<<<<< @@ -114760,48 +118438,48 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe break; case CAFE_CHAR: - /* "PyCafe.pyx":6861 + /* "PyCafe.pyx":7068 * elif valType == CAFE_CHAR: * * vecChar.reserve(len(valSet)) # <<<<<<<<<<<<<< * for i in range(0, len(valSet)): * vecChar.push_back(valSet[i]) */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6861, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7068, __pyx_L1_error) __pyx_v_vecChar.reserve(__pyx_t_18); - /* "PyCafe.pyx":6862 + /* "PyCafe.pyx":7069 * * vecChar.reserve(len(valSet)) * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< * vecChar.push_back(valSet[i]) * */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6862, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7069, __pyx_L1_error) __pyx_t_20 = __pyx_t_18; for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { __pyx_v_i = __pyx_t_21; - /* "PyCafe.pyx":6863 + /* "PyCafe.pyx":7070 * vecChar.reserve(len(valSet)) * for i in range(0, len(valSet)): * vecChar.push_back(valSet[i]) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6863, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7070, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_27 = __Pyx_PyInt_As_dbr_char_t(__pyx_t_8); if (unlikely((__pyx_t_27 == ((dbr_char_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 6863, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_dbr_char_t(__pyx_t_8); if (unlikely((__pyx_t_27 == ((dbr_char_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 7070, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; try { __pyx_v_vecChar.push_back(__pyx_t_27); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6863, __pyx_L1_error) + __PYX_ERR(3, 7070, __pyx_L1_error) } } - /* "PyCafe.pyx":6865 + /* "PyCafe.pyx":7072 * vecChar.push_back(valSet[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -114816,7 +118494,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6866 + /* "PyCafe.pyx":7073 * * with nogil: * status = self._c_cafe.setVChar(handle, vecChar) # <<<<<<<<<<<<<< @@ -114826,7 +118504,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setVChar(__pyx_v_handle, __pyx_v_vecChar); } - /* "PyCafe.pyx":6865 + /* "PyCafe.pyx":7072 * vecChar.push_back(valSet[i]) * * with nogil: # <<<<<<<<<<<<<< @@ -114845,7 +118523,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6859 + /* "PyCafe.pyx":7066 * status = self._c_cafe.setVUShort(handle, vecUShort) * * elif valType == CAFE_CHAR: # <<<<<<<<<<<<<< @@ -114855,52 +118533,52 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe break; case CAFE_STRING: - /* "PyCafe.pyx":6870 + /* "PyCafe.pyx":7077 * elif valType == CAFE_STRING: * * vecS.reserve(len(valSet)) # <<<<<<<<<<<<<< * for i in range(0, len(valSet)): * if isinstance(valSet[i], str): */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6870, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7077, __pyx_L1_error) __pyx_v_vecS.reserve(__pyx_t_18); - /* "PyCafe.pyx":6871 + /* "PyCafe.pyx":7078 * * vecS.reserve(len(valSet)) * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< * if isinstance(valSet[i], str): * #valSet[i] = (valSet[i]).encode('utf_8') */ - __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 6871, __pyx_L1_error) + __pyx_t_18 = PyObject_Length(__pyx_v_valSet); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7078, __pyx_L1_error) __pyx_t_20 = __pyx_t_18; for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { __pyx_v_i = __pyx_t_21; - /* "PyCafe.pyx":6872 + /* "PyCafe.pyx":7079 * vecS.reserve(len(valSet)) * for i in range(0, len(valSet)): * if isinstance(valSet[i], str): # <<<<<<<<<<<<<< * #valSet[i] = (valSet[i]).encode('utf_8') * temp = (valSet[i]).encode('utf_8') */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6872, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7079, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_3 = PyUnicode_Check(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6874 + /* "PyCafe.pyx":7081 * if isinstance(valSet[i], str): * #valSet[i] = (valSet[i]).encode('utf_8') * temp = (valSet[i]).encode('utf_8') # <<<<<<<<<<<<<< * elif isinstance(valSet[i], (bytes, bytearray)): * encoding = False */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6874, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_encode); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6874, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_encode); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -114913,15 +118591,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_10, function); } } - __pyx_t_8 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_6, __pyx_n_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_n_u_utf_8); + __pyx_t_8 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_6, __pyx_n_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_n_u_utf_8_2); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6874, __pyx_L1_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF_SET(__pyx_v_temp, __pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6872 + /* "PyCafe.pyx":7079 * vecS.reserve(len(valSet)) * for i in range(0, len(valSet)): * if isinstance(valSet[i], str): # <<<<<<<<<<<<<< @@ -114931,14 +118609,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L74; } - /* "PyCafe.pyx":6875 + /* "PyCafe.pyx":7082 * #valSet[i] = (valSet[i]).encode('utf_8') * temp = (valSet[i]).encode('utf_8') * elif isinstance(valSet[i], (bytes, bytearray)): # <<<<<<<<<<<<<< * encoding = False * if not encoding: */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6875, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7082, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_3 = PyBytes_Check(__pyx_t_8); __pyx_t_1 = (__pyx_t_3 != 0); @@ -114955,7 +118633,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6876 + /* "PyCafe.pyx":7083 * temp = (valSet[i]).encode('utf_8') * elif isinstance(valSet[i], (bytes, bytearray)): * encoding = False # <<<<<<<<<<<<<< @@ -114964,7 +118642,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":6877 + /* "PyCafe.pyx":7084 * elif isinstance(valSet[i], (bytes, bytearray)): * encoding = False * if not encoding: # <<<<<<<<<<<<<< @@ -114974,7 +118652,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6878 + /* "PyCafe.pyx":7085 * encoding = False * if not encoding: * try: # <<<<<<<<<<<<<< @@ -114990,16 +118668,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_30); /*try:*/ { - /* "PyCafe.pyx":6879 + /* "PyCafe.pyx":7086 * if not encoding: * try: * temp = (valSet[i]).decode('utf_8') # <<<<<<<<<<<<<< * encoding = True * print('utf-8') */ - __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6879, __pyx_L78_error) + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7086, __pyx_L78_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6879, __pyx_L78_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7086, __pyx_L78_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = NULL; @@ -115012,15 +118690,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_10, __pyx_n_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_8); + __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_10, __pyx_n_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_8_2); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6879, __pyx_L78_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7086, __pyx_L78_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_temp, __pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6880 + /* "PyCafe.pyx":7087 * try: * temp = (valSet[i]).decode('utf_8') * encoding = True # <<<<<<<<<<<<<< @@ -115029,25 +118707,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":6881 + /* "PyCafe.pyx":7088 * temp = (valSet[i]).decode('utf_8') * encoding = True * print('utf-8') # <<<<<<<<<<<<<< * vecS.push_back(temp.encode('utf_8')) * except UnicodeDecodeError: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__122, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6881, __pyx_L78_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__117, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7088, __pyx_L78_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6882 + /* "PyCafe.pyx":7089 * encoding = True * print('utf-8') * vecS.push_back(temp.encode('utf_8')) # <<<<<<<<<<<<<< * except UnicodeDecodeError: * pass */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_temp, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6882, __pyx_L78_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_temp, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7089, __pyx_L78_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_10 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -115059,21 +118737,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_10, __pyx_n_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_8); + __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_10, __pyx_n_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_8_2); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6882, __pyx_L78_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7089, __pyx_L78_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6882, __pyx_L78_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7089, __pyx_L78_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; try { __pyx_v_vecS.push_back(__pyx_t_31); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6882, __pyx_L78_error) + __PYX_ERR(3, 7089, __pyx_L78_error) } - /* "PyCafe.pyx":6878 + /* "PyCafe.pyx":7085 * encoding = False * if not encoding: * try: # <<<<<<<<<<<<<< @@ -115099,7 +118777,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6883 + /* "PyCafe.pyx":7090 * print('utf-8') * vecS.push_back(temp.encode('utf_8')) * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -115114,7 +118792,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L80_except_error; __pyx_L80_except_error:; - /* "PyCafe.pyx":6878 + /* "PyCafe.pyx":7085 * encoding = False * if not encoding: * try: # <<<<<<<<<<<<<< @@ -115134,7 +118812,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_L85_try_end:; } - /* "PyCafe.pyx":6877 + /* "PyCafe.pyx":7084 * elif isinstance(valSet[i], (bytes, bytearray)): * encoding = False * if not encoding: # <<<<<<<<<<<<<< @@ -115143,7 +118821,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6885 + /* "PyCafe.pyx":7092 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -115153,7 +118831,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6886 + /* "PyCafe.pyx":7093 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -115169,16 +118847,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_28); /*try:*/ { - /* "PyCafe.pyx":6887 + /* "PyCafe.pyx":7094 * if not encoding: * try: * temp = (valSet[i]).decode('utf_16') # <<<<<<<<<<<<<< * encoding = True * print('utf-16') */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6887, __pyx_L87_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7094, __pyx_L87_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6887, __pyx_L87_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7094, __pyx_L87_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -115191,15 +118869,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_10, function); } } - __pyx_t_8 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_6, __pyx_n_u_utf_16) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_n_u_utf_16); + __pyx_t_8 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_6, __pyx_n_u_utf_16_2) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_n_u_utf_16_2); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6887, __pyx_L87_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7094, __pyx_L87_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF_SET(__pyx_v_temp, __pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6888 + /* "PyCafe.pyx":7095 * try: * temp = (valSet[i]).decode('utf_16') * encoding = True # <<<<<<<<<<<<<< @@ -115208,25 +118886,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":6889 + /* "PyCafe.pyx":7096 * temp = (valSet[i]).decode('utf_16') * encoding = True * print('utf-16') # <<<<<<<<<<<<<< * vecS.push_back(temp.encode('utf_16').decode('utf_16')) * except UnicodeDecodeError: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__123, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6889, __pyx_L87_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__118, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7096, __pyx_L87_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6890 + /* "PyCafe.pyx":7097 * encoding = True * print('utf-16') * vecS.push_back(temp.encode('utf_16').decode('utf_16')) # <<<<<<<<<<<<<< * except UnicodeDecodeError: * pass */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_temp, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6890, __pyx_L87_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_temp, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7097, __pyx_L87_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -115238,12 +118916,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_10 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_n_u_utf_16) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_16); + __pyx_t_10 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_n_u_utf_16_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_16_2); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6890, __pyx_L87_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7097, __pyx_L87_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6890, __pyx_L87_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7097, __pyx_L87_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = NULL; @@ -115256,21 +118934,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_10, __pyx_n_u_utf_16) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_16); + __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_10, __pyx_n_u_utf_16_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_16_2); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6890, __pyx_L87_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7097, __pyx_L87_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6890, __pyx_L87_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7097, __pyx_L87_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; try { __pyx_v_vecS.push_back(((std::string)__pyx_t_31)); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6890, __pyx_L87_error) + __PYX_ERR(3, 7097, __pyx_L87_error) } - /* "PyCafe.pyx":6886 + /* "PyCafe.pyx":7093 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -115296,7 +118974,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6891 + /* "PyCafe.pyx":7098 * print('utf-16') * vecS.push_back(temp.encode('utf_16').decode('utf_16')) * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -115311,7 +118989,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L89_except_error; __pyx_L89_except_error:; - /* "PyCafe.pyx":6886 + /* "PyCafe.pyx":7093 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -115331,7 +119009,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_L94_try_end:; } - /* "PyCafe.pyx":6885 + /* "PyCafe.pyx":7092 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -115340,7 +119018,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6893 + /* "PyCafe.pyx":7100 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -115350,7 +119028,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6894 + /* "PyCafe.pyx":7101 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -115366,16 +119044,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_30); /*try:*/ { - /* "PyCafe.pyx":6895 + /* "PyCafe.pyx":7102 * if not encoding: * try: * temp = (valSet[i]).decode('utf_32') # <<<<<<<<<<<<<< * encoding = True * print('utf-32') */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6895, __pyx_L96_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7102, __pyx_L96_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6895, __pyx_L96_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7102, __pyx_L96_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -115390,13 +119068,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } __pyx_t_8 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_6, __pyx_n_u_utf_32) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_n_u_utf_32); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6895, __pyx_L96_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7102, __pyx_L96_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF_SET(__pyx_v_temp, __pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6896 + /* "PyCafe.pyx":7103 * try: * temp = (valSet[i]).decode('utf_32') * encoding = True # <<<<<<<<<<<<<< @@ -115405,25 +119083,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":6897 + /* "PyCafe.pyx":7104 * temp = (valSet[i]).decode('utf_32') * encoding = True * print('utf-32') # <<<<<<<<<<<<<< * vecS.push_back(temp.encode('utf_32')) * except UnicodeDecodeError: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__124, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6897, __pyx_L96_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__119, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7104, __pyx_L96_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6898 + /* "PyCafe.pyx":7105 * encoding = True * print('utf-32') * vecS.push_back(temp.encode('utf_32')) # <<<<<<<<<<<<<< * except UnicodeDecodeError: * pass */ - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_temp, __pyx_n_s_encode); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6898, __pyx_L96_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_temp, __pyx_n_s_encode); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7105, __pyx_L96_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) { @@ -115437,19 +119115,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } __pyx_t_8 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_6, __pyx_n_u_utf_32) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_n_u_utf_32); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6898, __pyx_L96_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7105, __pyx_L96_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6898, __pyx_L96_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7105, __pyx_L96_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; try { __pyx_v_vecS.push_back(__pyx_t_31); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6898, __pyx_L96_error) + __PYX_ERR(3, 7105, __pyx_L96_error) } - /* "PyCafe.pyx":6894 + /* "PyCafe.pyx":7101 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -115475,7 +119153,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6899 + /* "PyCafe.pyx":7106 * print('utf-32') * vecS.push_back(temp.encode('utf_32')) * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -115490,7 +119168,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L98_except_error; __pyx_L98_except_error:; - /* "PyCafe.pyx":6894 + /* "PyCafe.pyx":7101 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -115510,7 +119188,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_L103_try_end:; } - /* "PyCafe.pyx":6893 + /* "PyCafe.pyx":7100 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -115519,7 +119197,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6875 + /* "PyCafe.pyx":7082 * #valSet[i] = (valSet[i]).encode('utf_8') * temp = (valSet[i]).encode('utf_8') * elif isinstance(valSet[i], (bytes, bytearray)): # <<<<<<<<<<<<<< @@ -115529,7 +119207,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L74; } - /* "PyCafe.pyx":6902 + /* "PyCafe.pyx":7109 * pass * else: * print('utf-none', type(valSet[i])) # <<<<<<<<<<<<<< @@ -115537,9 +119215,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe * vecS.push_back( temp) */ /*else*/ { - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6902, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6902, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_kp_u_utf_none); __Pyx_GIVEREF(__pyx_kp_u_utf_none); @@ -115548,42 +119226,42 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_t_8))); PyTuple_SET_ITEM(__pyx_t_10, 1, ((PyObject *)Py_TYPE(__pyx_t_8))); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6902, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6903 + /* "PyCafe.pyx":7110 * else: * print('utf-none', type(valSet[i])) * temp = valSet[i] # <<<<<<<<<<<<<< * vecS.push_back( temp) * */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6903, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_XDECREF_SET(__pyx_v_temp, __pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":6904 + /* "PyCafe.pyx":7111 * print('utf-none', type(valSet[i])) * temp = valSet[i] * vecS.push_back( temp) # <<<<<<<<<<<<<< * * with nogil: */ - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_v_temp); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6904, __pyx_L1_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_v_temp); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7111, __pyx_L1_error) try { __pyx_v_vecS.push_back(((std::string)__pyx_t_31)); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 6904, __pyx_L1_error) + __PYX_ERR(3, 7111, __pyx_L1_error) } } __pyx_L74:; } - /* "PyCafe.pyx":6906 + /* "PyCafe.pyx":7113 * vecS.push_back( temp) * * with nogil: # <<<<<<<<<<<<<< @@ -115598,7 +119276,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6907 + /* "PyCafe.pyx":7114 * * with nogil: * status = self._c_cafe.setVString(handle, vecS) # <<<<<<<<<<<<<< @@ -115608,7 +119286,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setVString(__pyx_v_handle, __pyx_v_vecS); } - /* "PyCafe.pyx":6906 + /* "PyCafe.pyx":7113 * vecS.push_back( temp) * * with nogil: # <<<<<<<<<<<<<< @@ -115627,7 +119305,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6868 + /* "PyCafe.pyx":7075 * status = self._c_cafe.setVChar(handle, vecChar) * * elif valType == CAFE_STRING: # <<<<<<<<<<<<<< @@ -115638,7 +119316,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe default: break; } - /* "PyCafe.pyx":6772 + /* "PyCafe.pyx":6979 * valSet = valSet[0] * * if isGoodType: # <<<<<<<<<<<<<< @@ -115648,7 +119326,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6909 + /* "PyCafe.pyx":7116 * status = self._c_cafe.setVString(handle, vecS) * * elif isBytesType: # <<<<<<<<<<<<<< @@ -115658,20 +119336,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_v_isBytesType != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6911 + /* "PyCafe.pyx":7118 * elif isBytesType: * #print("isBytesType") * valSetS = valSet.value # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setString(handle, valSetS) */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6911, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6911, __pyx_L1_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7118, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_valSetS = ((std::string)__pyx_t_31); - /* "PyCafe.pyx":6912 + /* "PyCafe.pyx":7119 * #print("isBytesType") * valSetS = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -115686,7 +119364,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6913 + /* "PyCafe.pyx":7120 * valSetS = valSet.value * with nogil: * status = self._c_cafe.setString(handle, valSetS) # <<<<<<<<<<<<<< @@ -115696,7 +119374,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setString(__pyx_v_handle, __pyx_v_valSetS); } - /* "PyCafe.pyx":6912 + /* "PyCafe.pyx":7119 * #print("isBytesType") * valSetS = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -115715,7 +119393,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6909 + /* "PyCafe.pyx":7116 * status = self._c_cafe.setVString(handle, vecS) * * elif isBytesType: # <<<<<<<<<<<<<< @@ -115725,33 +119403,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6914 + /* "PyCafe.pyx":7121 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, (ctypes.c_char)): # <<<<<<<<<<<<<< * #print("is ctypes.c_char") * # print(valSet.value) */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6914, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_c_char); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6914, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_c_char); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_t_10); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 6914, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_t_10); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 7121, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6918 + /* "PyCafe.pyx":7125 * # print(valSet.value) * # print(valSet.value.decode()) * valSetS = valSet.value.decode() # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setString(handle, valSetS) */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 6918, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6918, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; @@ -115766,14 +119444,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6918, __pyx_L1_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6918, __pyx_L1_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7125, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetS = __pyx_t_31; - /* "PyCafe.pyx":6919 + /* "PyCafe.pyx":7126 * # print(valSet.value.decode()) * valSetS = valSet.value.decode() * with nogil: # <<<<<<<<<<<<<< @@ -115788,7 +119466,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6920 + /* "PyCafe.pyx":7127 * valSetS = valSet.value.decode() * with nogil: * status = self._c_cafe.setString(handle, valSetS) # <<<<<<<<<<<<<< @@ -115798,7 +119476,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setString(__pyx_v_handle, __pyx_v_valSetS); } - /* "PyCafe.pyx":6919 + /* "PyCafe.pyx":7126 * # print(valSet.value.decode()) * valSetS = valSet.value.decode() * with nogil: # <<<<<<<<<<<<<< @@ -115817,7 +119495,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6914 + /* "PyCafe.pyx":7121 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, (ctypes.c_char)): # <<<<<<<<<<<<<< @@ -115827,37 +119505,37 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6921 + /* "PyCafe.pyx":7128 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, (ctypes.c_float)): # <<<<<<<<<<<<<< * valSetF = valSet.value * with nogil: */ - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6921, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_c_float); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6921, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_c_float); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_t_6); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 6921, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_t_6); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 7128, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6922 + /* "PyCafe.pyx":7129 * 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) */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6922, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_23 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_23 == (float)-1) && PyErr_Occurred())) __PYX_ERR(3, 6922, __pyx_L1_error) + __pyx_t_23 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_23 == (float)-1) && PyErr_Occurred())) __PYX_ERR(3, 7129, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_valSetF = ((float)__pyx_t_23); - /* "PyCafe.pyx":6923 + /* "PyCafe.pyx":7130 * elif isinstance(valSet, (ctypes.c_float)): * valSetF = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -115872,7 +119550,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6924 + /* "PyCafe.pyx":7131 * valSetF = valSet.value * with nogil: * status = self._c_cafe.setFloat(handle, valSetF) # <<<<<<<<<<<<<< @@ -115882,7 +119560,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setFloat(__pyx_v_handle, __pyx_v_valSetF); } - /* "PyCafe.pyx":6923 + /* "PyCafe.pyx":7130 * elif isinstance(valSet, (ctypes.c_float)): * valSetF = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -115901,7 +119579,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6921 + /* "PyCafe.pyx":7128 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, (ctypes.c_float)): # <<<<<<<<<<<<<< @@ -115911,37 +119589,37 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6925 + /* "PyCafe.pyx":7132 * with nogil: * status = self._c_cafe.setFloat(handle, valSetF) * elif isinstance(valSet, (ctypes.c_double)): # <<<<<<<<<<<<<< * valSetD = valSet.value * with nogil: */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6925, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ctypes); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7132, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_double); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6925, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_c_double); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7132, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_t_10); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 6925, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_t_10); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 7132, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6926 + /* "PyCafe.pyx":7133 * 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) */ - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6926, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7133, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_22 = __pyx_PyFloat_AsDouble(__pyx_t_10); if (unlikely((__pyx_t_22 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 6926, __pyx_L1_error) + __pyx_t_22 = __pyx_PyFloat_AsDouble(__pyx_t_10); if (unlikely((__pyx_t_22 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7133, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetD = ((double)__pyx_t_22); - /* "PyCafe.pyx":6927 + /* "PyCafe.pyx":7134 * elif isinstance(valSet, (ctypes.c_double)): * valSetD = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -115956,7 +119634,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6928 + /* "PyCafe.pyx":7135 * valSetD = valSet.value * with nogil: * status = self._c_cafe.setDouble(handle, valSetD) # <<<<<<<<<<<<<< @@ -115966,7 +119644,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setDouble(__pyx_v_handle, __pyx_v_valSetD); } - /* "PyCafe.pyx":6927 + /* "PyCafe.pyx":7134 * elif isinstance(valSet, (ctypes.c_double)): * valSetD = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -115985,7 +119663,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6925 + /* "PyCafe.pyx":7132 * with nogil: * status = self._c_cafe.setFloat(handle, valSetF) * elif isinstance(valSet, (ctypes.c_double)): # <<<<<<<<<<<<<< @@ -115995,31 +119673,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6929 + /* "PyCafe.pyx":7136 * with nogil: * status = self._c_cafe.setDouble(handle, valSetD) * elif isinstance(valSet, ctypesInt): # <<<<<<<<<<<<<< * # print("ctypesInt") * valSetI = valSet.value */ - __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesInt); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 6929, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesInt); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 7136, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6931 + /* "PyCafe.pyx":7138 * elif isinstance(valSet, ctypesInt): * # print("ctypesInt") * valSetI = valSet.value # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setLong(handle, valSetI) */ - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6931, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6931, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7138, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetI = ((int)__pyx_t_17); - /* "PyCafe.pyx":6932 + /* "PyCafe.pyx":7139 * # print("ctypesInt") * valSetI = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116034,7 +119712,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6933 + /* "PyCafe.pyx":7140 * valSetI = valSet.value * with nogil: * status = self._c_cafe.setLong(handle, valSetI) # <<<<<<<<<<<<<< @@ -116044,7 +119722,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setLong(__pyx_v_handle, __pyx_v_valSetI); } - /* "PyCafe.pyx":6932 + /* "PyCafe.pyx":7139 * # print("ctypesInt") * valSetI = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116063,7 +119741,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6929 + /* "PyCafe.pyx":7136 * with nogil: * status = self._c_cafe.setDouble(handle, valSetD) * elif isinstance(valSet, ctypesInt): # <<<<<<<<<<<<<< @@ -116073,31 +119751,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6934 + /* "PyCafe.pyx":7141 * with nogil: * status = self._c_cafe.setLong(handle, valSetI) * elif isinstance(valSet, ctypesLongLong): # <<<<<<<<<<<<<< * # print("ctypesLongLong") * valSetLL = valSet.value */ - __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesLongLong); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 6934, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesLongLong); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 7141, __pyx_L1_error) __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6936 + /* "PyCafe.pyx":7143 * elif isinstance(valSet, ctypesLongLong): * # print("ctypesLongLong") * valSetLL = valSet.value # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setLong(handle, valSetLL) */ - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6936, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_32 = __Pyx_PyInt_As_PY_LONG_LONG(__pyx_t_10); if (unlikely((__pyx_t_32 == (PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(3, 6936, __pyx_L1_error) + __pyx_t_32 = __Pyx_PyInt_As_PY_LONG_LONG(__pyx_t_10); if (unlikely((__pyx_t_32 == (PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(3, 7143, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetLL = ((PY_LONG_LONG)__pyx_t_32); - /* "PyCafe.pyx":6937 + /* "PyCafe.pyx":7144 * # print("ctypesLongLong") * valSetLL = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116112,7 +119790,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6938 + /* "PyCafe.pyx":7145 * valSetLL = valSet.value * with nogil: * status = self._c_cafe.setLong(handle, valSetLL) # <<<<<<<<<<<<<< @@ -116122,7 +119800,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setLong(__pyx_v_handle, __pyx_v_valSetLL); } - /* "PyCafe.pyx":6937 + /* "PyCafe.pyx":7144 * # print("ctypesLongLong") * valSetLL = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116141,7 +119819,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6934 + /* "PyCafe.pyx":7141 * with nogil: * status = self._c_cafe.setLong(handle, valSetI) * elif isinstance(valSet, ctypesLongLong): # <<<<<<<<<<<<<< @@ -116151,31 +119829,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6939 + /* "PyCafe.pyx":7146 * with nogil: * status = self._c_cafe.setLong(handle, valSetLL) * elif isinstance(valSet, ctypesShort): # <<<<<<<<<<<<<< * #print("ctypesShort") * valSetShort = valSet.value */ - __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesShort); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 6939, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesShort); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 7146, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6941 + /* "PyCafe.pyx":7148 * elif isinstance(valSet, ctypesShort): * #print("ctypesShort") * valSetShort = valSet.value # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setShort(handle, valSetShort) */ - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6941, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_25 = __Pyx_PyInt_As_short(__pyx_t_10); if (unlikely((__pyx_t_25 == (short)-1) && PyErr_Occurred())) __PYX_ERR(3, 6941, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_short(__pyx_t_10); if (unlikely((__pyx_t_25 == (short)-1) && PyErr_Occurred())) __PYX_ERR(3, 7148, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetShort = ((short)__pyx_t_25); - /* "PyCafe.pyx":6942 + /* "PyCafe.pyx":7149 * #print("ctypesShort") * valSetShort = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116190,7 +119868,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6943 + /* "PyCafe.pyx":7150 * valSetShort = valSet.value * with nogil: * status = self._c_cafe.setShort(handle, valSetShort) # <<<<<<<<<<<<<< @@ -116200,7 +119878,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setShort(__pyx_v_handle, __pyx_v_valSetShort); } - /* "PyCafe.pyx":6942 + /* "PyCafe.pyx":7149 * #print("ctypesShort") * valSetShort = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116219,7 +119897,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6939 + /* "PyCafe.pyx":7146 * with nogil: * status = self._c_cafe.setLong(handle, valSetLL) * elif isinstance(valSet, ctypesShort): # <<<<<<<<<<<<<< @@ -116229,31 +119907,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6944 + /* "PyCafe.pyx":7151 * with nogil: * status = self._c_cafe.setShort(handle, valSetShort) * elif isinstance(valSet, ctypesUShort): # <<<<<<<<<<<<<< * #print("ctypesUShort") * valSetUShort = valSet.value */ - __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesUShort); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 6944, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesUShort); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 7151, __pyx_L1_error) __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6946 + /* "PyCafe.pyx":7153 * elif isinstance(valSet, ctypesUShort): * #print("ctypesUShort") * valSetUShort = valSet.value # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setUShort(handle, valSetUShort) */ - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6946, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7153, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_26 = __Pyx_PyInt_As_unsigned_short(__pyx_t_10); if (unlikely((__pyx_t_26 == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 6946, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyInt_As_unsigned_short(__pyx_t_10); if (unlikely((__pyx_t_26 == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(3, 7153, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetUShort = ((unsigned short)__pyx_t_26); - /* "PyCafe.pyx":6947 + /* "PyCafe.pyx":7154 * #print("ctypesUShort") * valSetUShort = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116268,7 +119946,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6948 + /* "PyCafe.pyx":7155 * valSetUShort = valSet.value * with nogil: * status = self._c_cafe.setUShort(handle, valSetUShort) # <<<<<<<<<<<<<< @@ -116278,7 +119956,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setUShort(__pyx_v_handle, __pyx_v_valSetUShort); } - /* "PyCafe.pyx":6947 + /* "PyCafe.pyx":7154 * #print("ctypesUShort") * valSetUShort = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116297,7 +119975,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6944 + /* "PyCafe.pyx":7151 * with nogil: * status = self._c_cafe.setShort(handle, valSetShort) * elif isinstance(valSet, ctypesUShort): # <<<<<<<<<<<<<< @@ -116307,31 +119985,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6949 + /* "PyCafe.pyx":7156 * with nogil: * status = self._c_cafe.setUShort(handle, valSetUShort) * elif isinstance(valSet, (ctypesString)): # <<<<<<<<<<<<<< * #print("ctypesString") * valSetS = valSet.value */ - __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesString); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 6949, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesString); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(3, 7156, __pyx_L1_error) __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6951 + /* "PyCafe.pyx":7158 * elif isinstance(valSet, (ctypesString)): * #print("ctypesString") * valSetS = valSet.value # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setString(handle, valSetS) */ - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6951, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6951, __pyx_L1_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7158, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetS = ((std::string)__pyx_t_31); - /* "PyCafe.pyx":6952 + /* "PyCafe.pyx":7159 * #print("ctypesString") * valSetS = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116346,7 +120024,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6953 + /* "PyCafe.pyx":7160 * valSetS = valSet.value * with nogil: * status = self._c_cafe.setString(handle, valSetS) # <<<<<<<<<<<<<< @@ -116356,7 +120034,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setString(__pyx_v_handle, __pyx_v_valSetS); } - /* "PyCafe.pyx":6952 + /* "PyCafe.pyx":7159 * #print("ctypesString") * valSetS = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116375,7 +120053,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6949 + /* "PyCafe.pyx":7156 * with nogil: * status = self._c_cafe.setUShort(handle, valSetUShort) * elif isinstance(valSet, (ctypesString)): # <<<<<<<<<<<<<< @@ -116385,31 +120063,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6954 + /* "PyCafe.pyx":7161 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, ctypesUChar): # <<<<<<<<<<<<<< * #print("ctypesUChar") * valSetUChar = valSet.value */ - __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesUChar); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 6954, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_valSet, __pyx_v_ctypesUChar); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(3, 7161, __pyx_L1_error) __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6956 + /* "PyCafe.pyx":7163 * elif isinstance(valSet, ctypesUChar): * #print("ctypesUChar") * valSetUChar = valSet.value # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setChar(handle, valSetUChar) */ - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6956, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_value_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7163, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_33 = __Pyx_PyInt_As_unsigned_char(__pyx_t_10); if (unlikely((__pyx_t_33 == (unsigned char)-1) && PyErr_Occurred())) __PYX_ERR(3, 6956, __pyx_L1_error) + __pyx_t_33 = __Pyx_PyInt_As_unsigned_char(__pyx_t_10); if (unlikely((__pyx_t_33 == (unsigned char)-1) && PyErr_Occurred())) __PYX_ERR(3, 7163, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetUChar = ((unsigned char)__pyx_t_33); - /* "PyCafe.pyx":6957 + /* "PyCafe.pyx":7164 * #print("ctypesUChar") * valSetUChar = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116424,7 +120102,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6958 + /* "PyCafe.pyx":7165 * valSetUChar = valSet.value * with nogil: * status = self._c_cafe.setChar(handle, valSetUChar) # <<<<<<<<<<<<<< @@ -116434,7 +120112,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setChar(__pyx_v_handle, __pyx_v_valSetUChar); } - /* "PyCafe.pyx":6957 + /* "PyCafe.pyx":7164 * #print("ctypesUChar") * valSetUChar = valSet.value * with nogil: # <<<<<<<<<<<<<< @@ -116453,7 +120131,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6954 + /* "PyCafe.pyx":7161 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, ctypesUChar): # <<<<<<<<<<<<<< @@ -116463,7 +120141,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6959 + /* "PyCafe.pyx":7166 * with nogil: * status = self._c_cafe.setChar(handle, valSetUChar) * elif isinstance(valSet, (float)): # <<<<<<<<<<<<<< @@ -116474,17 +120152,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6961 + /* "PyCafe.pyx":7168 * elif isinstance(valSet, (float)): * #print("float type") * valSetD = valSet # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setDouble(handle, valSetD) */ - __pyx_t_23 = __pyx_PyFloat_AsFloat(__pyx_v_valSet); if (unlikely((__pyx_t_23 == (float)-1) && PyErr_Occurred())) __PYX_ERR(3, 6961, __pyx_L1_error) + __pyx_t_23 = __pyx_PyFloat_AsFloat(__pyx_v_valSet); if (unlikely((__pyx_t_23 == (float)-1) && PyErr_Occurred())) __PYX_ERR(3, 7168, __pyx_L1_error) __pyx_v_valSetD = ((float)__pyx_t_23); - /* "PyCafe.pyx":6962 + /* "PyCafe.pyx":7169 * #print("float type") * valSetD = valSet * with nogil: # <<<<<<<<<<<<<< @@ -116499,7 +120177,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6963 + /* "PyCafe.pyx":7170 * valSetD = valSet * with nogil: * status = self._c_cafe.setDouble(handle, valSetD) # <<<<<<<<<<<<<< @@ -116509,7 +120187,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setDouble(__pyx_v_handle, __pyx_v_valSetD); } - /* "PyCafe.pyx":6962 + /* "PyCafe.pyx":7169 * #print("float type") * valSetD = valSet * with nogil: # <<<<<<<<<<<<<< @@ -116528,7 +120206,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6959 + /* "PyCafe.pyx":7166 * with nogil: * status = self._c_cafe.setChar(handle, valSetUChar) * elif isinstance(valSet, (float)): # <<<<<<<<<<<<<< @@ -116538,7 +120216,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6964 + /* "PyCafe.pyx":7171 * with nogil: * status = self._c_cafe.setDouble(handle, valSetD) * elif isinstance(valSet, (int, long)): # <<<<<<<<<<<<<< @@ -116559,17 +120237,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6966 + /* "PyCafe.pyx":7173 * elif isinstance(valSet, (int, long)): * #print("int/long type") * valSetI = valSet # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setLong(handle, valSetI) */ - __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_v_valSet); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 6966, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_v_valSet); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7173, __pyx_L1_error) __pyx_v_valSetI = ((int)__pyx_t_17); - /* "PyCafe.pyx":6967 + /* "PyCafe.pyx":7174 * #print("int/long type") * valSetI = valSet * with nogil: # <<<<<<<<<<<<<< @@ -116584,7 +120262,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6968 + /* "PyCafe.pyx":7175 * valSetI = valSet * with nogil: * status = self._c_cafe.setLong(handle, valSetI) # <<<<<<<<<<<<<< @@ -116594,7 +120272,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setLong(__pyx_v_handle, __pyx_v_valSetI); } - /* "PyCafe.pyx":6967 + /* "PyCafe.pyx":7174 * #print("int/long type") * valSetI = valSet * with nogil: # <<<<<<<<<<<<<< @@ -116613,7 +120291,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6964 + /* "PyCafe.pyx":7171 * with nogil: * status = self._c_cafe.setDouble(handle, valSetD) * elif isinstance(valSet, (int, long)): # <<<<<<<<<<<<<< @@ -116623,7 +120301,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6969 + /* "PyCafe.pyx":7176 * with nogil: * status = self._c_cafe.setLong(handle, valSetI) * elif isinstance(valSet, (str)): # <<<<<<<<<<<<<< @@ -116634,7 +120312,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6971 + /* "PyCafe.pyx":7178 * elif isinstance(valSet, (str)): * #print("str type", valSet) * encoding = False # <<<<<<<<<<<<<< @@ -116643,7 +120321,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":6972 + /* "PyCafe.pyx":7179 * #print("str type", valSet) * encoding = False * try: # <<<<<<<<<<<<<< @@ -116659,14 +120337,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_28); /*try:*/ { - /* "PyCafe.pyx":6973 + /* "PyCafe.pyx":7180 * encoding = False * try: * valSetS = valSet.encode('utf_8') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6973, __pyx_L145_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7180, __pyx_L145_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -116678,16 +120356,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_n_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_8); + __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_n_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_8_2); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6973, __pyx_L145_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7180, __pyx_L145_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6973, __pyx_L145_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7180, __pyx_L145_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetS = __pyx_t_31; - /* "PyCafe.pyx":6974 + /* "PyCafe.pyx":7181 * try: * valSetS = valSet.encode('utf_8') * encoding = True # <<<<<<<<<<<<<< @@ -116696,7 +120374,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":6972 + /* "PyCafe.pyx":7179 * #print("str type", valSet) * encoding = False * try: # <<<<<<<<<<<<<< @@ -116722,7 +120400,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":6975 + /* "PyCafe.pyx":7182 * valSetS = valSet.encode('utf_8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -116737,7 +120415,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L147_except_error; __pyx_L147_except_error:; - /* "PyCafe.pyx":6972 + /* "PyCafe.pyx":7179 * #print("str type", valSet) * encoding = False * try: # <<<<<<<<<<<<<< @@ -116757,7 +120435,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_L150_try_end:; } - /* "PyCafe.pyx":6977 + /* "PyCafe.pyx":7184 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -116767,7 +120445,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":6978 + /* "PyCafe.pyx":7185 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -116783,14 +120461,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_30); /*try:*/ { - /* "PyCafe.pyx":6979 + /* "PyCafe.pyx":7186 * if not encoding: * try: * valSetS = valSet.encode('utf_16') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6979, __pyx_L152_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7186, __pyx_L152_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -116802,16 +120480,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_n_u_utf_16) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_16); + __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_n_u_utf_16_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_16_2); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6979, __pyx_L152_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7186, __pyx_L152_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6979, __pyx_L152_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7186, __pyx_L152_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetS = __pyx_t_31; - /* "PyCafe.pyx":6980 + /* "PyCafe.pyx":7187 * try: * valSetS = valSet.encode('utf_16') * encoding = True # <<<<<<<<<<<<<< @@ -116820,7 +120498,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":6978 + /* "PyCafe.pyx":7185 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -116846,7 +120524,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":6981 + /* "PyCafe.pyx":7188 * valSetS = valSet.encode('utf_16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -116861,7 +120539,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L154_except_error; __pyx_L154_except_error:; - /* "PyCafe.pyx":6978 + /* "PyCafe.pyx":7185 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -116881,7 +120559,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_L157_try_end:; } - /* "PyCafe.pyx":6977 + /* "PyCafe.pyx":7184 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -116890,7 +120568,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":6984 + /* "PyCafe.pyx":7191 * pass * * with nogil: # <<<<<<<<<<<<<< @@ -116905,7 +120583,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":6985 + /* "PyCafe.pyx":7192 * * with nogil: * status = self._c_cafe.setString(handle, valSetS) # <<<<<<<<<<<<<< @@ -116915,7 +120593,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setString(__pyx_v_handle, __pyx_v_valSetS); } - /* "PyCafe.pyx":6984 + /* "PyCafe.pyx":7191 * pass * * with nogil: # <<<<<<<<<<<<<< @@ -116934,7 +120612,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6969 + /* "PyCafe.pyx":7176 * with nogil: * status = self._c_cafe.setLong(handle, valSetI) * elif isinstance(valSet, (str)): # <<<<<<<<<<<<<< @@ -116944,7 +120622,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":6986 + /* "PyCafe.pyx":7193 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, (bytes, bytearray)): # <<<<<<<<<<<<<< @@ -116965,7 +120643,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6988 + /* "PyCafe.pyx":7195 * elif isinstance(valSet, (bytes, bytearray)): * #print("bytes,bytearray") * encoding = False # <<<<<<<<<<<<<< @@ -116974,7 +120652,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 0; - /* "PyCafe.pyx":6989 + /* "PyCafe.pyx":7196 * #print("bytes,bytearray") * encoding = False * try: # <<<<<<<<<<<<<< @@ -116990,14 +120668,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_28); /*try:*/ { - /* "PyCafe.pyx":6990 + /* "PyCafe.pyx":7197 * encoding = False * try: * valSetS = valSet.decode('utf_8') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6990, __pyx_L163_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7197, __pyx_L163_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -117009,16 +120687,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_n_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_8); + __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_n_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_8_2); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6990, __pyx_L163_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7197, __pyx_L163_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6990, __pyx_L163_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7197, __pyx_L163_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetS = __pyx_t_31; - /* "PyCafe.pyx":6991 + /* "PyCafe.pyx":7198 * try: * valSetS = valSet.decode('utf_8') * encoding = True # <<<<<<<<<<<<<< @@ -117027,7 +120705,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":6989 + /* "PyCafe.pyx":7196 * #print("bytes,bytearray") * encoding = False * try: # <<<<<<<<<<<<<< @@ -117053,7 +120731,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":6992 + /* "PyCafe.pyx":7199 * valSetS = valSet.decode('utf_8') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -117068,7 +120746,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L165_except_error; __pyx_L165_except_error:; - /* "PyCafe.pyx":6989 + /* "PyCafe.pyx":7196 * #print("bytes,bytearray") * encoding = False * try: # <<<<<<<<<<<<<< @@ -117088,7 +120766,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_L168_try_end:; } - /* "PyCafe.pyx":6994 + /* "PyCafe.pyx":7201 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -117098,7 +120776,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":6995 + /* "PyCafe.pyx":7202 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -117114,14 +120792,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XGOTREF(__pyx_t_30); /*try:*/ { - /* "PyCafe.pyx":6996 + /* "PyCafe.pyx":7203 * if not encoding: * try: * valSetS = valSet.decode('utf_16') # <<<<<<<<<<<<<< * encoding = True * except UnicodeDecodeError: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 6996, __pyx_L170_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7203, __pyx_L170_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -117133,16 +120811,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_n_u_utf_16) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_16); + __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_n_u_utf_16_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_n_u_utf_16_2); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 6996, __pyx_L170_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7203, __pyx_L170_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 6996, __pyx_L170_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7203, __pyx_L170_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetS = ((std::string)__pyx_t_31); - /* "PyCafe.pyx":6997 + /* "PyCafe.pyx":7204 * try: * valSetS = valSet.decode('utf_16') * encoding = True # <<<<<<<<<<<<<< @@ -117151,7 +120829,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_encoding = 1; - /* "PyCafe.pyx":6995 + /* "PyCafe.pyx":7202 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -117177,7 +120855,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":6998 + /* "PyCafe.pyx":7205 * valSetS = valSet.decode('utf_16') * encoding = True * except UnicodeDecodeError: # <<<<<<<<<<<<<< @@ -117187,19 +120865,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeDecodeError); if (__pyx_t_17) { __Pyx_AddTraceback("PyCafe.CyCafe.set", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_6, &__pyx_t_8) < 0) __PYX_ERR(3, 6998, __pyx_L172_except_error) + if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_6, &__pyx_t_8) < 0) __PYX_ERR(3, 7205, __pyx_L172_except_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_8); - /* "PyCafe.pyx":6999 + /* "PyCafe.pyx":7206 * encoding = True * except UnicodeDecodeError: * print('decode utf_16 error') # <<<<<<<<<<<<<< * pass * except UnicodeEncodeError as ex: */ - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__125, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 6999, __pyx_L172_except_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__120, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7206, __pyx_L172_except_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; @@ -117208,7 +120886,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L171_exception_handled; } - /* "PyCafe.pyx":7001 + /* "PyCafe.pyx":7208 * print('decode utf_16 error') * pass * except UnicodeEncodeError as ex: # <<<<<<<<<<<<<< @@ -117218,7 +120896,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeEncodeError); if (__pyx_t_17) { __Pyx_AddTraceback("PyCafe.CyCafe.set", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_6, &__pyx_t_10) < 0) __PYX_ERR(3, 7001, __pyx_L172_except_error) + if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_6, &__pyx_t_10) < 0) __PYX_ERR(3, 7208, __pyx_L172_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_10); @@ -117226,14 +120904,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_ex = __pyx_t_6; /*try:*/ { - /* "PyCafe.pyx":7002 + /* "PyCafe.pyx":7209 * pass * except UnicodeEncodeError as ex: * print('encode utf_16 error', ex) # <<<<<<<<<<<<<< * pass * if not encoding: */ - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7002, __pyx_L183_error) + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7209, __pyx_L183_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_kp_u_encode_utf_16_error); __Pyx_GIVEREF(__pyx_kp_u_encode_utf_16_error); @@ -117241,13 +120919,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_INCREF(__pyx_v_ex); __Pyx_GIVEREF(__pyx_v_ex); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_ex); - __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 7002, __pyx_L183_error) + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_7, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 7209, __pyx_L183_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } - /* "PyCafe.pyx":7001 + /* "PyCafe.pyx":7208 * print('decode utf_16 error') * pass * except UnicodeEncodeError as ex: # <<<<<<<<<<<<<< @@ -117311,7 +120989,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L172_except_error; __pyx_L172_except_error:; - /* "PyCafe.pyx":6995 + /* "PyCafe.pyx":7202 * pass * if not encoding: * try: # <<<<<<<<<<<<<< @@ -117331,7 +121009,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_L175_try_end:; } - /* "PyCafe.pyx":6994 + /* "PyCafe.pyx":7201 * except UnicodeDecodeError: * pass * if not encoding: # <<<<<<<<<<<<<< @@ -117340,7 +121018,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":7004 + /* "PyCafe.pyx":7211 * print('encode utf_16 error', ex) * pass * if not encoding: # <<<<<<<<<<<<<< @@ -117350,28 +121028,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_2 = ((!(__pyx_v_encoding != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7005 + /* "PyCafe.pyx":7212 * pass * if not encoding: * print('no encoding done') # <<<<<<<<<<<<<< * valSetS = valSet * with nogil: */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__126, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7005, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__121, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":7006 + /* "PyCafe.pyx":7213 * if not encoding: * print('no encoding done') * valSetS = valSet # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setString(handle, valSetS) */ - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_v_valSet); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7006, __pyx_L1_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_v_valSet); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7213, __pyx_L1_error) __pyx_v_valSetS = ((std::string)__pyx_t_31); - /* "PyCafe.pyx":7004 + /* "PyCafe.pyx":7211 * print('encode utf_16 error', ex) * pass * if not encoding: # <<<<<<<<<<<<<< @@ -117380,7 +121058,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":7007 + /* "PyCafe.pyx":7214 * print('no encoding done') * valSetS = valSet * with nogil: # <<<<<<<<<<<<<< @@ -117395,7 +121073,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":7008 + /* "PyCafe.pyx":7215 * valSetS = valSet * with nogil: * status = self._c_cafe.setString(handle, valSetS) # <<<<<<<<<<<<<< @@ -117405,7 +121083,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setString(__pyx_v_handle, __pyx_v_valSetS); } - /* "PyCafe.pyx":7007 + /* "PyCafe.pyx":7214 * print('no encoding done') * valSetS = valSet * with nogil: # <<<<<<<<<<<<<< @@ -117424,7 +121102,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":6986 + /* "PyCafe.pyx":7193 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, (bytes, bytearray)): # <<<<<<<<<<<<<< @@ -117434,7 +121112,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":7009 + /* "PyCafe.pyx":7216 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, (unicode)): # <<<<<<<<<<<<<< @@ -117445,14 +121123,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7011 + /* "PyCafe.pyx":7218 * elif isinstance(valSet, (unicode)): * #print("unicode") * valSetS = valSet.encode('utf-8') # <<<<<<<<<<<<<< * with nogil: * status = self._c_cafe.setString(handle, valSetS) */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7011, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_valSet, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -117464,16 +121142,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_kp_u_utf_8_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_utf_8_2); + __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_kp_u_utf_8) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_utf_8); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7011, __pyx_L1_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7011, __pyx_L1_error) + __pyx_t_31 = __pyx_convert_string_from_py_std__in_string(__pyx_t_10); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7218, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_valSetS = __pyx_t_31; - /* "PyCafe.pyx":7012 + /* "PyCafe.pyx":7219 * #print("unicode") * valSetS = valSet.encode('utf-8') * with nogil: # <<<<<<<<<<<<<< @@ -117488,7 +121166,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe #endif /*try:*/ { - /* "PyCafe.pyx":7013 + /* "PyCafe.pyx":7220 * valSetS = valSet.encode('utf-8') * with nogil: * status = self._c_cafe.setString(handle, valSetS) # <<<<<<<<<<<<<< @@ -117498,7 +121176,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_v_status = __pyx_v_self->_c_cafe->setString(__pyx_v_handle, __pyx_v_valSetS); } - /* "PyCafe.pyx":7012 + /* "PyCafe.pyx":7219 * #print("unicode") * valSetS = valSet.encode('utf-8') * with nogil: # <<<<<<<<<<<<<< @@ -117517,7 +121195,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } } - /* "PyCafe.pyx":7009 + /* "PyCafe.pyx":7216 * with nogil: * status = self._c_cafe.setString(handle, valSetS) * elif isinstance(valSet, (unicode)): # <<<<<<<<<<<<<< @@ -117527,7 +121205,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L33; } - /* "PyCafe.pyx":7015 + /* "PyCafe.pyx":7222 * status = self._c_cafe.setString(handle, valSetS) * else: * print("PyCafe def set WARNING: DATA TYPE NOT SUPPORTED") # <<<<<<<<<<<<<< @@ -117535,22 +121213,22 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe * or not) should be of of type , or ") */ /*else*/ { - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__127, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7015, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__122, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":7016 + /* "PyCafe.pyx":7223 * 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 of type , or ") * type(valSet) */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__128, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7016, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__123, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":7018 + /* "PyCafe.pyx":7225 * print("Input data (whether within a 'list','array.array','cython.view.memoryview','memoryview' \n\ * or not) should be of of type , or ") * type(valSet) # <<<<<<<<<<<<<< @@ -117561,7 +121239,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L33:; - /* "PyCafe.pyx":7020 + /* "PyCafe.pyx":7227 * type(valSet) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -117571,7 +121249,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7021 + /* "PyCafe.pyx":7228 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -117581,7 +121259,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7022 + /* "PyCafe.pyx":7229 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -117591,7 +121269,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7023 + /* "PyCafe.pyx":7230 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -117600,7 +121278,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":7022 + /* "PyCafe.pyx":7229 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * if handle == 0: # <<<<<<<<<<<<<< @@ -117610,7 +121288,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe goto __pyx_L198; } - /* "PyCafe.pyx":7025 + /* "PyCafe.pyx":7232 * self._c_cafe.printStatusMessage(status) * else: * self._c_cafe.printStatus(handle, status) # <<<<<<<<<<<<<< @@ -117622,7 +121300,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe } __pyx_L198:; - /* "PyCafe.pyx":7021 + /* "PyCafe.pyx":7228 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -117631,7 +121309,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":7026 + /* "PyCafe.pyx":7233 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -117641,60 +121319,60 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe __pyx_t_3 = (__pyx_v_self->_enable_exceptions != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7027 + /* "PyCafe.pyx":7234 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=handle, _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_10 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7027, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7027, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7027, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7027, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7234, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7234, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_unsigned_int(__pyx_v_handle); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 7027, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_handle, __pyx_t_6) < 0) __PYX_ERR(3, 7234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7027, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyStr_FromString(__pyx_v_self->_c_cafe->getPVFromHandle(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 7027, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_pv_name, __pyx_t_6) < 0) __PYX_ERR(3, 7234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7028 + /* "PyCafe.pyx":7235 * if self._enable_exceptions: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=handle, _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7028, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 7027, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_code, __pyx_t_6) < 0) __PYX_ERR(3, 7234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7028, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 7027, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_text, __pyx_t_6) < 0) __PYX_ERR(3, 7234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7028, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(__pyx_v_status)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 7027, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_info, __pyx_t_6) < 0) __PYX_ERR(3, 7234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7027 + /* "PyCafe.pyx":7234 * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=handle, _pv_name=self._c_cafe.getPVFromHandle(handle), # <<<<<<<<<<<<<< * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7027, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7029 + /* "PyCafe.pyx":7236 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, _handle=handle, _pv_name=self._c_cafe.getPVFromHandle(handle), * _error_code=status, _error_text=self.cs.code(status), _error_info=self.cs.info(status)) * raise _cafeException # <<<<<<<<<<<<<< @@ -117702,9 +121380,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe * return status */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7029, __pyx_L1_error) + __PYX_ERR(3, 7236, __pyx_L1_error) - /* "PyCafe.pyx":7026 + /* "PyCafe.pyx":7233 * else: * self._c_cafe.printStatus(handle, status) * if self._enable_exceptions: # <<<<<<<<<<<<<< @@ -117713,7 +121391,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":7020 + /* "PyCafe.pyx":7227 * type(valSet) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -117722,7 +121400,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe */ } - /* "PyCafe.pyx":7031 + /* "PyCafe.pyx":7238 * raise _cafeException * * return status # <<<<<<<<<<<<<< @@ -117730,13 +121408,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe * # END def set(self, handlePV, valSet): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7031, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":6629 + /* "PyCafe.pyx":6836 * ############################################################################## * * def set(self, handlePV, valSet): # <<<<<<<<<<<<<< @@ -117790,7 +121468,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_396set(struct __pyx_obj_6PyCafe_CyCafe return __pyx_r; } -/* "PyCafe.pyx":7038 +/* "PyCafe.pyx":7245 * ############################################################################ * * def setScalarList(self, list handleList, list valList): # <<<<<<<<<<<<<< @@ -117829,11 +121507,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_399setScalarList(PyObject *__pyx_v_sel case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_valList)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setScalarList", 1, 2, 2, 1); __PYX_ERR(3, 7038, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setScalarList", 1, 2, 2, 1); __PYX_ERR(3, 7245, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setScalarList") < 0)) __PYX_ERR(3, 7038, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setScalarList") < 0)) __PYX_ERR(3, 7245, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -117846,14 +121524,14 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_399setScalarList(PyObject *__pyx_v_sel } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setScalarList", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7038, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setScalarList", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7245, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setScalarList", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handleList), (&PyList_Type), 1, "handleList", 1))) __PYX_ERR(3, 7038, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_valList), (&PyList_Type), 1, "valList", 1))) __PYX_ERR(3, 7038, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handleList), (&PyList_Type), 1, "handleList", 1))) __PYX_ERR(3, 7245, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_valList), (&PyList_Type), 1, "valList", 1))) __PYX_ERR(3, 7245, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_398setScalarList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handleList, __pyx_v_valList); /* function exit code */ @@ -117896,7 +121574,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __Pyx_RefNannySetupContext("setScalarList", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":7039 + /* "PyCafe.pyx":7246 * * def setScalarList(self, list handleList, list valList): * cdef str _METHOD = "setScalarList" # <<<<<<<<<<<<<< @@ -117906,7 +121584,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __Pyx_INCREF(__pyx_n_u_setScalarList); __pyx_v__METHOD = __pyx_n_u_setScalarList; - /* "PyCafe.pyx":7042 + /* "PyCafe.pyx":7249 * * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -117915,29 +121593,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7042, __pyx_L1_error) + __PYX_ERR(3, 7249, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7042, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyUnicode_Check(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7043 + /* "PyCafe.pyx":7250 * * 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\ */ - __pyx_t_1 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, __pyx_v_handleList, 0, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7043, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, __pyx_v_handleList, 0, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(3, 7043, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(3, 7250, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_handleList, ((PyObject*)__pyx_t_1)); __pyx_t_1 = 0; - /* "PyCafe.pyx":7042 + /* "PyCafe.pyx":7249 * * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -117947,7 +121625,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC goto __pyx_L3; } - /* "PyCafe.pyx":7044 + /* "PyCafe.pyx":7251 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -117956,9 +121634,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7044, __pyx_L1_error) + __PYX_ERR(3, 7251, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7044, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyInt_Check(__pyx_t_1); __pyx_t_4 = (__pyx_t_2 != 0); @@ -117975,20 +121653,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7045 + /* "PyCafe.pyx":7252 * 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 of type \ * if handles or if PVs") */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__129, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7045, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__124, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(3, 7045, __pyx_L1_error) + __PYX_ERR(3, 7252, __pyx_L1_error) - /* "PyCafe.pyx":7044 + /* "PyCafe.pyx":7251 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -117998,7 +121676,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC } __pyx_L3:; - /* "PyCafe.pyx":7049 + /* "PyCafe.pyx":7256 * if handles or if PVs") * * if len(handleList) != len(valList): # <<<<<<<<<<<<<< @@ -118007,18 +121685,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7049, __pyx_L1_error) + __PYX_ERR(3, 7256, __pyx_L1_error) } - __pyx_t_5 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7049, __pyx_L1_error) + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7256, __pyx_L1_error) if (unlikely(__pyx_v_valList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7049, __pyx_L1_error) + __PYX_ERR(3, 7256, __pyx_L1_error) } - __pyx_t_6 = PyList_GET_SIZE(__pyx_v_valList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7049, __pyx_L1_error) + __pyx_t_6 = PyList_GET_SIZE(__pyx_v_valList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7256, __pyx_L1_error) __pyx_t_2 = ((__pyx_t_5 != __pyx_t_6) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7051 + /* "PyCafe.pyx":7258 * if len(handleList) != len(valList): * raise Exception("EXCEPTION RAISED IN PyCafe def setScalarList. \ * Length of handle list ", len(handleList), " does not match \ # <<<<<<<<<<<<<< @@ -118027,13 +121705,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7051, __pyx_L1_error) + __PYX_ERR(3, 7258, __pyx_L1_error) } - __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7051, __pyx_L1_error) - __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7051, __pyx_L1_error) + __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7258, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - /* "PyCafe.pyx":7052 + /* "PyCafe.pyx":7259 * raise Exception("EXCEPTION RAISED IN PyCafe def setScalarList. \ * Length of handle list ", len(handleList), " does not match \ * the length of data list ", len(valList)) # <<<<<<<<<<<<<< @@ -118042,20 +121720,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_valList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7052, __pyx_L1_error) + __PYX_ERR(3, 7259, __pyx_L1_error) } - __pyx_t_6 = PyList_GET_SIZE(__pyx_v_valList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7052, __pyx_L1_error) - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7052, __pyx_L1_error) + __pyx_t_6 = PyList_GET_SIZE(__pyx_v_valList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7259, __pyx_L1_error) + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7259, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "PyCafe.pyx":7050 + /* "PyCafe.pyx":7257 * * 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)) */ - __pyx_t_8 = PyTuple_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7050, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_2); __Pyx_GIVEREF(__pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_2); @@ -118069,14 +121747,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_7); __pyx_t_1 = 0; __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7050, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(3, 7050, __pyx_L1_error) + __PYX_ERR(3, 7257, __pyx_L1_error) - /* "PyCafe.pyx":7049 + /* "PyCafe.pyx":7256 * if handles or if PVs") * * if len(handleList) != len(valList): # <<<<<<<<<<<<<< @@ -118085,19 +121763,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":7054 + /* "PyCafe.pyx":7261 * the length of data list ", len(valList)) * * nelemPrevious = [] # <<<<<<<<<<<<<< * * # Better with PVDataHolder */ - __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7054, __pyx_L1_error) + __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_v_nelemPrevious = ((PyObject*)__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":7057 + /* "PyCafe.pyx":7264 * * # Better with PVDataHolder * cdef unsigned int nelemTotal = 0 # <<<<<<<<<<<<<< @@ -118106,7 +121784,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ __pyx_v_nelemTotal = 0; - /* "PyCafe.pyx":7058 + /* "PyCafe.pyx":7265 * # Better with PVDataHolder * cdef unsigned int nelemTotal = 0 * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -118115,14 +121793,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7058, __pyx_L1_error) + __PYX_ERR(3, 7265, __pyx_L1_error) } - __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7058, __pyx_L1_error) + __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7265, __pyx_L1_error) __pyx_t_5 = __pyx_t_6; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_5; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":7060 + /* "PyCafe.pyx":7267 * for i in range(0, len(handleList)): * # nelemTotal+=self.hh.getNelemNative(handleList[i]) * nelemPrevious.append(self.hh.getNelemClient(handleList[i])) # <<<<<<<<<<<<<< @@ -118131,19 +121809,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7060, __pyx_L1_error) + __PYX_ERR(3, 7267, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7060, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_7); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7060, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_7); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7267, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNelemClient(__pyx_t_10)); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7060, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.getNelemClient(__pyx_t_10)); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_nelemPrevious, __pyx_t_7); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(3, 7060, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_nelemPrevious, __pyx_t_7); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(3, 7267, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } - /* "PyCafe.pyx":7066 + /* "PyCafe.pyx":7273 * # do this to avoid compiler warning messages * cdef vector[unsigned int] v * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -118152,14 +121830,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7066, __pyx_L1_error) + __PYX_ERR(3, 7273, __pyx_L1_error) } - __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7066, __pyx_L1_error) + __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7273, __pyx_L1_error) __pyx_t_5 = __pyx_t_6; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_5; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":7067 + /* "PyCafe.pyx":7274 * cdef vector[unsigned int] v * for i in range(0, len(handleList)): * v.push_back(handleList[i]) # <<<<<<<<<<<<<< @@ -118168,21 +121846,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7067, __pyx_L1_error) + __PYX_ERR(3, 7274, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7067, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_7); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7067, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_7); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7274, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; try { __pyx_v_v.push_back(__pyx_t_10); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7067, __pyx_L1_error) + __PYX_ERR(3, 7274, __pyx_L1_error) } } - /* "PyCafe.pyx":7071 + /* "PyCafe.pyx":7278 * # Create temporary group from handleList * # Does group exist? * cdef PVDataHolder * pvd = self._c_cafe.getPVData(v) # <<<<<<<<<<<<<< @@ -118191,7 +121869,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ __pyx_v_pvd = __pyx_v_self->_c_cafe->getPVData(__pyx_v_v); - /* "PyCafe.pyx":7076 + /* "PyCafe.pyx":7283 * # len(handleList) * sizeof(PVDataHolder) + nelemTotal*size_cdu) * * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -118203,7 +121881,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_13; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafe.pyx":7079 + /* "PyCafe.pyx":7286 * # pvd[i].val =malloc(sizeof(CAFE_DATATYPE_UNION)) * #pvd[i]= PVDataHolder(1); * pvd[i].setNelem(1) # <<<<<<<<<<<<<< @@ -118213,7 +121891,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC (void)((__pyx_v_pvd[__pyx_v_i]).setNelem(1)); } - /* "PyCafe.pyx":7083 + /* "PyCafe.pyx":7290 * #cdef unsigned short valType = CAFE_STRING * * for i in range(0, v.size()): #len(handleList)): # <<<<<<<<<<<<<< @@ -118225,7 +121903,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_13; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "PyCafe.pyx":7084 + /* "PyCafe.pyx":7291 * * for i in range(0, v.size()): #len(handleList)): * if isinstance(valList[i], (str)): # <<<<<<<<<<<<<< @@ -118234,16 +121912,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_valList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7084, __pyx_L1_error) + __PYX_ERR(3, 7291, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7084, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_2 = PyUnicode_Check(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7085 + /* "PyCafe.pyx":7292 * for i in range(0, v.size()): #len(handleList)): * if isinstance(valList[i], (str)): * pvd[i].setString(valList[i]) # <<<<<<<<<<<<<< @@ -118252,15 +121930,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_valList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7085, __pyx_L1_error) + __PYX_ERR(3, 7292, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7085, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_14 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7085, __pyx_L1_error) + __pyx_t_14 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7292, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; (void)((__pyx_v_pvd[__pyx_v_i]).setString(__pyx_t_14)); - /* "PyCafe.pyx":7084 + /* "PyCafe.pyx":7291 * * for i in range(0, v.size()): #len(handleList)): * if isinstance(valList[i], (str)): # <<<<<<<<<<<<<< @@ -118270,7 +121948,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC goto __pyx_L15; } - /* "PyCafe.pyx":7086 + /* "PyCafe.pyx":7293 * if isinstance(valList[i], (str)): * pvd[i].setString(valList[i]) * elif isinstance(valList[i], (float)): # <<<<<<<<<<<<<< @@ -118279,16 +121957,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_valList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7086, __pyx_L1_error) + __PYX_ERR(3, 7293, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7086, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_3 = PyFloat_Check(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7087 + /* "PyCafe.pyx":7294 * pvd[i].setString(valList[i]) * elif isinstance(valList[i], (float)): * pvd[i].setDouble(valList[i]) # <<<<<<<<<<<<<< @@ -118297,15 +121975,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_valList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7087, __pyx_L1_error) + __PYX_ERR(3, 7294, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7087, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_15 = __pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_15 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7087, __pyx_L1_error) + __pyx_t_15 = __pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_15 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7294, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; (void)((__pyx_v_pvd[__pyx_v_i]).setDouble(__pyx_t_15)); - /* "PyCafe.pyx":7086 + /* "PyCafe.pyx":7293 * if isinstance(valList[i], (str)): * pvd[i].setString(valList[i]) * elif isinstance(valList[i], (float)): # <<<<<<<<<<<<<< @@ -118315,7 +121993,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC goto __pyx_L15; } - /* "PyCafe.pyx":7088 + /* "PyCafe.pyx":7295 * elif isinstance(valList[i], (float)): * pvd[i].setDouble(valList[i]) * elif isinstance(valList[i], (long, int)): # <<<<<<<<<<<<<< @@ -118324,9 +122002,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_valList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7088, __pyx_L1_error) + __PYX_ERR(3, 7295, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7088, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_3 = PyLong_Check(__pyx_t_7); __pyx_t_4 = (__pyx_t_3 != 0); @@ -118343,7 +122021,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7089 + /* "PyCafe.pyx":7296 * pvd[i].setDouble(valList[i]) * elif isinstance(valList[i], (long, int)): * pvd[i].setInt(valList[i]) # <<<<<<<<<<<<<< @@ -118352,15 +122030,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_valList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7089, __pyx_L1_error) + __PYX_ERR(3, 7296, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7089, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_valList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7089, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7296, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; (void)((__pyx_v_pvd[__pyx_v_i]).setInt(__pyx_t_16)); - /* "PyCafe.pyx":7088 + /* "PyCafe.pyx":7295 * elif isinstance(valList[i], (float)): * pvd[i].setDouble(valList[i]) * elif isinstance(valList[i], (long, int)): # <<<<<<<<<<<<<< @@ -118370,7 +122048,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC goto __pyx_L15; } - /* "PyCafe.pyx":7091 + /* "PyCafe.pyx":7298 * pvd[i].setInt(valList[i]) * else: * print("This line in PyCafe def setScalarList should never appear!") # <<<<<<<<<<<<<< @@ -118378,14 +122056,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC * cdef int status = ICAFE_NORMAL */ /*else*/ { - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__130, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7091, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__125, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __pyx_L15:; } - /* "PyCafe.pyx":7093 + /* "PyCafe.pyx":7300 * print("This line in PyCafe def setScalarList should never appear!") * * cdef int status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -118394,7 +122072,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":7094 + /* "PyCafe.pyx":7301 * * cdef int status = ICAFE_NORMAL * with nogil: # <<<<<<<<<<<<<< @@ -118409,7 +122087,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC #endif /*try:*/ { - /* "PyCafe.pyx":7095 + /* "PyCafe.pyx":7302 * cdef int status = ICAFE_NORMAL * with nogil: * status = self._c_cafe.setPVArray(v, pvd) # <<<<<<<<<<<<<< @@ -118419,7 +122097,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __pyx_v_status = __pyx_v_self->_c_cafe->setPVArray(__pyx_v_v, __pyx_v_pvd); } - /* "PyCafe.pyx":7094 + /* "PyCafe.pyx":7301 * * cdef int status = ICAFE_NORMAL * with nogil: # <<<<<<<<<<<<<< @@ -118438,7 +122116,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":7097 + /* "PyCafe.pyx":7304 * status = self._c_cafe.setPVArray(v, pvd) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -118447,30 +122125,30 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7097, __pyx_L1_error) + __PYX_ERR(3, 7304, __pyx_L1_error) } - __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7097, __pyx_L1_error) + __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7304, __pyx_L1_error) __pyx_t_5 = __pyx_t_6; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_5; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":7098 + /* "PyCafe.pyx":7305 * * for i in range(0, len(handleList)): * if (nelemPrevious[i] != 1): # <<<<<<<<<<<<<< * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) */ - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_nelemPrevious, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7098, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_nelemPrevious, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7098, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 7098, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(3, 7305, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (__pyx_t_3) { - /* "PyCafe.pyx":7100 + /* "PyCafe.pyx":7307 * if (nelemPrevious[i] != 1): * self._c_cafe.setNelemToPrevious( * handleList[i], nelemPrevious[i]) # <<<<<<<<<<<<<< @@ -118479,18 +122157,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7100, __pyx_L1_error) + __PYX_ERR(3, 7307, __pyx_L1_error) } - __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7100, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_8); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7100, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_8); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7307, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_nelemPrevious, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7100, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_nelemPrevious, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_8); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7100, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_8); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7307, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":7099 + /* "PyCafe.pyx":7306 * for i in range(0, len(handleList)): * if (nelemPrevious[i] != 1): * self._c_cafe.setNelemToPrevious( # <<<<<<<<<<<<<< @@ -118499,7 +122177,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ (void)(__pyx_v_self->_c_cafe->setNelemToPrevious(__pyx_t_10, __pyx_t_17)); - /* "PyCafe.pyx":7098 + /* "PyCafe.pyx":7305 * * for i in range(0, len(handleList)): * if (nelemPrevious[i] != 1): # <<<<<<<<<<<<<< @@ -118509,19 +122187,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC } } - /* "PyCafe.pyx":7103 + /* "PyCafe.pyx":7310 * * # return status for individual channels * statusList = [] # <<<<<<<<<<<<<< * * if status != ICAFE_NORMAL: */ - __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7103, __pyx_L1_error) + __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_v_statusList = ((PyObject*)__pyx_t_8); __pyx_t_8 = 0; - /* "PyCafe.pyx":7105 + /* "PyCafe.pyx":7312 * statusList = [] * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -118531,7 +122209,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __pyx_t_3 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7106 + /* "PyCafe.pyx":7313 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -118541,7 +122219,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __pyx_t_3 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7107 + /* "PyCafe.pyx":7314 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -118550,7 +122228,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":7106 + /* "PyCafe.pyx":7313 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -118559,7 +122237,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":7105 + /* "PyCafe.pyx":7312 * statusList = [] * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -118568,7 +122246,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":7109 + /* "PyCafe.pyx":7316 * self._c_cafe.printStatusMessage(status) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< @@ -118577,14 +122255,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7109, __pyx_L1_error) + __PYX_ERR(3, 7316, __pyx_L1_error) } - __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7109, __pyx_L1_error) + __pyx_t_6 = PyList_GET_SIZE(__pyx_v_handleList); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7316, __pyx_L1_error) __pyx_t_5 = __pyx_t_6; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_5; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":7110 + /* "PyCafe.pyx":7317 * * for i in range(0, len(handleList)): * if (pvd[i].getStatus() != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -118594,7 +122272,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __pyx_t_3 = (((__pyx_v_pvd[__pyx_v_i]).getStatus() != ICAFE_NORMAL) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7111 + /* "PyCafe.pyx":7318 * for i in range(0, len(handleList)): * if (pvd[i].getStatus() != ICAFE_NORMAL): * print("Handle=", handleList[i], "PV=", # <<<<<<<<<<<<<< @@ -118603,12 +122281,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7111, __pyx_L1_error) + __PYX_ERR(3, 7318, __pyx_L1_error) } - __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7111, __pyx_L1_error) + __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 7318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "PyCafe.pyx":7112 + /* "PyCafe.pyx":7319 * if (pvd[i].getStatus() != ICAFE_NORMAL): * print("Handle=", handleList[i], "PV=", * self.hh.getPVFromHandle(handleList[i])) # <<<<<<<<<<<<<< @@ -118617,23 +122295,23 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ if (unlikely(__pyx_v_handleList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7112, __pyx_L1_error) + __PYX_ERR(3, 7319, __pyx_L1_error) } - __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7112, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_handleList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7112, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_unsigned_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7319, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_17)); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7112, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_17)); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "PyCafe.pyx":7111 + /* "PyCafe.pyx":7318 * 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()) */ - __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7111, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_kp_u_Handle); __Pyx_GIVEREF(__pyx_kp_u_Handle); @@ -118647,21 +122325,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_7); __pyx_t_8 = 0; __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7111, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":7113 + /* "PyCafe.pyx":7320 * 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("") */ - __pyx_t_7 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7113, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7113, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_kp_u_with_error_status); __Pyx_GIVEREF(__pyx_kp_u_with_error_status); @@ -118669,12 +122347,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7113, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":7114 + /* "PyCafe.pyx":7321 * self.hh.getPVFromHandle(handleList[i])) * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) # <<<<<<<<<<<<<< @@ -118683,18 +122361,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ __pyx_v_self->_c_cafe->printStatusMessage((__pyx_v_pvd[__pyx_v_i]).getStatus()); - /* "PyCafe.pyx":7115 + /* "PyCafe.pyx":7322 * print("with error status=", pvd[i].getStatus()) * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * print("") # <<<<<<<<<<<<<< * statusList.append(pvd[i].getStatus()) * */ - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7115, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "PyCafe.pyx":7110 + /* "PyCafe.pyx":7317 * * for i in range(0, len(handleList)): * if (pvd[i].getStatus() != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -118703,20 +122381,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC */ } - /* "PyCafe.pyx":7116 + /* "PyCafe.pyx":7323 * self._c_cafe.printStatusMessage(pvd[i].getStatus()) * print("") * statusList.append(pvd[i].getStatus()) # <<<<<<<<<<<<<< * * # free(pvd) */ - __pyx_t_7 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7116, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_7); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(3, 7116, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_7); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(3, 7323, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } - /* "PyCafe.pyx":7120 + /* "PyCafe.pyx":7327 * # free(pvd) * * return status, statusList # <<<<<<<<<<<<<< @@ -118724,9 +122402,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7120, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 7327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7120, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 7327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_7); @@ -118738,7 +122416,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC __pyx_t_1 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7038 + /* "PyCafe.pyx":7245 * ############################################################################ * * def setScalarList(self, list handleList, list valList): # <<<<<<<<<<<<<< @@ -118765,7 +122443,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_398setScalarList(struct __pyx_obj_6PyC return __pyx_r; } -/* "PyCafe.pyx":7125 +/* "PyCafe.pyx":7332 * * ################################################################################## * def setCompoundList(self, handleList, list vectorList): # <<<<<<<<<<<<<< @@ -118804,11 +122482,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_401setCompoundList(PyObject *__pyx_v_s case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vectorList)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setCompoundList", 1, 2, 2, 1); __PYX_ERR(3, 7125, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setCompoundList", 1, 2, 2, 1); __PYX_ERR(3, 7332, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCompoundList") < 0)) __PYX_ERR(3, 7125, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCompoundList") < 0)) __PYX_ERR(3, 7332, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -118821,13 +122499,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_401setCompoundList(PyObject *__pyx_v_s } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setCompoundList", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7125, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setCompoundList", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7332, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setCompoundList", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vectorList), (&PyList_Type), 1, "vectorList", 1))) __PYX_ERR(3, 7125, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vectorList), (&PyList_Type), 1, "vectorList", 1))) __PYX_ERR(3, 7332, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_400setCompoundList(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handleList, __pyx_v_vectorList); /* function exit code */ @@ -118872,7 +122550,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __Pyx_RefNannySetupContext("setCompoundList", 0); __Pyx_INCREF(__pyx_v_handleList); - /* "PyCafe.pyx":7127 + /* "PyCafe.pyx":7334 * def setCompoundList(self, handleList, list vectorList): * * cdef str _METHOD = "setCompoundList(handleList, list vectorList)" # <<<<<<<<<<<<<< @@ -118882,7 +122560,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __Pyx_INCREF(__pyx_kp_u_setCompoundList_handleList_list); __pyx_v__METHOD = __pyx_kp_u_setCompoundList_handleList_list; - /* "PyCafe.pyx":7129 + /* "PyCafe.pyx":7336 * cdef str _METHOD = "setCompoundList(handleList, list vectorList)" * * if isinstance(handleList, (str)): # <<<<<<<<<<<<<< @@ -118893,14 +122571,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7130 + /* "PyCafe.pyx":7337 * * if isinstance(handleList, (str)): * handleList = self.getHandlesFromWithinGroup(handleList) # <<<<<<<<<<<<<< * else: * if not isinstance(handleList, (list)): */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7130, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getHandlesFromWithinGroup); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -118914,13 +122592,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_handleList) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_handleList); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7130, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":7129 + /* "PyCafe.pyx":7336 * cdef str _METHOD = "setCompoundList(handleList, list vectorList)" * * if isinstance(handleList, (str)): # <<<<<<<<<<<<<< @@ -118930,7 +122608,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P goto __pyx_L3; } - /* "PyCafe.pyx":7132 + /* "PyCafe.pyx":7339 * handleList = self.getHandlesFromWithinGroup(handleList) * else: * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -118942,20 +122620,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7133 + /* "PyCafe.pyx":7340 * else: * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def setCompoundList. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__131, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7133, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__126, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 7133, __pyx_L1_error) + __PYX_ERR(3, 7340, __pyx_L1_error) - /* "PyCafe.pyx":7132 + /* "PyCafe.pyx":7339 * handleList = self.getHandlesFromWithinGroup(handleList) * else: * if not isinstance(handleList, (list)): # <<<<<<<<<<<<<< @@ -118964,34 +122642,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7136 + /* "PyCafe.pyx":7343 * 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)): */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7136, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = PyUnicode_Check(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7137 + /* "PyCafe.pyx":7344 * * 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\ */ - if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 7137, __pyx_L1_error) - __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7137, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_handleList))||((__pyx_v_handleList) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_handleList)->tp_name), 0))) __PYX_ERR(3, 7344, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandleList(__pyx_v_self, ((PyObject*)__pyx_v_handleList), 0, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_handleList, __pyx_t_3); __pyx_t_3 = 0; - /* "PyCafe.pyx":7136 + /* "PyCafe.pyx":7343 * First input argument, should be of handles or PVs") * * if isinstance(handleList[0], (str)): # <<<<<<<<<<<<<< @@ -119001,14 +122679,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P goto __pyx_L5; } - /* "PyCafe.pyx":7138 + /* "PyCafe.pyx":7345 * 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 of type if handles or if PVs") */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7138, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_handleList, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = PyInt_Check(__pyx_t_3); __pyx_t_6 = (__pyx_t_1 != 0); @@ -119025,20 +122703,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7139 + /* "PyCafe.pyx":7346 * 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 of type if handles or if PVs") * */ - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__132, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7139, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__127, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(3, 7139, __pyx_L1_error) + __PYX_ERR(3, 7346, __pyx_L1_error) - /* "PyCafe.pyx":7138 + /* "PyCafe.pyx":7345 * if isinstance(handleList[0], (str)): * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): # <<<<<<<<<<<<<< @@ -119048,48 +122726,48 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P } __pyx_L5:; - /* "PyCafe.pyx":7142 + /* "PyCafe.pyx":7349 * First input argument, should be a 'list' of of type 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)) */ - __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7142, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7349, __pyx_L1_error) if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7142, __pyx_L1_error) + __PYX_ERR(3, 7349, __pyx_L1_error) } - __pyx_t_8 = PyList_GET_SIZE(__pyx_v_vectorList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7142, __pyx_L1_error) + __pyx_t_8 = PyList_GET_SIZE(__pyx_v_vectorList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7349, __pyx_L1_error) __pyx_t_1 = ((__pyx_t_7 != __pyx_t_8) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7144 + /* "PyCafe.pyx":7351 * 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 */ - __pyx_t_8 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7144, __pyx_L1_error) - __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7144, __pyx_L1_error) + __pyx_t_8 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7351, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7144, __pyx_L1_error) + __PYX_ERR(3, 7351, __pyx_L1_error) } - __pyx_t_8 = PyList_GET_SIZE(__pyx_v_vectorList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7144, __pyx_L1_error) - __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7144, __pyx_L1_error) + __pyx_t_8 = PyList_GET_SIZE(__pyx_v_vectorList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7351, __pyx_L1_error) + __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "PyCafe.pyx":7143 + /* "PyCafe.pyx":7350 * * 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)) * */ - __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7143, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_5); __Pyx_GIVEREF(__pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_5); @@ -119103,14 +122781,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7143, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 7143, __pyx_L1_error) + __PYX_ERR(3, 7350, __pyx_L1_error) - /* "PyCafe.pyx":7142 + /* "PyCafe.pyx":7349 * First input argument, should be a 'list' of of type if handles or if PVs") * * if len(handleList) != len(vectorList): # <<<<<<<<<<<<<< @@ -119121,38 +122799,38 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P } __pyx_L3:; - /* "PyCafe.pyx":7150 + /* "PyCafe.pyx":7357 * cdef int i * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * v.push_back(handleList[i]) * */ - __pyx_t_8 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7150, __pyx_L1_error) + __pyx_t_8 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7357, __pyx_L1_error) __pyx_t_7 = __pyx_t_8; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_7; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":7151 + /* "PyCafe.pyx":7358 * * for i in range(0, len(handleList)): * v.push_back(handleList[i]) # <<<<<<<<<<<<<< * * # Create temporary group from handleList */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7151, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7151, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7358, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_v.push_back(__pyx_t_10); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7151, __pyx_L1_error) + __PYX_ERR(3, 7358, __pyx_L1_error) } } - /* "PyCafe.pyx":7155 + /* "PyCafe.pyx":7362 * # Create temporary group from handleList * # Does group exist? * cdef PVDataHolder * pvdata = self._c_cafe.getPVData(v) # <<<<<<<<<<<<<< @@ -119161,7 +122839,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ __pyx_v_pvdata = __pyx_v_self->_c_cafe->getPVData(__pyx_v_v); - /* "PyCafe.pyx":7157 + /* "PyCafe.pyx":7364 * cdef PVDataHolder * pvdata = self._c_cafe.getPVData(v) * * for i in range(0, len(vectorList)): # <<<<<<<<<<<<<< @@ -119170,14 +122848,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7157, __pyx_L1_error) + __PYX_ERR(3, 7364, __pyx_L1_error) } - __pyx_t_8 = PyList_GET_SIZE(__pyx_v_vectorList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7157, __pyx_L1_error) + __pyx_t_8 = PyList_GET_SIZE(__pyx_v_vectorList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7364, __pyx_L1_error) __pyx_t_7 = __pyx_t_8; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_7; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":7160 + /* "PyCafe.pyx":7367 * * # if not list * if isinstance(vectorList[i], (str)): # <<<<<<<<<<<<<< @@ -119186,16 +122864,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7160, __pyx_L1_error) + __PYX_ERR(3, 7367, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7160, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7161 + /* "PyCafe.pyx":7368 * # if not list * if isinstance(vectorList[i], (str)): * pvdata[i].setString(vectorList[i]) # <<<<<<<<<<<<<< @@ -119204,15 +122882,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7161, __pyx_L1_error) + __PYX_ERR(3, 7368, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7161, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7368, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_11 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7161, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7368, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setString(__pyx_t_11)); - /* "PyCafe.pyx":7160 + /* "PyCafe.pyx":7367 * * # if not list * if isinstance(vectorList[i], (str)): # <<<<<<<<<<<<<< @@ -119222,7 +122900,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P goto __pyx_L13; } - /* "PyCafe.pyx":7163 + /* "PyCafe.pyx":7370 * pvdata[i].setString(vectorList[i]) * * elif isinstance(vectorList[i], (float)): # <<<<<<<<<<<<<< @@ -119231,16 +122909,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7163, __pyx_L1_error) + __PYX_ERR(3, 7370, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7163, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyFloat_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7164 + /* "PyCafe.pyx":7371 * * elif isinstance(vectorList[i], (float)): * pvdata[i].setDouble(vectorList[i]) # <<<<<<<<<<<<<< @@ -119249,15 +122927,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7164, __pyx_L1_error) + __PYX_ERR(3, 7371, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7164, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7164, __pyx_L1_error) + __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7371, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setDouble(__pyx_t_12)); - /* "PyCafe.pyx":7163 + /* "PyCafe.pyx":7370 * pvdata[i].setString(vectorList[i]) * * elif isinstance(vectorList[i], (float)): # <<<<<<<<<<<<<< @@ -119267,7 +122945,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P goto __pyx_L13; } - /* "PyCafe.pyx":7166 + /* "PyCafe.pyx":7373 * pvdata[i].setDouble(vectorList[i]) * * elif isinstance(vectorList[i], (long, int)): # <<<<<<<<<<<<<< @@ -119276,9 +122954,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7166, __pyx_L1_error) + __PYX_ERR(3, 7373, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7166, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyLong_Check(__pyx_t_4); __pyx_t_6 = (__pyx_t_2 != 0); @@ -119295,7 +122973,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7167 + /* "PyCafe.pyx":7374 * * elif isinstance(vectorList[i], (long, int)): * pvdata[i].setInt(vectorList[i]) # <<<<<<<<<<<<<< @@ -119304,15 +122982,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7167, __pyx_L1_error) + __PYX_ERR(3, 7374, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7167, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7167, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7374, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setInt(__pyx_t_13)); - /* "PyCafe.pyx":7166 + /* "PyCafe.pyx":7373 * pvdata[i].setDouble(vectorList[i]) * * elif isinstance(vectorList[i], (long, int)): # <<<<<<<<<<<<<< @@ -119322,7 +123000,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P goto __pyx_L13; } - /* "PyCafe.pyx":7169 + /* "PyCafe.pyx":7376 * pvdata[i].setInt(vectorList[i]) * * elif isinstance(vectorList[i], (list)): # <<<<<<<<<<<<<< @@ -119331,16 +123009,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7169, __pyx_L1_error) + __PYX_ERR(3, 7376, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7169, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyList_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7172 + /* "PyCafe.pyx":7379 * * # if list * valType = CAFE_INVALID_DATATYPE # <<<<<<<<<<<<<< @@ -119349,7 +123027,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ __pyx_v_valType = CAFE_INVALID_DATATYPE; - /* "PyCafe.pyx":7173 + /* "PyCafe.pyx":7380 * # if list * valType = CAFE_INVALID_DATATYPE * pvdata[i].setNelem(len(vectorList[i])) # <<<<<<<<<<<<<< @@ -119358,15 +123036,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7173, __pyx_L1_error) + __PYX_ERR(3, 7380, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7173, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_14 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_14 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7173, __pyx_L1_error) + __pyx_t_14 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_14 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7380, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setNelem(__pyx_t_14)); - /* "PyCafe.pyx":7176 + /* "PyCafe.pyx":7383 * # 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 # <<<<<<<<<<<<<< @@ -119376,7 +123054,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P for (__pyx_t_15 = 0; __pyx_t_15 < 1; __pyx_t_15+=1) { __pyx_v_k = __pyx_t_15; - /* "PyCafe.pyx":7177 + /* "PyCafe.pyx":7384 * # 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)): # <<<<<<<<<<<<<< @@ -119385,11 +123063,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7177, __pyx_L1_error) + __PYX_ERR(3, 7384, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7177, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7177, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = PyUnicode_Check(__pyx_t_5); @@ -119397,7 +123075,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7178 + /* "PyCafe.pyx":7385 * 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 # <<<<<<<<<<<<<< @@ -119406,7 +123084,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ __pyx_v_valType = CAFE_STRING; - /* "PyCafe.pyx":7179 + /* "PyCafe.pyx":7386 * if isinstance(vectorList[i][k], (str)): * valType = CAFE_STRING * break # <<<<<<<<<<<<<< @@ -119415,7 +123093,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ goto __pyx_L17_break; - /* "PyCafe.pyx":7177 + /* "PyCafe.pyx":7384 * # 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)): # <<<<<<<<<<<<<< @@ -119425,7 +123103,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P goto __pyx_L18; } - /* "PyCafe.pyx":7180 + /* "PyCafe.pyx":7387 * valType = CAFE_STRING * break * elif isinstance(vectorList[i][k], (float)): # <<<<<<<<<<<<<< @@ -119434,11 +123112,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7180, __pyx_L1_error) + __PYX_ERR(3, 7387, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7180, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7180, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_2 = PyFloat_Check(__pyx_t_4); @@ -119446,7 +123124,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7181 + /* "PyCafe.pyx":7388 * break * elif isinstance(vectorList[i][k], (float)): * valType = CAFE_DOUBLE # <<<<<<<<<<<<<< @@ -119455,7 +123133,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ __pyx_v_valType = CAFE_DOUBLE; - /* "PyCafe.pyx":7180 + /* "PyCafe.pyx":7387 * valType = CAFE_STRING * break * elif isinstance(vectorList[i][k], (float)): # <<<<<<<<<<<<<< @@ -119465,7 +123143,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P goto __pyx_L18; } - /* "PyCafe.pyx":7182 + /* "PyCafe.pyx":7389 * elif isinstance(vectorList[i][k], (float)): * valType = CAFE_DOUBLE * elif isinstance(vectorList[i][k], (long, int)): # <<<<<<<<<<<<<< @@ -119474,11 +123152,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7182, __pyx_L1_error) + __PYX_ERR(3, 7389, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7182, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7182, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = PyLong_Check(__pyx_t_5); @@ -119496,7 +123174,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7183 + /* "PyCafe.pyx":7390 * valType = CAFE_DOUBLE * elif isinstance(vectorList[i][k], (long, int)): * if valType != CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -119506,7 +123184,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((__pyx_v_valType != CAFE_DOUBLE) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7184 + /* "PyCafe.pyx":7391 * elif isinstance(vectorList[i][k], (long, int)): * if valType != CAFE_DOUBLE: * valType = CAFE_LONG # <<<<<<<<<<<<<< @@ -119515,7 +123193,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ __pyx_v_valType = CAFE_LONG; - /* "PyCafe.pyx":7183 + /* "PyCafe.pyx":7390 * valType = CAFE_DOUBLE * elif isinstance(vectorList[i][k], (long, int)): * if valType != CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -119525,7 +123203,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P goto __pyx_L21; } - /* "PyCafe.pyx":7186 + /* "PyCafe.pyx":7393 * valType = CAFE_LONG * else: * valType = CAFE_STRING # <<<<<<<<<<<<<< @@ -119535,7 +123213,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P /*else*/ { __pyx_v_valType = CAFE_STRING; - /* "PyCafe.pyx":7187 + /* "PyCafe.pyx":7394 * else: * valType = CAFE_STRING * break # <<<<<<<<<<<<<< @@ -119546,7 +123224,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P } __pyx_L21:; - /* "PyCafe.pyx":7182 + /* "PyCafe.pyx":7389 * elif isinstance(vectorList[i][k], (float)): * valType = CAFE_DOUBLE * elif isinstance(vectorList[i][k], (long, int)): # <<<<<<<<<<<<<< @@ -119558,7 +123236,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P } __pyx_L17_break:; - /* "PyCafe.pyx":7190 + /* "PyCafe.pyx":7397 * * # check dt of first element * if valType == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -119568,7 +123246,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P switch (__pyx_v_valType) { case CAFE_DOUBLE: - /* "PyCafe.pyx":7191 + /* "PyCafe.pyx":7398 * # check dt of first element * if valType == CAFE_DOUBLE: * pvdata[i].setVDouble(vectorList[i]) # <<<<<<<<<<<<<< @@ -119577,15 +123255,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7191, __pyx_L1_error) + __PYX_ERR(3, 7398, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7191, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_16 = __pyx_convert_vector_from_py_double(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7191, __pyx_L1_error) + __pyx_t_16 = __pyx_convert_vector_from_py_double(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7398, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setVDouble(__pyx_t_16)); - /* "PyCafe.pyx":7190 + /* "PyCafe.pyx":7397 * * # check dt of first element * if valType == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -119595,7 +123273,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P break; case CAFE_LONG: - /* "PyCafe.pyx":7193 + /* "PyCafe.pyx":7400 * pvdata[i].setVDouble(vectorList[i]) * elif valType == CAFE_LONG: * pvdata[i].setVInt(vectorList[i]) # <<<<<<<<<<<<<< @@ -119604,15 +123282,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7193, __pyx_L1_error) + __PYX_ERR(3, 7400, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7193, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7400, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_17 = __pyx_convert_vector_from_py_int(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7193, __pyx_L1_error) + __pyx_t_17 = __pyx_convert_vector_from_py_int(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7400, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setVInt(__pyx_t_17)); - /* "PyCafe.pyx":7192 + /* "PyCafe.pyx":7399 * if valType == CAFE_DOUBLE: * pvdata[i].setVDouble(vectorList[i]) * elif valType == CAFE_LONG: # <<<<<<<<<<<<<< @@ -119622,7 +123300,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P break; case CAFE_STRING: - /* "PyCafe.pyx":7195 + /* "PyCafe.pyx":7402 * pvdata[i].setVInt(vectorList[i]) * elif valType == CAFE_STRING: * pvdata[i].setVString(vectorList[i]) # <<<<<<<<<<<<<< @@ -119631,15 +123309,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7195, __pyx_L1_error) + __PYX_ERR(3, 7402, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7195, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7402, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_18 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7195, __pyx_L1_error) + __pyx_t_18 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7402, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setVString(__pyx_t_18)); - /* "PyCafe.pyx":7194 + /* "PyCafe.pyx":7401 * elif valType == CAFE_LONG: * pvdata[i].setVInt(vectorList[i]) * elif valType == CAFE_STRING: # <<<<<<<<<<<<<< @@ -119650,7 +123328,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P default: break; } - /* "PyCafe.pyx":7169 + /* "PyCafe.pyx":7376 * pvdata[i].setInt(vectorList[i]) * * elif isinstance(vectorList[i], (list)): # <<<<<<<<<<<<<< @@ -119660,7 +123338,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P goto __pyx_L13; } - /* "PyCafe.pyx":7198 + /* "PyCafe.pyx":7405 * * else: * print("This line in PyCafe def setCompoundList should never appear!") # <<<<<<<<<<<<<< @@ -119668,27 +123346,27 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P * Unknown data input; should be one of of type , , , ") */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__133, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7198, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__128, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7199 + /* "PyCafe.pyx":7406 * 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 of type , , , ") * */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__134, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7199, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__129, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 7199, __pyx_L1_error) + __PYX_ERR(3, 7406, __pyx_L1_error) } __pyx_L13:; } - /* "PyCafe.pyx":7204 + /* "PyCafe.pyx":7411 * # endForLoop * * cdef int status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -119697,7 +123375,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":7205 + /* "PyCafe.pyx":7412 * * cdef int status = ICAFE_NORMAL * with nogil: # <<<<<<<<<<<<<< @@ -119712,7 +123390,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":7206 + /* "PyCafe.pyx":7413 * cdef int status = ICAFE_NORMAL * with nogil: * status = self._c_cafe.setPVArray(v, pvdata) # <<<<<<<<<<<<<< @@ -119722,7 +123400,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_v_status = __pyx_v_self->_c_cafe->setPVArray(__pyx_v_v, __pyx_v_pvdata); } - /* "PyCafe.pyx":7205 + /* "PyCafe.pyx":7412 * * cdef int status = ICAFE_NORMAL * with nogil: # <<<<<<<<<<<<<< @@ -119741,19 +123419,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P } } - /* "PyCafe.pyx":7209 + /* "PyCafe.pyx":7416 * * # return status for individual channels * statusList = [] # <<<<<<<<<<<<<< * * if status != ICAFE_NORMAL: */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7209, __pyx_L1_error) + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_statusList = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7211 + /* "PyCafe.pyx":7418 * statusList = [] * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -119763,7 +123441,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7212 + /* "PyCafe.pyx":7419 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -119773,7 +123451,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7213 + /* "PyCafe.pyx":7420 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -119782,7 +123460,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":7212 + /* "PyCafe.pyx":7419 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -119791,7 +123469,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7211 + /* "PyCafe.pyx":7418 * statusList = [] * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -119800,19 +123478,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7215 + /* "PyCafe.pyx":7422 * self._c_cafe.printStatusMessage(status) * * for i in range(0, len(handleList)): # <<<<<<<<<<<<<< * if (pvdata[i].getStatus() != ICAFE_NORMAL): * print("Handle=", handleList[i], "PV=", */ - __pyx_t_8 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7215, __pyx_L1_error) + __pyx_t_8 = PyObject_Length(__pyx_v_handleList); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7422, __pyx_L1_error) __pyx_t_7 = __pyx_t_8; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_7; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":7216 + /* "PyCafe.pyx":7423 * * for i in range(0, len(handleList)): * if (pvdata[i].getStatus() != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -119822,38 +123500,38 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_2 = (((__pyx_v_pvdata[__pyx_v_i]).getStatus() != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7217 + /* "PyCafe.pyx":7424 * 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()) */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7217, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - /* "PyCafe.pyx":7218 + /* "PyCafe.pyx":7425 * 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()) */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7218, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handleList, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7218, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_10 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7425, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_10)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7218, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyStr_FromString(__pyx_v_self->hh.getPVFromHandle(__pyx_t_10)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "PyCafe.pyx":7217 + /* "PyCafe.pyx":7424 * 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()) */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7217, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_kp_u_Handle); __Pyx_GIVEREF(__pyx_kp_u_Handle); @@ -119867,21 +123545,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_4); __pyx_t_5 = 0; __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7217, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":7219 + /* "PyCafe.pyx":7426 * 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("") */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvdata[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7219, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvdata[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7219, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_kp_u_with_error_status); __Pyx_GIVEREF(__pyx_kp_u_with_error_status); @@ -119889,12 +123567,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7219, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":7220 + /* "PyCafe.pyx":7427 * self.hh.getPVFromHandle(handleList[i])) * print("with error status=", pvdata[i].getStatus()) * self._c_cafe.printStatusMessage(pvdata[i].getStatus()) # <<<<<<<<<<<<<< @@ -119903,18 +123581,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ __pyx_v_self->_c_cafe->printStatusMessage((__pyx_v_pvdata[__pyx_v_i]).getStatus()); - /* "PyCafe.pyx":7221 + /* "PyCafe.pyx":7428 * 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()) */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7221, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":7216 + /* "PyCafe.pyx":7423 * * for i in range(0, len(handleList)): * if (pvdata[i].getStatus() != ICAFE_NORMAL): # <<<<<<<<<<<<<< @@ -119923,20 +123601,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7223 + /* "PyCafe.pyx":7430 * print("") * #raise Exception("EXCEPTION RAISED in PyCafe def setCompoundList. Status = %d" %status) * statusList.append(pvdata[i].getStatus()) # <<<<<<<<<<<<<< * * return status, statusList */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvdata[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7223, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_pvdata[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_19 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_4); if (unlikely(__pyx_t_19 == ((int)-1))) __PYX_ERR(3, 7223, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_4); if (unlikely(__pyx_t_19 == ((int)-1))) __PYX_ERR(3, 7430, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } - /* "PyCafe.pyx":7225 + /* "PyCafe.pyx":7432 * statusList.append(pvdata[i].getStatus()) * * return status, statusList # <<<<<<<<<<<<<< @@ -119944,9 +123622,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7225, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7225, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 7432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); @@ -119958,7 +123636,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P __pyx_t_3 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7125 + /* "PyCafe.pyx":7332 * * ################################################################################## * def setCompoundList(self, handleList, list vectorList): # <<<<<<<<<<<<<< @@ -119984,7 +123662,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_400setCompoundList(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":7230 +/* "PyCafe.pyx":7437 * * ################################################################################## * def setGroup(self, ghandleName, list vectorList): # <<<<<<<<<<<<<< @@ -120023,11 +123701,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_403setGroup(PyObject *__pyx_v_self, Py case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vectorList)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setGroup", 1, 2, 2, 1); __PYX_ERR(3, 7230, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setGroup", 1, 2, 2, 1); __PYX_ERR(3, 7437, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGroup") < 0)) __PYX_ERR(3, 7230, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGroup") < 0)) __PYX_ERR(3, 7437, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -120040,13 +123718,13 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_403setGroup(PyObject *__pyx_v_self, Py } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setGroup", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7230, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setGroup", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7437, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setGroup", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vectorList), (&PyList_Type), 1, "vectorList", 1))) __PYX_ERR(3, 7230, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vectorList), (&PyList_Type), 1, "vectorList", 1))) __PYX_ERR(3, 7437, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_402setGroup(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_ghandleName, __pyx_v_vectorList); /* function exit code */ @@ -120094,7 +123772,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C int __pyx_t_20; __Pyx_RefNannySetupContext("setGroup", 0); - /* "PyCafe.pyx":7232 + /* "PyCafe.pyx":7439 * def setGroup(self, ghandleName, list vectorList): * * cdef str _METHOD = "setGroup(self, ghandleName, list vectorList)" # <<<<<<<<<<<<<< @@ -120104,7 +123782,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_kp_u_setGroup_self_ghandleName_list_v); __pyx_v__METHOD = __pyx_kp_u_setGroup_self_ghandleName_list_v; - /* "PyCafe.pyx":7234 + /* "PyCafe.pyx":7441 * cdef str _METHOD = "setGroup(self, ghandleName, list vectorList)" * * cdef unsigned int ghandle = 0 # <<<<<<<<<<<<<< @@ -120113,7 +123791,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_ghandle = 0; - /* "PyCafe.pyx":7235 + /* "PyCafe.pyx":7442 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -120134,17 +123812,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7236 + /* "PyCafe.pyx":7443 * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName # <<<<<<<<<<<<<< * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7236, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_ghandleName); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7443, __pyx_L1_error) __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":7235 + /* "PyCafe.pyx":7442 * * cdef unsigned int ghandle = 0 * if isinstance(ghandleName, (int, long)): # <<<<<<<<<<<<<< @@ -120154,7 +123832,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L3; } - /* "PyCafe.pyx":7237 + /* "PyCafe.pyx":7444 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -120165,21 +123843,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7238 + /* "PyCafe.pyx":7445 * ghandle = ghandleName * elif isinstance(ghandleName, (str)): * ghandle = self.checkForGroupHandle(ghandleName) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 7238, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7238, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_ghandleName))||((__pyx_v_ghandleName) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_ghandleName)->tp_name), 0))) __PYX_ERR(3, 7445, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForGroupHandle(__pyx_v_self, ((PyObject*)__pyx_v_ghandleName), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7238, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7445, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_ghandle = __pyx_t_4; - /* "PyCafe.pyx":7237 + /* "PyCafe.pyx":7444 * if isinstance(ghandleName, (int, long)): * ghandle = ghandleName * elif isinstance(ghandleName, (str)): # <<<<<<<<<<<<<< @@ -120189,7 +123867,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L3; } - /* "PyCafe.pyx":7240 + /* "PyCafe.pyx":7447 * ghandle = self.checkForGroupHandle(ghandleName) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -120197,18 +123875,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C * raise _cafeException */ /*else*/ { - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7240, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7240, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7240, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_11) < 0) __PYX_ERR(3, 7240, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7240, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7447, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7447, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_11) < 0) __PYX_ERR(3, 7447, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7242 + /* "PyCafe.pyx":7449 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument should be of type if group handle, else if group name") * raise _cafeException # <<<<<<<<<<<<<< @@ -120216,11 +123894,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C * cdef PVGroup pvg */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7242, __pyx_L1_error) + __PYX_ERR(3, 7449, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":7246 + /* "PyCafe.pyx":7453 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -120235,7 +123913,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C #endif /*try:*/ { - /* "PyCafe.pyx":7247 + /* "PyCafe.pyx":7454 * * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) # <<<<<<<<<<<<<< @@ -120245,7 +123923,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C (void)(__pyx_v_self->_c_cafe->groupAttach(__pyx_v_ghandle, __pyx_v_pvg)); } - /* "PyCafe.pyx":7246 + /* "PyCafe.pyx":7453 * cdef PVGroup pvg * * with nogil: # <<<<<<<<<<<<<< @@ -120264,7 +123942,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C } } - /* "PyCafe.pyx":7251 + /* "PyCafe.pyx":7458 * #print ("len V", len(vectorList), " npv=", pvg.getNPV()) * * cdef PVDataHolder * pvdata = pvg.getPVData() # <<<<<<<<<<<<<< @@ -120273,7 +123951,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_pvdata = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":7253 + /* "PyCafe.pyx":7460 * cdef PVDataHolder * pvdata = pvg.getPVData() * * for i in range(0, len(vectorList)): # <<<<<<<<<<<<<< @@ -120282,14 +123960,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7253, __pyx_L1_error) + __PYX_ERR(3, 7460, __pyx_L1_error) } - __pyx_t_7 = PyList_GET_SIZE(__pyx_v_vectorList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7253, __pyx_L1_error) + __pyx_t_7 = PyList_GET_SIZE(__pyx_v_vectorList); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7460, __pyx_L1_error) __pyx_t_8 = __pyx_t_7; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; - /* "PyCafe.pyx":7256 + /* "PyCafe.pyx":7463 * * # if not list * if isinstance(vectorList[i], (str)): # <<<<<<<<<<<<<< @@ -120298,16 +123976,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7256, __pyx_L1_error) + __PYX_ERR(3, 7463, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7256, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7463, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyUnicode_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7257 + /* "PyCafe.pyx":7464 * # if not list * if isinstance(vectorList[i], (str)): * pvdata[i].setString(vectorList[i]) # <<<<<<<<<<<<<< @@ -120316,15 +123994,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7257, __pyx_L1_error) + __PYX_ERR(3, 7464, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7257, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7464, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = __pyx_convert_string_from_py_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7257, __pyx_L1_error) + __pyx_t_10 = __pyx_convert_string_from_py_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7464, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setString(__pyx_t_10)); - /* "PyCafe.pyx":7256 + /* "PyCafe.pyx":7463 * * # if not list * if isinstance(vectorList[i], (str)): # <<<<<<<<<<<<<< @@ -120334,7 +124012,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L11; } - /* "PyCafe.pyx":7259 + /* "PyCafe.pyx":7466 * pvdata[i].setString(vectorList[i]) * * elif isinstance(vectorList[i], (float)): # <<<<<<<<<<<<<< @@ -120343,16 +124021,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7259, __pyx_L1_error) + __PYX_ERR(3, 7466, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7259, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyFloat_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7260 + /* "PyCafe.pyx":7467 * * elif isinstance(vectorList[i], (float)): * pvdata[i].setDouble(vectorList[i]) # <<<<<<<<<<<<<< @@ -120361,15 +124039,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7260, __pyx_L1_error) + __PYX_ERR(3, 7467, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7260, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_11 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7260, __pyx_L1_error) + __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_11 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7467, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setDouble(__pyx_t_11)); - /* "PyCafe.pyx":7259 + /* "PyCafe.pyx":7466 * pvdata[i].setString(vectorList[i]) * * elif isinstance(vectorList[i], (float)): # <<<<<<<<<<<<<< @@ -120379,7 +124057,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L11; } - /* "PyCafe.pyx":7262 + /* "PyCafe.pyx":7469 * pvdata[i].setDouble(vectorList[i]) * * elif isinstance(vectorList[i], (long, int)): # <<<<<<<<<<<<<< @@ -120388,9 +124066,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7262, __pyx_L1_error) + __PYX_ERR(3, 7469, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7262, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyLong_Check(__pyx_t_6); __pyx_t_3 = (__pyx_t_2 != 0); @@ -120407,7 +124085,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7263 + /* "PyCafe.pyx":7470 * * elif isinstance(vectorList[i], (long, int)): * pvdata[i].setInt(vectorList[i]) # <<<<<<<<<<<<<< @@ -120416,15 +124094,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7263, __pyx_L1_error) + __PYX_ERR(3, 7470, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7263, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7263, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7470, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setInt(__pyx_t_12)); - /* "PyCafe.pyx":7262 + /* "PyCafe.pyx":7469 * pvdata[i].setDouble(vectorList[i]) * * elif isinstance(vectorList[i], (long, int)): # <<<<<<<<<<<<<< @@ -120434,7 +124112,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L11; } - /* "PyCafe.pyx":7265 + /* "PyCafe.pyx":7472 * pvdata[i].setInt(vectorList[i]) * * elif isinstance(vectorList[i], (list)): # <<<<<<<<<<<<<< @@ -120443,16 +124121,16 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7265, __pyx_L1_error) + __PYX_ERR(3, 7472, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7265, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyList_Check(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7268 + /* "PyCafe.pyx":7475 * * # if list * valType = CAFE_INVALID_DATATYPE # <<<<<<<<<<<<<< @@ -120461,7 +124139,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_valType = CAFE_INVALID_DATATYPE; - /* "PyCafe.pyx":7269 + /* "PyCafe.pyx":7476 * # if list * valType = CAFE_INVALID_DATATYPE * pvdata[i].setNelem(len(vectorList[i])) # <<<<<<<<<<<<<< @@ -120470,15 +124148,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7269, __pyx_L1_error) + __PYX_ERR(3, 7476, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7269, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = PyObject_Length(__pyx_t_6); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7269, __pyx_L1_error) + __pyx_t_13 = PyObject_Length(__pyx_t_6); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7476, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setNelem(__pyx_t_13)); - /* "PyCafe.pyx":7272 + /* "PyCafe.pyx":7479 * # 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 # <<<<<<<<<<<<<< @@ -120488,7 +124166,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_14 = 0; __pyx_t_14 < 1; __pyx_t_14+=1) { __pyx_v_k = __pyx_t_14; - /* "PyCafe.pyx":7273 + /* "PyCafe.pyx":7480 * # 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)): # <<<<<<<<<<<<<< @@ -120497,11 +124175,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7273, __pyx_L1_error) + __PYX_ERR(3, 7480, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7273, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_6, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7273, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_6, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_1 = PyUnicode_Check(__pyx_t_5); @@ -120509,7 +124187,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7274 + /* "PyCafe.pyx":7481 * 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 # <<<<<<<<<<<<<< @@ -120518,7 +124196,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_valType = CAFE_STRING; - /* "PyCafe.pyx":7275 + /* "PyCafe.pyx":7482 * if isinstance(vectorList[i][k], (str)): * valType = CAFE_STRING * break # <<<<<<<<<<<<<< @@ -120527,7 +124205,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ goto __pyx_L15_break; - /* "PyCafe.pyx":7273 + /* "PyCafe.pyx":7480 * # 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)): # <<<<<<<<<<<<<< @@ -120537,7 +124215,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L16; } - /* "PyCafe.pyx":7276 + /* "PyCafe.pyx":7483 * valType = CAFE_STRING * break * elif isinstance(vectorList[i][k], (float)): # <<<<<<<<<<<<<< @@ -120546,11 +124224,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7276, __pyx_L1_error) + __PYX_ERR(3, 7483, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7276, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7276, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_2 = PyFloat_Check(__pyx_t_6); @@ -120558,7 +124236,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7277 + /* "PyCafe.pyx":7484 * break * elif isinstance(vectorList[i][k], (float)): * valType = CAFE_DOUBLE # <<<<<<<<<<<<<< @@ -120567,7 +124245,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_valType = CAFE_DOUBLE; - /* "PyCafe.pyx":7276 + /* "PyCafe.pyx":7483 * valType = CAFE_STRING * break * elif isinstance(vectorList[i][k], (float)): # <<<<<<<<<<<<<< @@ -120577,7 +124255,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L16; } - /* "PyCafe.pyx":7278 + /* "PyCafe.pyx":7485 * elif isinstance(vectorList[i][k], (float)): * valType = CAFE_DOUBLE * elif isinstance(vectorList[i][k], (long, int)): # <<<<<<<<<<<<<< @@ -120586,11 +124264,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7278, __pyx_L1_error) + __PYX_ERR(3, 7485, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7278, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_6, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7278, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_6, __pyx_v_k, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = PyLong_Check(__pyx_t_5); @@ -120608,7 +124286,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7279 + /* "PyCafe.pyx":7486 * valType = CAFE_DOUBLE * elif isinstance(vectorList[i][k], (long, int)): * if valType != CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -120618,7 +124296,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_valType != CAFE_DOUBLE) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7280 + /* "PyCafe.pyx":7487 * elif isinstance(vectorList[i][k], (long, int)): * if valType != CAFE_DOUBLE: * valType = CAFE_LONG # <<<<<<<<<<<<<< @@ -120627,7 +124305,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_valType = CAFE_LONG; - /* "PyCafe.pyx":7279 + /* "PyCafe.pyx":7486 * valType = CAFE_DOUBLE * elif isinstance(vectorList[i][k], (long, int)): * if valType != CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -120637,7 +124315,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L19; } - /* "PyCafe.pyx":7282 + /* "PyCafe.pyx":7489 * valType = CAFE_LONG * else: * valType = CAFE_STRING # <<<<<<<<<<<<<< @@ -120647,7 +124325,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C /*else*/ { __pyx_v_valType = CAFE_STRING; - /* "PyCafe.pyx":7283 + /* "PyCafe.pyx":7490 * else: * valType = CAFE_STRING * break # <<<<<<<<<<<<<< @@ -120658,7 +124336,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C } __pyx_L19:; - /* "PyCafe.pyx":7278 + /* "PyCafe.pyx":7485 * elif isinstance(vectorList[i][k], (float)): * valType = CAFE_DOUBLE * elif isinstance(vectorList[i][k], (long, int)): # <<<<<<<<<<<<<< @@ -120670,7 +124348,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C } __pyx_L15_break:; - /* "PyCafe.pyx":7286 + /* "PyCafe.pyx":7493 * * # check dt of first element * if valType == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -120680,7 +124358,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C switch (__pyx_v_valType) { case CAFE_DOUBLE: - /* "PyCafe.pyx":7287 + /* "PyCafe.pyx":7494 * # check dt of first element * if valType == CAFE_DOUBLE: * pvdata[i].setVDouble(vectorList[i]) # <<<<<<<<<<<<<< @@ -120689,15 +124367,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7287, __pyx_L1_error) + __PYX_ERR(3, 7494, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7287, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_15 = __pyx_convert_vector_from_py_double(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7287, __pyx_L1_error) + __pyx_t_15 = __pyx_convert_vector_from_py_double(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7494, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setVDouble(__pyx_t_15)); - /* "PyCafe.pyx":7286 + /* "PyCafe.pyx":7493 * * # check dt of first element * if valType == CAFE_DOUBLE: # <<<<<<<<<<<<<< @@ -120707,7 +124385,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_LONG: - /* "PyCafe.pyx":7289 + /* "PyCafe.pyx":7496 * pvdata[i].setVDouble(vectorList[i]) * elif valType == CAFE_LONG: * pvdata[i].setVInt(vectorList[i]) # <<<<<<<<<<<<<< @@ -120716,15 +124394,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7289, __pyx_L1_error) + __PYX_ERR(3, 7496, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7289, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_16 = __pyx_convert_vector_from_py_int(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7289, __pyx_L1_error) + __pyx_t_16 = __pyx_convert_vector_from_py_int(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7496, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setVInt(__pyx_t_16)); - /* "PyCafe.pyx":7288 + /* "PyCafe.pyx":7495 * if valType == CAFE_DOUBLE: * pvdata[i].setVDouble(vectorList[i]) * elif valType == CAFE_LONG: # <<<<<<<<<<<<<< @@ -120734,7 +124412,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C break; case CAFE_STRING: - /* "PyCafe.pyx":7291 + /* "PyCafe.pyx":7498 * pvdata[i].setVInt(vectorList[i]) * elif valType == CAFE_STRING: * pvdata[i].setVString(vectorList[i]) # <<<<<<<<<<<<<< @@ -120743,15 +124421,15 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7291, __pyx_L1_error) + __PYX_ERR(3, 7498, __pyx_L1_error) } - __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7291, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_17 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7291, __pyx_L1_error) + __pyx_t_17 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7498, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; (void)((__pyx_v_pvdata[__pyx_v_i]).setVString(__pyx_t_17)); - /* "PyCafe.pyx":7290 + /* "PyCafe.pyx":7497 * elif valType == CAFE_LONG: * pvdata[i].setVInt(vectorList[i]) * elif valType == CAFE_STRING: # <<<<<<<<<<<<<< @@ -120762,7 +124440,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C default: break; } - /* "PyCafe.pyx":7265 + /* "PyCafe.pyx":7472 * pvdata[i].setInt(vectorList[i]) * * elif isinstance(vectorList[i], (list)): # <<<<<<<<<<<<<< @@ -120772,7 +124450,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L11; } - /* "PyCafe.pyx":7295 + /* "PyCafe.pyx":7502 * else: * * print("PyCafe def setGroup: Unusual data type for element", # <<<<<<<<<<<<<< @@ -120781,66 +124459,66 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ /*else*/ { - /* "PyCafe.pyx":7296 + /* "PyCafe.pyx":7503 * * 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 of type , , , ") */ - __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7296, __pyx_L1_error) + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__pyx_v_vectorList == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7296, __pyx_L1_error) + __PYX_ERR(3, 7503, __pyx_L1_error) } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7296, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_vectorList, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":7295 + /* "PyCafe.pyx":7502 * else: * * print("PyCafe def setGroup: Unusual data type for element", # <<<<<<<<<<<<<< * i, " : ", type(vectorList[i])) * raise Exception("EXCEPTION RAISED IN PyCafe def setGroup. \n\ */ - __pyx_t_18 = PyTuple_New(4); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 7295, __pyx_L1_error) + __pyx_t_18 = PyTuple_New(4); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 7502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); __Pyx_INCREF(__pyx_kp_u_PyCafe_def_setGroup_Unusual_data); __Pyx_GIVEREF(__pyx_kp_u_PyCafe_def_setGroup_Unusual_data); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_kp_u_PyCafe_def_setGroup_Unusual_data); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_5); - __Pyx_INCREF(__pyx_kp_u__135); - __Pyx_GIVEREF(__pyx_kp_u__135); - PyTuple_SET_ITEM(__pyx_t_18, 2, __pyx_kp_u__135); + __Pyx_INCREF(__pyx_kp_u__130); + __Pyx_GIVEREF(__pyx_kp_u__130); + PyTuple_SET_ITEM(__pyx_t_18, 2, __pyx_kp_u__130); __Pyx_INCREF(((PyObject *)Py_TYPE(__pyx_t_6))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_t_6))); PyTuple_SET_ITEM(__pyx_t_18, 3, ((PyObject *)Py_TYPE(__pyx_t_6))); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_18, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7295, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_18, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7297 + /* "PyCafe.pyx":7504 * 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 of type , , , ") * */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__136, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7297, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__131, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7297, __pyx_L1_error) + __PYX_ERR(3, 7504, __pyx_L1_error) } __pyx_L11:; } - /* "PyCafe.pyx":7302 + /* "PyCafe.pyx":7509 * # endForLoop * * cdef int status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -120849,19 +124527,19 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":7303 + /* "PyCafe.pyx":7510 * * cdef int status = ICAFE_NORMAL * statusList = [] # <<<<<<<<<<<<<< * pvg.setPVData(pvdata) * */ - __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7303, __pyx_L1_error) + __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7510, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_statusList = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7304 + /* "PyCafe.pyx":7511 * cdef int status = ICAFE_NORMAL * statusList = [] * pvg.setPVData(pvdata) # <<<<<<<<<<<<<< @@ -120870,7 +124548,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_pvg.setPVData(__pyx_v_pvdata); - /* "PyCafe.pyx":7306 + /* "PyCafe.pyx":7513 * pvg.setPVData(pvdata) * * with nogil: # <<<<<<<<<<<<<< @@ -120885,7 +124563,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C #endif /*try:*/ { - /* "PyCafe.pyx":7307 + /* "PyCafe.pyx":7514 * * with nogil: * status = self._c_cafe.groupSet(ghandle, pvg) # <<<<<<<<<<<<<< @@ -120895,7 +124573,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_v_status = __pyx_v_self->_c_cafe->groupSet(__pyx_v_ghandle, __pyx_v_pvg); } - /* "PyCafe.pyx":7306 + /* "PyCafe.pyx":7513 * pvg.setPVData(pvdata) * * with nogil: # <<<<<<<<<<<<<< @@ -120914,7 +124592,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C } } - /* "PyCafe.pyx":7311 + /* "PyCafe.pyx":7518 * cdef PVDataHolder * pvd * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -120924,7 +124602,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7312 + /* "PyCafe.pyx":7519 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -120934,7 +124612,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_2 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7313 + /* "PyCafe.pyx":7520 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -120943,7 +124621,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":7312 + /* "PyCafe.pyx":7519 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -120952,7 +124630,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":7317 + /* "PyCafe.pyx":7524 * #raise Exception("EXCEPTION RAISED in PyCafe def setGroup. Status = %d" %status) * * pvd = pvg.getPVData() # <<<<<<<<<<<<<< @@ -120961,7 +124639,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C */ __pyx_v_pvd = __pyx_v_pvg.getPVData(); - /* "PyCafe.pyx":7319 + /* "PyCafe.pyx":7526 * pvd = pvg.getPVData() * * for i in range(0, pvg.getNPV()): # <<<<<<<<<<<<<< @@ -120973,20 +124651,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_19; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "PyCafe.pyx":7320 + /* "PyCafe.pyx":7527 * * for i in range(0, pvg.getNPV()): * statusList.append(pvd[i].getStatus()) # <<<<<<<<<<<<<< * else: * statusList.append(status) */ - __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7320, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_pvd[__pyx_v_i]).getStatus()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_20 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_6); if (unlikely(__pyx_t_20 == ((int)-1))) __PYX_ERR(3, 7320, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_6); if (unlikely(__pyx_t_20 == ((int)-1))) __PYX_ERR(3, 7527, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } - /* "PyCafe.pyx":7311 + /* "PyCafe.pyx":7518 * cdef PVDataHolder * pvd * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -120996,7 +124674,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C goto __pyx_L23; } - /* "PyCafe.pyx":7322 + /* "PyCafe.pyx":7529 * statusList.append(pvd[i].getStatus()) * else: * statusList.append(status) # <<<<<<<<<<<<<< @@ -121004,14 +124682,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C * return status, statusList */ /*else*/ { - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7322, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_20 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_6); if (unlikely(__pyx_t_20 == ((int)-1))) __PYX_ERR(3, 7322, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyList_Append(__pyx_v_statusList, __pyx_t_6); if (unlikely(__pyx_t_20 == ((int)-1))) __PYX_ERR(3, 7529, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_L23:; - /* "PyCafe.pyx":7324 + /* "PyCafe.pyx":7531 * statusList.append(status) * * return status, statusList # <<<<<<<<<<<<<< @@ -121019,9 +124697,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7324, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 7324, __pyx_L1_error) + __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(3, 7531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_6); @@ -121033,7 +124711,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C __pyx_t_18 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7230 + /* "PyCafe.pyx":7437 * * ################################################################################## * def setGroup(self, ghandleName, list vectorList): # <<<<<<<<<<<<<< @@ -121059,7 +124737,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_402setGroup(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":7332 +/* "PyCafe.pyx":7539 * ################################################################################## * * def gameSetAndMatch(self, list handlePVSet, list valSet, handlePVAction, valAction, list handlePVMatch, double tolerance, double timeout, bint printFlag): # <<<<<<<<<<<<<< @@ -121116,47 +124794,47 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_405gameSetAndMatch(PyObject *__pyx_v_s case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_valSet)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 1); __PYX_ERR(3, 7332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 1); __PYX_ERR(3, 7539, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_handlePVAction)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 2); __PYX_ERR(3, 7332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 2); __PYX_ERR(3, 7539, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_valAction)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 3); __PYX_ERR(3, 7332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 3); __PYX_ERR(3, 7539, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_handlePVMatch)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 4); __PYX_ERR(3, 7332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 4); __PYX_ERR(3, 7539, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tolerance)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 5); __PYX_ERR(3, 7332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 5); __PYX_ERR(3, 7539, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 6); __PYX_ERR(3, 7332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 6); __PYX_ERR(3, 7539, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_printFlag)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 7); __PYX_ERR(3, 7332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, 7); __PYX_ERR(3, 7539, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "gameSetAndMatch") < 0)) __PYX_ERR(3, 7332, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "gameSetAndMatch") < 0)) __PYX_ERR(3, 7539, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 8) { goto __pyx_L5_argtuple_error; @@ -121175,21 +124853,21 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_405gameSetAndMatch(PyObject *__pyx_v_s __pyx_v_handlePVAction = values[2]; __pyx_v_valAction = values[3]; __pyx_v_handlePVMatch = ((PyObject*)values[4]); - __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7332, __pyx_L3_error) - __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7332, __pyx_L3_error) - __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[7]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7332, __pyx_L3_error) + __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7539, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7539, __pyx_L3_error) + __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[7]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7539, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("gameSetAndMatch", 1, 8, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7539, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.gameSetAndMatch", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVSet), (&PyList_Type), 1, "handlePVSet", 1))) __PYX_ERR(3, 7332, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_valSet), (&PyList_Type), 1, "valSet", 1))) __PYX_ERR(3, 7332, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVMatch), (&PyList_Type), 1, "handlePVMatch", 1))) __PYX_ERR(3, 7332, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVSet), (&PyList_Type), 1, "handlePVSet", 1))) __PYX_ERR(3, 7539, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_valSet), (&PyList_Type), 1, "valSet", 1))) __PYX_ERR(3, 7539, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVMatch), (&PyList_Type), 1, "handlePVMatch", 1))) __PYX_ERR(3, 7539, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePVSet, __pyx_v_valSet, __pyx_v_handlePVAction, __pyx_v_valAction, __pyx_v_handlePVMatch, __pyx_v_tolerance, __pyx_v_timeout, __pyx_v_printFlag); /* function exit code */ @@ -121230,7 +124908,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __Pyx_INCREF(__pyx_v_handlePVAction); __Pyx_INCREF(__pyx_v_valAction); - /* "PyCafe.pyx":7333 + /* "PyCafe.pyx":7540 * * def gameSetAndMatch(self, list handlePVSet, list valSet, handlePVAction, valAction, list handlePVMatch, double tolerance, double timeout, bint printFlag): * cdef str _METHOD = "gameSetAndMatch(list handlePVSet, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag)" # <<<<<<<<<<<<<< @@ -121240,7 +124918,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __Pyx_INCREF(__pyx_kp_u_gameSetAndMatch_list_handlePVSet); __pyx_v__METHOD = __pyx_kp_u_gameSetAndMatch_list_handlePVSet; - /* "PyCafe.pyx":7336 + /* "PyCafe.pyx":7543 * * * if (len(handlePVSet) != len(valSet)): # <<<<<<<<<<<<<< @@ -121249,31 +124927,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7336, __pyx_L1_error) + __PYX_ERR(3, 7543, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7336, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7543, __pyx_L1_error) if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7336, __pyx_L1_error) + __PYX_ERR(3, 7543, __pyx_L1_error) } - __pyx_t_2 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7336, __pyx_L1_error) + __pyx_t_2 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7543, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_1 != __pyx_t_2) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7337 + /* "PyCafe.pyx":7544 * * 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!") * */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__137, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7337, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__132, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7544, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 7337, __pyx_L1_error) + __PYX_ERR(3, 7544, __pyx_L1_error) - /* "PyCafe.pyx":7336 + /* "PyCafe.pyx":7543 * * * if (len(handlePVSet) != len(valSet)): # <<<<<<<<<<<<<< @@ -121282,7 +124960,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7340 + /* "PyCafe.pyx":7547 * Lengths of first (handlePVSet) and second (valSet) input lists must match!") * * if (len(handlePVSet) != len(handlePVMatch)): # <<<<<<<<<<<<<< @@ -121291,31 +124969,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7340, __pyx_L1_error) + __PYX_ERR(3, 7547, __pyx_L1_error) } - __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7340, __pyx_L1_error) + __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7547, __pyx_L1_error) if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7340, __pyx_L1_error) + __PYX_ERR(3, 7547, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7340, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7547, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_2 != __pyx_t_1) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7341 + /* "PyCafe.pyx":7548 * * 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!") * */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__138, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7341, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__133, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7548, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 7341, __pyx_L1_error) + __PYX_ERR(3, 7548, __pyx_L1_error) - /* "PyCafe.pyx":7340 + /* "PyCafe.pyx":7547 * Lengths of first (handlePVSet) and second (valSet) input lists must match!") * * if (len(handlePVSet) != len(handlePVMatch)): # <<<<<<<<<<<<<< @@ -121324,7 +125002,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7344 + /* "PyCafe.pyx":7551 * Lengths of first (handlePVSet) and third (handlePVMatch) input lists must match!") * * if not isinstance(handlePVAction, (list)): # <<<<<<<<<<<<<< @@ -121335,7 +125013,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __pyx_t_5 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":7345 + /* "PyCafe.pyx":7552 * * if not isinstance(handlePVAction, (list)): * tmp = handlePVAction # <<<<<<<<<<<<<< @@ -121345,28 +125023,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __Pyx_INCREF(__pyx_v_handlePVAction); __pyx_v_tmp = __pyx_v_handlePVAction; - /* "PyCafe.pyx":7346 + /* "PyCafe.pyx":7553 * if not isinstance(handlePVAction, (list)): * tmp = handlePVAction * handlePVAction = [] # <<<<<<<<<<<<<< * handlePVAction.append(tmp) * */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7346, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_handlePVAction, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":7347 + /* "PyCafe.pyx":7554 * tmp = handlePVAction * handlePVAction = [] * handlePVAction.append(tmp) # <<<<<<<<<<<<<< * * if not isinstance(valAction, (list)): */ - __pyx_t_6 = __Pyx_PyObject_Append(__pyx_v_handlePVAction, __pyx_v_tmp); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(3, 7347, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Append(__pyx_v_handlePVAction, __pyx_v_tmp); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(3, 7554, __pyx_L1_error) - /* "PyCafe.pyx":7344 + /* "PyCafe.pyx":7551 * Lengths of first (handlePVSet) and third (handlePVMatch) input lists must match!") * * if not isinstance(handlePVAction, (list)): # <<<<<<<<<<<<<< @@ -121375,7 +125053,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7349 + /* "PyCafe.pyx":7556 * handlePVAction.append(tmp) * * if not isinstance(valAction, (list)): # <<<<<<<<<<<<<< @@ -121386,7 +125064,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __pyx_t_3 = ((!(__pyx_t_5 != 0)) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7350 + /* "PyCafe.pyx":7557 * * if not isinstance(valAction, (list)): * tmp = valAction # <<<<<<<<<<<<<< @@ -121396,28 +125074,28 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __Pyx_INCREF(__pyx_v_valAction); __Pyx_XDECREF_SET(__pyx_v_tmp, __pyx_v_valAction); - /* "PyCafe.pyx":7351 + /* "PyCafe.pyx":7558 * if not isinstance(valAction, (list)): * tmp = valAction * valAction = [] # <<<<<<<<<<<<<< * valAction.append(tmp) * */ - __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7351, __pyx_L1_error) + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_valAction, __pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":7352 + /* "PyCafe.pyx":7559 * tmp = valAction * valAction = [] * valAction.append(tmp) # <<<<<<<<<<<<<< * * cdef vector[unsigned int] handleSet */ - __pyx_t_6 = __Pyx_PyObject_Append(__pyx_v_valAction, __pyx_v_tmp); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(3, 7352, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Append(__pyx_v_valAction, __pyx_v_tmp); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(3, 7559, __pyx_L1_error) - /* "PyCafe.pyx":7349 + /* "PyCafe.pyx":7556 * handlePVAction.append(tmp) * * if not isinstance(valAction, (list)): # <<<<<<<<<<<<<< @@ -121426,7 +125104,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7355 + /* "PyCafe.pyx":7562 * * cdef vector[unsigned int] handleSet * handleSet.reserve(len(handlePVSet)) # <<<<<<<<<<<<<< @@ -121435,12 +125113,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7355, __pyx_L1_error) + __PYX_ERR(3, 7562, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7355, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7562, __pyx_L1_error) __pyx_v_handleSet.reserve(__pyx_t_1); - /* "PyCafe.pyx":7358 + /* "PyCafe.pyx":7565 * * cdef vector[unsigned int] handleMatch * handleMatch.reserve(len(handlePVMatch)) # <<<<<<<<<<<<<< @@ -121449,12 +125127,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7358, __pyx_L1_error) + __PYX_ERR(3, 7565, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7358, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7565, __pyx_L1_error) __pyx_v_handleMatch.reserve(__pyx_t_1); - /* "PyCafe.pyx":7361 + /* "PyCafe.pyx":7568 * * cdef vector[double] valSetV * valSetV.reserve(len(valSet)) # <<<<<<<<<<<<<< @@ -121463,32 +125141,32 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7361, __pyx_L1_error) + __PYX_ERR(3, 7568, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7361, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7568, __pyx_L1_error) __pyx_v_valSetV.reserve(__pyx_t_1); - /* "PyCafe.pyx":7364 + /* "PyCafe.pyx":7571 * * cdef vector[unsigned int] handleAction * handleAction.reserve(len(handlePVAction)) # <<<<<<<<<<<<<< * * cdef vector[string] valActionV */ - __pyx_t_1 = PyObject_Length(__pyx_v_handlePVAction); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7364, __pyx_L1_error) + __pyx_t_1 = PyObject_Length(__pyx_v_handlePVAction); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7571, __pyx_L1_error) __pyx_v_handleAction.reserve(__pyx_t_1); - /* "PyCafe.pyx":7367 + /* "PyCafe.pyx":7574 * * cdef vector[string] valActionV * valActionV.reserve(len(valAction)) # <<<<<<<<<<<<<< * * for i in range(0, len(handlePVSet)): */ - __pyx_t_1 = PyObject_Length(__pyx_v_valAction); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7367, __pyx_L1_error) + __pyx_t_1 = PyObject_Length(__pyx_v_valAction); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7574, __pyx_L1_error) __pyx_v_valActionV.reserve(__pyx_t_1); - /* "PyCafe.pyx":7369 + /* "PyCafe.pyx":7576 * valActionV.reserve(len(valAction)) * * for i in range(0, len(handlePVSet)): # <<<<<<<<<<<<<< @@ -121497,14 +125175,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7369, __pyx_L1_error) + __PYX_ERR(3, 7576, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7369, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7576, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_2; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "PyCafe.pyx":7370 + /* "PyCafe.pyx":7577 * * for i in range(0, len(handlePVSet)): * if isinstance(handlePVSet[i], (int, long)): # <<<<<<<<<<<<<< @@ -121513,9 +125191,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7370, __pyx_L1_error) + __PYX_ERR(3, 7577, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7370, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyInt_Check(__pyx_t_4); __pyx_t_8 = (__pyx_t_5 != 0); @@ -121532,7 +125210,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __pyx_t_5 = (__pyx_t_3 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":7371 + /* "PyCafe.pyx":7578 * for i in range(0, len(handlePVSet)): * if isinstance(handlePVSet[i], (int, long)): * handleSet.push_back(handlePVSet[i]) # <<<<<<<<<<<<<< @@ -121541,20 +125219,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7371, __pyx_L1_error) + __PYX_ERR(3, 7578, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7371, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7371, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7578, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_handleSet.push_back(__pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7371, __pyx_L1_error) + __PYX_ERR(3, 7578, __pyx_L1_error) } - /* "PyCafe.pyx":7370 + /* "PyCafe.pyx":7577 * * for i in range(0, len(handlePVSet)): * if isinstance(handlePVSet[i], (int, long)): # <<<<<<<<<<<<<< @@ -121564,7 +125242,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P goto __pyx_L9; } - /* "PyCafe.pyx":7372 + /* "PyCafe.pyx":7579 * if isinstance(handlePVSet[i], (int, long)): * handleSet.push_back(handlePVSet[i]) * elif isinstance(handlePVSet[i], (str)): # <<<<<<<<<<<<<< @@ -121573,35 +125251,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7372, __pyx_L1_error) + __PYX_ERR(3, 7579, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7372, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__pyx_t_5 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7373 + /* "PyCafe.pyx":7580 * handleSet.push_back(handlePVSet[i]) * elif isinstance(handlePVSet[i], (str)): * handleSet.push_back(self.checkForHandle(handlePVSet)) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVSet))||((__pyx_v_handlePVSet) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVSet)->tp_name), 0))) __PYX_ERR(3, 7373, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVSet), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7373, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVSet))||((__pyx_v_handlePVSet) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVSet)->tp_name), 0))) __PYX_ERR(3, 7580, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVSet), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7580, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7373, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7580, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_handleSet.push_back(__pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7373, __pyx_L1_error) + __PYX_ERR(3, 7580, __pyx_L1_error) } - /* "PyCafe.pyx":7372 + /* "PyCafe.pyx":7579 * if isinstance(handlePVSet[i], (int, long)): * handleSet.push_back(handlePVSet[i]) * elif isinstance(handlePVSet[i], (str)): # <<<<<<<<<<<<<< @@ -121611,7 +125289,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P goto __pyx_L9; } - /* "PyCafe.pyx":7375 + /* "PyCafe.pyx":7582 * handleSet.push_back(self.checkForHandle(handlePVSet)) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -121619,18 +125297,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P * raise _cafeException */ /*else*/ { - __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7375, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7582, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7375, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7375, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_kp_u_ThandlePVSet_list_member_should) < 0) __PYX_ERR(3, 7375, __pyx_L1_error) - __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7375, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7582, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7582, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_kp_u_ThandlePVSet_list_member_should) < 0) __PYX_ERR(3, 7582, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7582, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":7377 + /* "PyCafe.pyx":7584 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="ThandlePVSet list member should be of type if handle, else if PV") * raise _cafeException # <<<<<<<<<<<<<< @@ -121638,12 +125316,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P * for i in range(0, len(handlePVMatch)): */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7377, __pyx_L1_error) + __PYX_ERR(3, 7584, __pyx_L1_error) } __pyx_L9:; } - /* "PyCafe.pyx":7379 + /* "PyCafe.pyx":7586 * raise _cafeException * * for i in range(0, len(handlePVMatch)): # <<<<<<<<<<<<<< @@ -121652,14 +125330,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7379, __pyx_L1_error) + __PYX_ERR(3, 7586, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7379, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7586, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_2; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "PyCafe.pyx":7380 + /* "PyCafe.pyx":7587 * * for i in range(0, len(handlePVMatch)): * if isinstance(handlePVMatch[i], (int, long)): # <<<<<<<<<<<<<< @@ -121668,9 +125346,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7380, __pyx_L1_error) + __PYX_ERR(3, 7587, __pyx_L1_error) } - __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7380, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7587, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_5 = PyInt_Check(__pyx_t_10); __pyx_t_8 = (__pyx_t_5 != 0); @@ -121687,7 +125365,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __pyx_t_5 = (__pyx_t_3 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":7381 + /* "PyCafe.pyx":7588 * for i in range(0, len(handlePVMatch)): * if isinstance(handlePVMatch[i], (int, long)): * handleMatch.push_back(handlePVMatch[i]) # <<<<<<<<<<<<<< @@ -121696,20 +125374,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7381, __pyx_L1_error) + __PYX_ERR(3, 7588, __pyx_L1_error) } - __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7381, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_10); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7381, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_10); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7588, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; try { __pyx_v_handleMatch.push_back(__pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7381, __pyx_L1_error) + __PYX_ERR(3, 7588, __pyx_L1_error) } - /* "PyCafe.pyx":7380 + /* "PyCafe.pyx":7587 * * for i in range(0, len(handlePVMatch)): * if isinstance(handlePVMatch[i], (int, long)): # <<<<<<<<<<<<<< @@ -121719,7 +125397,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P goto __pyx_L14; } - /* "PyCafe.pyx":7382 + /* "PyCafe.pyx":7589 * if isinstance(handlePVMatch[i], (int, long)): * handleMatch.push_back(handlePVMatch[i]) * elif isinstance(handlePVMatch[i], (str)): # <<<<<<<<<<<<<< @@ -121728,35 +125406,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7382, __pyx_L1_error) + __PYX_ERR(3, 7589, __pyx_L1_error) } - __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7382, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_5 = PyUnicode_Check(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_3 = (__pyx_t_5 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7383 + /* "PyCafe.pyx":7590 * handleMatch.push_back(handlePVMatch[i]) * elif isinstance(handlePVMatch[i], (str)): * handleMatch.push_back(self.checkForHandle(handlePVMatch)) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7383, __pyx_L1_error) - __pyx_t_10 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7383, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7590, __pyx_L1_error) + __pyx_t_10 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7590, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_10); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7383, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_10); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7590, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; try { __pyx_v_handleMatch.push_back(__pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7383, __pyx_L1_error) + __PYX_ERR(3, 7590, __pyx_L1_error) } - /* "PyCafe.pyx":7382 + /* "PyCafe.pyx":7589 * if isinstance(handlePVMatch[i], (int, long)): * handleMatch.push_back(handlePVMatch[i]) * elif isinstance(handlePVMatch[i], (str)): # <<<<<<<<<<<<<< @@ -121766,7 +125444,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P goto __pyx_L14; } - /* "PyCafe.pyx":7385 + /* "PyCafe.pyx":7592 * handleMatch.push_back(self.checkForHandle(handlePVMatch)) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -121774,18 +125452,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P * raise _cafeException */ /*else*/ { - __pyx_t_10 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7385, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7385, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7385, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_info, __pyx_kp_u_handleMatch_list_member_should_b) < 0) __PYX_ERR(3, 7385, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7385, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7592, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7592, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_error_info, __pyx_kp_u_handleMatch_list_member_should_b) < 0) __PYX_ERR(3, 7592, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":7387 + /* "PyCafe.pyx":7594 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="handleMatch list member should be of type if handle, else if PV") * raise _cafeException # <<<<<<<<<<<<<< @@ -121793,31 +125471,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P * for i in range(0, len(handlePVAction)): */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7387, __pyx_L1_error) + __PYX_ERR(3, 7594, __pyx_L1_error) } __pyx_L14:; } - /* "PyCafe.pyx":7389 + /* "PyCafe.pyx":7596 * raise _cafeException * * for i in range(0, len(handlePVAction)): # <<<<<<<<<<<<<< * if isinstance(handlePVAction[i], (int, long)): * handleAction.push_back(handlePVAction[i]) */ - __pyx_t_1 = PyObject_Length(__pyx_v_handlePVAction); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7389, __pyx_L1_error) + __pyx_t_1 = PyObject_Length(__pyx_v_handlePVAction); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7596, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_2; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "PyCafe.pyx":7390 + /* "PyCafe.pyx":7597 * * for i in range(0, len(handlePVAction)): * if isinstance(handlePVAction[i], (int, long)): # <<<<<<<<<<<<<< * handleAction.push_back(handlePVAction[i]) * elif isinstance(handlePVAction[i], (str)): */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handlePVAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7390, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handlePVAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7597, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyInt_Check(__pyx_t_4); __pyx_t_8 = (__pyx_t_5 != 0); @@ -121834,25 +125512,25 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __pyx_t_5 = (__pyx_t_3 != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":7391 + /* "PyCafe.pyx":7598 * for i in range(0, len(handlePVAction)): * if isinstance(handlePVAction[i], (int, long)): * handleAction.push_back(handlePVAction[i]) # <<<<<<<<<<<<<< * elif isinstance(handlePVAction[i], (str)): * handleAction.push_back(self.checkForHandle(handlePVAction)) */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handlePVAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7391, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handlePVAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7391, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7598, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_handleAction.push_back(__pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7391, __pyx_L1_error) + __PYX_ERR(3, 7598, __pyx_L1_error) } - /* "PyCafe.pyx":7390 + /* "PyCafe.pyx":7597 * * for i in range(0, len(handlePVAction)): * if isinstance(handlePVAction[i], (int, long)): # <<<<<<<<<<<<<< @@ -121862,40 +125540,40 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P goto __pyx_L19; } - /* "PyCafe.pyx":7392 + /* "PyCafe.pyx":7599 * if isinstance(handlePVAction[i], (int, long)): * handleAction.push_back(handlePVAction[i]) * elif isinstance(handlePVAction[i], (str)): # <<<<<<<<<<<<<< * handleAction.push_back(self.checkForHandle(handlePVAction)) * else: */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handlePVAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7392, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_handlePVAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__pyx_t_5 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7393 + /* "PyCafe.pyx":7600 * handleAction.push_back(handlePVAction[i]) * elif isinstance(handlePVAction[i], (str)): * handleAction.push_back(self.checkForHandle(handlePVAction)) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVAction))||((__pyx_v_handlePVAction) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVAction)->tp_name), 0))) __PYX_ERR(3, 7393, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVAction), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7393, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVAction))||((__pyx_v_handlePVAction) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVAction)->tp_name), 0))) __PYX_ERR(3, 7600, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVAction), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7393, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7600, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_handleAction.push_back(__pyx_t_9); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7393, __pyx_L1_error) + __PYX_ERR(3, 7600, __pyx_L1_error) } - /* "PyCafe.pyx":7392 + /* "PyCafe.pyx":7599 * if isinstance(handlePVAction[i], (int, long)): * handleAction.push_back(handlePVAction[i]) * elif isinstance(handlePVAction[i], (str)): # <<<<<<<<<<<<<< @@ -121905,7 +125583,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P goto __pyx_L19; } - /* "PyCafe.pyx":7395 + /* "PyCafe.pyx":7602 * handleAction.push_back(self.checkForHandle(handlePVAction)) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -121913,18 +125591,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P * raise _cafeException */ /*else*/ { - __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7395, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7395, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7395, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_kp_u_handlePVAction_list_member_shoul) < 0) __PYX_ERR(3, 7395, __pyx_L1_error) - __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7395, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7602, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7602, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_kp_u_handlePVAction_list_member_shoul) < 0) __PYX_ERR(3, 7602, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_10); __pyx_t_10 = 0; - /* "PyCafe.pyx":7397 + /* "PyCafe.pyx":7604 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="handlePVAction list member should be of type if handle, else if PV") * raise _cafeException # <<<<<<<<<<<<<< @@ -121932,59 +125610,59 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P * for i in range(0, len(valAction)): */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7397, __pyx_L1_error) + __PYX_ERR(3, 7604, __pyx_L1_error) } __pyx_L19:; } - /* "PyCafe.pyx":7399 + /* "PyCafe.pyx":7606 * raise _cafeException * * for i in range(0, len(valAction)): # <<<<<<<<<<<<<< * if not isinstance(valAction[i], (str)): * valActionV.push_back(str(valAction[i])) */ - __pyx_t_1 = PyObject_Length(__pyx_v_valAction); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7399, __pyx_L1_error) + __pyx_t_1 = PyObject_Length(__pyx_v_valAction); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7606, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_2; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "PyCafe.pyx":7400 + /* "PyCafe.pyx":7607 * * for i in range(0, len(valAction)): * if not isinstance(valAction[i], (str)): # <<<<<<<<<<<<<< * valActionV.push_back(str(valAction[i])) * else: */ - __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_valAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7400, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_valAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7607, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_3 = PyUnicode_Check(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_5 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":7401 + /* "PyCafe.pyx":7608 * 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]) */ - __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_valAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7401, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_valAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7401, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_11 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7401, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7608, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_valActionV.push_back(__pyx_t_11); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7401, __pyx_L1_error) + __PYX_ERR(3, 7608, __pyx_L1_error) } - /* "PyCafe.pyx":7400 + /* "PyCafe.pyx":7607 * * for i in range(0, len(valAction)): * if not isinstance(valAction[i], (str)): # <<<<<<<<<<<<<< @@ -121994,7 +125672,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P goto __pyx_L24; } - /* "PyCafe.pyx":7403 + /* "PyCafe.pyx":7610 * valActionV.push_back(str(valAction[i])) * else: * valActionV.push_back(valAction[i]) # <<<<<<<<<<<<<< @@ -122002,21 +125680,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P * for i in range(0, len(valSet)): */ /*else*/ { - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_valAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7403, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_valAction, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_11 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7403, __pyx_L1_error) + __pyx_t_11 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 7610, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_valActionV.push_back(__pyx_t_11); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7403, __pyx_L1_error) + __PYX_ERR(3, 7610, __pyx_L1_error) } } __pyx_L24:; } - /* "PyCafe.pyx":7405 + /* "PyCafe.pyx":7612 * valActionV.push_back(valAction[i]) * * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< @@ -122025,14 +125703,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7405, __pyx_L1_error) + __PYX_ERR(3, 7612, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7405, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7612, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_2; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "PyCafe.pyx":7406 + /* "PyCafe.pyx":7613 * * for i in range(0, len(valSet)): * valSetV.push_back(valSet[i]) # <<<<<<<<<<<<<< @@ -122041,21 +125719,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7406, __pyx_L1_error) + __PYX_ERR(3, 7613, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7406, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7613, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7406, __pyx_L1_error) + __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7613, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_valSetV.push_back(__pyx_t_12); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7406, __pyx_L1_error) + __PYX_ERR(3, 7613, __pyx_L1_error) } } - /* "PyCafe.pyx":7410 + /* "PyCafe.pyx":7617 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -122070,7 +125748,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":7411 + /* "PyCafe.pyx":7618 * * with nogil: * status = self._c_cafe.gameSetAndMatch( # <<<<<<<<<<<<<< @@ -122080,7 +125758,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __pyx_v_status = __pyx_v_self->_c_cafe->gameSetAndMatch(__pyx_v_handleSet, __pyx_v_valSetV, __pyx_v_handleAction, __pyx_v_valActionV, __pyx_v_handleMatch, __pyx_v_tolerance, __pyx_v_timeout, __pyx_v_printFlag); } - /* "PyCafe.pyx":7410 + /* "PyCafe.pyx":7617 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -122099,7 +125777,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P } } - /* "PyCafe.pyx":7414 + /* "PyCafe.pyx":7621 * handleSet, valSetV, handleAction, valActionV, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -122109,7 +125787,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __pyx_t_5 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":7415 + /* "PyCafe.pyx":7622 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -122119,7 +125797,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P __pyx_t_5 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_5) { - /* "PyCafe.pyx":7416 + /* "PyCafe.pyx":7623 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -122128,7 +125806,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":7415 + /* "PyCafe.pyx":7622 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -122137,34 +125815,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7418 + /* "PyCafe.pyx":7625 * self._c_cafe.printStatusMessage(status) * raise Exception( * "EXCEPTION RAISED in PyCafe def gameSetAndMatch. Status = %d" % status) # <<<<<<<<<<<<<< * * return status */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7418, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7625, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_10 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_g_4, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7418, __pyx_L1_error) + __pyx_t_10 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_g_4, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 7625, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":7417 + /* "PyCafe.pyx":7624 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def gameSetAndMatch. Status = %d" % status) * */ - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7417, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7624, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 7417, __pyx_L1_error) + __PYX_ERR(3, 7624, __pyx_L1_error) - /* "PyCafe.pyx":7414 + /* "PyCafe.pyx":7621 * handleSet, valSetV, handleAction, valActionV, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -122173,7 +125851,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7420 + /* "PyCafe.pyx":7627 * "EXCEPTION RAISED in PyCafe def gameSetAndMatch. Status = %d" % status) * * return status # <<<<<<<<<<<<<< @@ -122181,13 +125859,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7420, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7627, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7332 + /* "PyCafe.pyx":7539 * ################################################################################## * * def gameSetAndMatch(self, list handlePVSet, list valSet, handlePVAction, valAction, list handlePVMatch, double tolerance, double timeout, bint printFlag): # <<<<<<<<<<<<<< @@ -122214,7 +125892,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_404gameSetAndMatch(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":7425 +/* "PyCafe.pyx":7632 * ################################################################################## * * def setAndMatchMany(self, list handlePVSet, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag): # <<<<<<<<<<<<<< @@ -122265,35 +125943,35 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_407setAndMatchMany(PyObject *__pyx_v_s case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_valSet)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 1); __PYX_ERR(3, 7425, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 1); __PYX_ERR(3, 7632, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_handlePVMatch)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 2); __PYX_ERR(3, 7425, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 2); __PYX_ERR(3, 7632, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tolerance)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 3); __PYX_ERR(3, 7425, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 3); __PYX_ERR(3, 7632, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 4); __PYX_ERR(3, 7425, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 4); __PYX_ERR(3, 7632, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_printFlag)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 5); __PYX_ERR(3, 7425, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, 5); __PYX_ERR(3, 7632, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setAndMatchMany") < 0)) __PYX_ERR(3, 7425, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setAndMatchMany") < 0)) __PYX_ERR(3, 7632, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 6) { goto __pyx_L5_argtuple_error; @@ -122308,21 +125986,21 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_407setAndMatchMany(PyObject *__pyx_v_s __pyx_v_handlePVSet = ((PyObject*)values[0]); __pyx_v_valSet = ((PyObject*)values[1]); __pyx_v_handlePVMatch = ((PyObject*)values[2]); - __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7425, __pyx_L3_error) - __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7425, __pyx_L3_error) - __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7425, __pyx_L3_error) + __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7632, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7632, __pyx_L3_error) + __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7632, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7425, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatchMany", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7632, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setAndMatchMany", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVSet), (&PyList_Type), 1, "handlePVSet", 1))) __PYX_ERR(3, 7425, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_valSet), (&PyList_Type), 1, "valSet", 1))) __PYX_ERR(3, 7425, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVMatch), (&PyList_Type), 1, "handlePVMatch", 1))) __PYX_ERR(3, 7425, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVSet), (&PyList_Type), 1, "handlePVSet", 1))) __PYX_ERR(3, 7632, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_valSet), (&PyList_Type), 1, "valSet", 1))) __PYX_ERR(3, 7632, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVMatch), (&PyList_Type), 1, "handlePVMatch", 1))) __PYX_ERR(3, 7632, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_handlePVSet, __pyx_v_valSet, __pyx_v_handlePVMatch, __pyx_v_tolerance, __pyx_v_timeout, __pyx_v_printFlag); /* function exit code */ @@ -122356,7 +126034,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P double __pyx_t_10; __Pyx_RefNannySetupContext("setAndMatchMany", 0); - /* "PyCafe.pyx":7426 + /* "PyCafe.pyx":7633 * * 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)" # <<<<<<<<<<<<<< @@ -122366,7 +126044,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P __Pyx_INCREF(__pyx_kp_u_setAndMatchMany_list_handlePVSet); __pyx_v__METHOD = __pyx_kp_u_setAndMatchMany_list_handlePVSet; - /* "PyCafe.pyx":7429 + /* "PyCafe.pyx":7636 * * * if (len(handlePVSet) != len(valSet)): # <<<<<<<<<<<<<< @@ -122375,31 +126053,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7429, __pyx_L1_error) + __PYX_ERR(3, 7636, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7429, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7636, __pyx_L1_error) if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7429, __pyx_L1_error) + __PYX_ERR(3, 7636, __pyx_L1_error) } - __pyx_t_2 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7429, __pyx_L1_error) + __pyx_t_2 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7636, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_1 != __pyx_t_2) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7430 + /* "PyCafe.pyx":7637 * * 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!") * */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__137, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7430, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__132, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7637, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 7430, __pyx_L1_error) + __PYX_ERR(3, 7637, __pyx_L1_error) - /* "PyCafe.pyx":7429 + /* "PyCafe.pyx":7636 * * * if (len(handlePVSet) != len(valSet)): # <<<<<<<<<<<<<< @@ -122408,7 +126086,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7433 + /* "PyCafe.pyx":7640 * Lengths of first (handlePVSet) and second (valSet) input lists must match!") * * if (len(handlePVSet) != len(handlePVMatch)): # <<<<<<<<<<<<<< @@ -122417,31 +126095,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7433, __pyx_L1_error) + __PYX_ERR(3, 7640, __pyx_L1_error) } - __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7433, __pyx_L1_error) + __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7640, __pyx_L1_error) if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7433, __pyx_L1_error) + __PYX_ERR(3, 7640, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7433, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7640, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_2 != __pyx_t_1) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7434 + /* "PyCafe.pyx":7641 * * 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!") * */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__138, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7434, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__133, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 7434, __pyx_L1_error) + __PYX_ERR(3, 7641, __pyx_L1_error) - /* "PyCafe.pyx":7433 + /* "PyCafe.pyx":7640 * Lengths of first (handlePVSet) and second (valSet) input lists must match!") * * if (len(handlePVSet) != len(handlePVMatch)): # <<<<<<<<<<<<<< @@ -122450,7 +126128,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7438 + /* "PyCafe.pyx":7645 * * cdef vector[unsigned int] handleSet * handleSet.reserve(len(handlePVSet)) # <<<<<<<<<<<<<< @@ -122459,12 +126137,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7438, __pyx_L1_error) + __PYX_ERR(3, 7645, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7438, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7645, __pyx_L1_error) __pyx_v_handleSet.reserve(__pyx_t_1); - /* "PyCafe.pyx":7441 + /* "PyCafe.pyx":7648 * * cdef vector[unsigned int] handleMatch * handleMatch.reserve(len(handlePVMatch)) # <<<<<<<<<<<<<< @@ -122473,12 +126151,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7441, __pyx_L1_error) + __PYX_ERR(3, 7648, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7441, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7648, __pyx_L1_error) __pyx_v_handleMatch.reserve(__pyx_t_1); - /* "PyCafe.pyx":7444 + /* "PyCafe.pyx":7651 * * cdef vector[double] valSetV * valSetV.reserve(len(valSet)) # <<<<<<<<<<<<<< @@ -122487,12 +126165,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7444, __pyx_L1_error) + __PYX_ERR(3, 7651, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7444, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7651, __pyx_L1_error) __pyx_v_valSetV.reserve(__pyx_t_1); - /* "PyCafe.pyx":7446 + /* "PyCafe.pyx":7653 * valSetV.reserve(len(valSet)) * * for i in range(0, len(handlePVSet)): # <<<<<<<<<<<<<< @@ -122501,14 +126179,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7446, __pyx_L1_error) + __PYX_ERR(3, 7653, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7446, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7653, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_2; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":7447 + /* "PyCafe.pyx":7654 * * for i in range(0, len(handlePVSet)): * if isinstance(handlePVSet[i], (int, long)): # <<<<<<<<<<<<<< @@ -122517,9 +126195,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7447, __pyx_L1_error) + __PYX_ERR(3, 7654, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7447, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7654, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyInt_Check(__pyx_t_4); __pyx_t_7 = (__pyx_t_6 != 0); @@ -122536,7 +126214,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P __pyx_t_6 = (__pyx_t_3 != 0); if (__pyx_t_6) { - /* "PyCafe.pyx":7448 + /* "PyCafe.pyx":7655 * for i in range(0, len(handlePVSet)): * if isinstance(handlePVSet[i], (int, long)): * handleSet.push_back(handlePVSet[i]) # <<<<<<<<<<<<<< @@ -122545,20 +126223,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7448, __pyx_L1_error) + __PYX_ERR(3, 7655, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7448, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7655, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7448, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7655, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_handleSet.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7448, __pyx_L1_error) + __PYX_ERR(3, 7655, __pyx_L1_error) } - /* "PyCafe.pyx":7447 + /* "PyCafe.pyx":7654 * * for i in range(0, len(handlePVSet)): * if isinstance(handlePVSet[i], (int, long)): # <<<<<<<<<<<<<< @@ -122568,7 +126246,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P goto __pyx_L7; } - /* "PyCafe.pyx":7449 + /* "PyCafe.pyx":7656 * if isinstance(handlePVSet[i], (int, long)): * handleSet.push_back(handlePVSet[i]) * elif isinstance(handlePVSet[i], (str)): # <<<<<<<<<<<<<< @@ -122577,35 +126255,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7449, __pyx_L1_error) + __PYX_ERR(3, 7656, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7449, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__pyx_t_6 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7450 + /* "PyCafe.pyx":7657 * handleSet.push_back(handlePVSet[i]) * elif isinstance(handlePVSet[i], (str)): * handleSet.push_back(self.checkForHandle(handlePVSet)) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVSet))||((__pyx_v_handlePVSet) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVSet)->tp_name), 0))) __PYX_ERR(3, 7450, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVSet), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7450, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVSet))||((__pyx_v_handlePVSet) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVSet)->tp_name), 0))) __PYX_ERR(3, 7657, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVSet), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7450, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7657, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_handleSet.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7450, __pyx_L1_error) + __PYX_ERR(3, 7657, __pyx_L1_error) } - /* "PyCafe.pyx":7449 + /* "PyCafe.pyx":7656 * if isinstance(handlePVSet[i], (int, long)): * handleSet.push_back(handlePVSet[i]) * elif isinstance(handlePVSet[i], (str)): # <<<<<<<<<<<<<< @@ -122615,7 +126293,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P goto __pyx_L7; } - /* "PyCafe.pyx":7452 + /* "PyCafe.pyx":7659 * handleSet.push_back(self.checkForHandle(handlePVSet)) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -122623,18 +126301,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P * raise _cafeException */ /*else*/ { - __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7452, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7659, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7452, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7452, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_kp_u_ThandlePVSet_list_member_should) < 0) __PYX_ERR(3, 7452, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7452, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7659, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7659, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_kp_u_ThandlePVSet_list_member_should) < 0) __PYX_ERR(3, 7659, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7659, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":7454 + /* "PyCafe.pyx":7661 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="ThandlePVSet list member should be of type if handle, else if PV") * raise _cafeException # <<<<<<<<<<<<<< @@ -122642,12 +126320,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P * for i in range(0, len(handlePVMatch)): */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7454, __pyx_L1_error) + __PYX_ERR(3, 7661, __pyx_L1_error) } __pyx_L7:; } - /* "PyCafe.pyx":7456 + /* "PyCafe.pyx":7663 * raise _cafeException * * for i in range(0, len(handlePVMatch)): # <<<<<<<<<<<<<< @@ -122656,14 +126334,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7456, __pyx_L1_error) + __PYX_ERR(3, 7663, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7456, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7663, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_2; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":7457 + /* "PyCafe.pyx":7664 * * for i in range(0, len(handlePVMatch)): * if isinstance(handlePVMatch[i], (int, long)): # <<<<<<<<<<<<<< @@ -122672,9 +126350,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7457, __pyx_L1_error) + __PYX_ERR(3, 7664, __pyx_L1_error) } - __pyx_t_9 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7457, __pyx_L1_error) + __pyx_t_9 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7664, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = PyInt_Check(__pyx_t_9); __pyx_t_7 = (__pyx_t_6 != 0); @@ -122691,7 +126369,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P __pyx_t_6 = (__pyx_t_3 != 0); if (__pyx_t_6) { - /* "PyCafe.pyx":7458 + /* "PyCafe.pyx":7665 * for i in range(0, len(handlePVMatch)): * if isinstance(handlePVMatch[i], (int, long)): * handleMatch.push_back(handlePVMatch[i]) # <<<<<<<<<<<<<< @@ -122700,20 +126378,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7458, __pyx_L1_error) + __PYX_ERR(3, 7665, __pyx_L1_error) } - __pyx_t_9 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7458, __pyx_L1_error) + __pyx_t_9 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7665, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7458, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7665, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; try { __pyx_v_handleMatch.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7458, __pyx_L1_error) + __PYX_ERR(3, 7665, __pyx_L1_error) } - /* "PyCafe.pyx":7457 + /* "PyCafe.pyx":7664 * * for i in range(0, len(handlePVMatch)): * if isinstance(handlePVMatch[i], (int, long)): # <<<<<<<<<<<<<< @@ -122723,7 +126401,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P goto __pyx_L12; } - /* "PyCafe.pyx":7459 + /* "PyCafe.pyx":7666 * if isinstance(handlePVMatch[i], (int, long)): * handleMatch.push_back(handlePVMatch[i]) * elif isinstance(handlePVMatch[i], (str)): # <<<<<<<<<<<<<< @@ -122732,35 +126410,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7459, __pyx_L1_error) + __PYX_ERR(3, 7666, __pyx_L1_error) } - __pyx_t_9 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7459, __pyx_L1_error) + __pyx_t_9 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7666, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = PyUnicode_Check(__pyx_t_9); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_3 = (__pyx_t_6 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7460 + /* "PyCafe.pyx":7667 * handleMatch.push_back(handlePVMatch[i]) * elif isinstance(handlePVMatch[i], (str)): * handleMatch.push_back(self.checkForHandle(handlePVMatch)) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7460, __pyx_L1_error) - __pyx_t_9 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7460, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7667, __pyx_L1_error) + __pyx_t_9 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7460, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_9); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7667, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; try { __pyx_v_handleMatch.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7460, __pyx_L1_error) + __PYX_ERR(3, 7667, __pyx_L1_error) } - /* "PyCafe.pyx":7459 + /* "PyCafe.pyx":7666 * if isinstance(handlePVMatch[i], (int, long)): * handleMatch.push_back(handlePVMatch[i]) * elif isinstance(handlePVMatch[i], (str)): # <<<<<<<<<<<<<< @@ -122770,7 +126448,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P goto __pyx_L12; } - /* "PyCafe.pyx":7462 + /* "PyCafe.pyx":7669 * handleMatch.push_back(self.checkForHandle(handlePVMatch)) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -122778,18 +126456,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P * raise _cafeException */ /*else*/ { - __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7462, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7669, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7462, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7462, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_info, __pyx_kp_u_handleMatch_list_member_should_b) < 0) __PYX_ERR(3, 7462, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7462, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7669, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7669, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_error_info, __pyx_kp_u_handleMatch_list_member_should_b) < 0) __PYX_ERR(3, 7669, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7669, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":7464 + /* "PyCafe.pyx":7671 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="handleMatch list member should be of type if handle, else if PV") * raise _cafeException # <<<<<<<<<<<<<< @@ -122797,12 +126475,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P * for i in range(0, len(valSet)): */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7464, __pyx_L1_error) + __PYX_ERR(3, 7671, __pyx_L1_error) } __pyx_L12:; } - /* "PyCafe.pyx":7466 + /* "PyCafe.pyx":7673 * raise _cafeException * * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< @@ -122811,14 +126489,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7466, __pyx_L1_error) + __PYX_ERR(3, 7673, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7466, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7673, __pyx_L1_error) __pyx_t_2 = __pyx_t_1; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_2; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":7467 + /* "PyCafe.pyx":7674 * * for i in range(0, len(valSet)): * valSetV.push_back(valSet[i]) # <<<<<<<<<<<<<< @@ -122827,21 +126505,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7467, __pyx_L1_error) + __PYX_ERR(3, 7674, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7467, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7467, __pyx_L1_error) + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7674, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_valSetV.push_back(__pyx_t_10); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7467, __pyx_L1_error) + __PYX_ERR(3, 7674, __pyx_L1_error) } } - /* "PyCafe.pyx":7471 + /* "PyCafe.pyx":7678 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -122856,7 +126534,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P #endif /*try:*/ { - /* "PyCafe.pyx":7472 + /* "PyCafe.pyx":7679 * * with nogil: * status = self._c_cafe.setAndMatchMany( # <<<<<<<<<<<<<< @@ -122866,7 +126544,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P __pyx_v_status = __pyx_v_self->_c_cafe->setAndMatchMany(__pyx_v_handleSet, __pyx_v_valSetV, __pyx_v_handleMatch, __pyx_v_tolerance, __pyx_v_timeout, __pyx_v_printFlag); } - /* "PyCafe.pyx":7471 + /* "PyCafe.pyx":7678 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -122885,7 +126563,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P } } - /* "PyCafe.pyx":7475 + /* "PyCafe.pyx":7682 * handleSet, valSetV, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -122895,7 +126573,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P __pyx_t_3 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7476 + /* "PyCafe.pyx":7683 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -122905,7 +126583,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P __pyx_t_3 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7477 + /* "PyCafe.pyx":7684 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -122914,7 +126592,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":7476 + /* "PyCafe.pyx":7683 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -122923,34 +126601,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7479 + /* "PyCafe.pyx":7686 * self._c_cafe.printStatusMessage(status) * raise Exception( * "EXCEPTION RAISED in PyCafe def setAndMatchMany. Status = %d" % status) # <<<<<<<<<<<<<< * * return status */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7479, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7686, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_s, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7479, __pyx_L1_error) + __pyx_t_9 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_s, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7686, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "PyCafe.pyx":7478 + /* "PyCafe.pyx":7685 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def setAndMatchMany. Status = %d" % status) * */ - __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7478, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 7478, __pyx_L1_error) + __PYX_ERR(3, 7685, __pyx_L1_error) - /* "PyCafe.pyx":7475 + /* "PyCafe.pyx":7682 * handleSet, valSetV, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -122959,7 +126637,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P */ } - /* "PyCafe.pyx":7481 + /* "PyCafe.pyx":7688 * "EXCEPTION RAISED in PyCafe def setAndMatchMany. Status = %d" % status) * * return status # <<<<<<<<<<<<<< @@ -122967,13 +126645,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7481, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7688, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7425 + /* "PyCafe.pyx":7632 * ################################################################################## * * def setAndMatchMany(self, list handlePVSet, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag): # <<<<<<<<<<<<<< @@ -122997,7 +126675,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_406setAndMatchMany(struct __pyx_obj_6P return __pyx_r; } -/* "PyCafe.pyx":7486 +/* "PyCafe.pyx":7693 * ############################################################################ * * def setAndMatch(self, handlePVSet, double valSet, handlePVMatch, # <<<<<<<<<<<<<< @@ -123048,35 +126726,35 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_409setAndMatch(PyObject *__pyx_v_self, case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_valSet)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 1); __PYX_ERR(3, 7486, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 1); __PYX_ERR(3, 7693, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_handlePVMatch)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 2); __PYX_ERR(3, 7486, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 2); __PYX_ERR(3, 7693, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tolerance)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 3); __PYX_ERR(3, 7486, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 3); __PYX_ERR(3, 7693, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 4); __PYX_ERR(3, 7486, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 4); __PYX_ERR(3, 7693, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_printFlag)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 5); __PYX_ERR(3, 7486, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, 5); __PYX_ERR(3, 7693, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setAndMatch") < 0)) __PYX_ERR(3, 7486, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setAndMatch") < 0)) __PYX_ERR(3, 7693, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 6) { goto __pyx_L5_argtuple_error; @@ -123089,15 +126767,15 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_409setAndMatch(PyObject *__pyx_v_self, values[5] = PyTuple_GET_ITEM(__pyx_args, 5); } __pyx_v_handlePVSet = values[0]; - __pyx_v_valSet = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_valSet == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7486, __pyx_L3_error) + __pyx_v_valSet = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_valSet == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7693, __pyx_L3_error) __pyx_v_handlePVMatch = values[2]; - __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7487, __pyx_L3_error) - __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7487, __pyx_L3_error) - __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7487, __pyx_L3_error) + __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7694, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7694, __pyx_L3_error) + __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7694, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7486, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setAndMatch", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7693, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setAndMatch", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -123126,7 +126804,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf PyObject *__pyx_t_6 = NULL; __Pyx_RefNannySetupContext("setAndMatch", 0); - /* "PyCafe.pyx":7488 + /* "PyCafe.pyx":7695 * def setAndMatch(self, handlePVSet, double valSet, handlePVMatch, * double tolerance, double timeout, bint printFlag): * cdef str _METHOD = ("setAndMatch(handlePVSet, double valSet," # <<<<<<<<<<<<<< @@ -123136,7 +126814,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf __Pyx_INCREF(__pyx_kp_u_setAndMatch_handlePVSet_double_v); __pyx_v__METHOD = __pyx_kp_u_setAndMatch_handlePVSet_double_v; - /* "PyCafe.pyx":7492 + /* "PyCafe.pyx":7699 * "double timeout, bint printFlag)") * * cdef unsigned int handleSet = 0 # <<<<<<<<<<<<<< @@ -123145,7 +126823,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf */ __pyx_v_handleSet = 0; - /* "PyCafe.pyx":7493 + /* "PyCafe.pyx":7700 * * cdef unsigned int handleSet = 0 * if isinstance(handlePVSet, (int, long)): # <<<<<<<<<<<<<< @@ -123166,17 +126844,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7494 + /* "PyCafe.pyx":7701 * cdef unsigned int handleSet = 0 * if isinstance(handlePVSet, (int, long)): * handleSet = handlePVSet # <<<<<<<<<<<<<< * elif isinstance(handlePVSet, (str)): * handleSet = self.checkForHandle(handlePVSet) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePVSet); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7494, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePVSet); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7701, __pyx_L1_error) __pyx_v_handleSet = __pyx_t_4; - /* "PyCafe.pyx":7493 + /* "PyCafe.pyx":7700 * * cdef unsigned int handleSet = 0 * if isinstance(handlePVSet, (int, long)): # <<<<<<<<<<<<<< @@ -123186,7 +126864,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf goto __pyx_L3; } - /* "PyCafe.pyx":7495 + /* "PyCafe.pyx":7702 * if isinstance(handlePVSet, (int, long)): * handleSet = handlePVSet * elif isinstance(handlePVSet, (str)): # <<<<<<<<<<<<<< @@ -123197,21 +126875,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7496 + /* "PyCafe.pyx":7703 * handleSet = handlePVSet * elif isinstance(handlePVSet, (str)): * handleSet = self.checkForHandle(handlePVSet) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVSet))||((__pyx_v_handlePVSet) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVSet)->tp_name), 0))) __PYX_ERR(3, 7496, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVSet), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7496, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVSet))||((__pyx_v_handlePVSet) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVSet)->tp_name), 0))) __PYX_ERR(3, 7703, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVSet), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7496, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7703, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handleSet = __pyx_t_4; - /* "PyCafe.pyx":7495 + /* "PyCafe.pyx":7702 * if isinstance(handlePVSet, (int, long)): * handleSet = handlePVSet * elif isinstance(handlePVSet, (str)): # <<<<<<<<<<<<<< @@ -123221,7 +126899,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf goto __pyx_L3; } - /* "PyCafe.pyx":7498 + /* "PyCafe.pyx":7705 * handleSet = self.checkForHandle(handlePVSet) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< @@ -123230,33 +126908,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf */ /*else*/ { - /* "PyCafe.pyx":7499 + /* "PyCafe.pyx":7706 * else: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _error_info=("First input argument, should be of type if handle," + * "else if PV")) */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7499, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7499, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7499, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_6) < 0) __PYX_ERR(3, 7499, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7706, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7706, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o_6) < 0) __PYX_ERR(3, 7706, __pyx_L1_error) - /* "PyCafe.pyx":7498 + /* "PyCafe.pyx":7705 * handleSet = self.checkForHandle(handlePVSet) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _error_info=("First input argument, should be of type if handle," + */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7498, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7502 + /* "PyCafe.pyx":7709 * _error_info=("First input argument, should be of type if handle," + * "else if PV")) * raise _cafeException # <<<<<<<<<<<<<< @@ -123264,11 +126942,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf * cdef unsigned int handleMatch = 0 */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7502, __pyx_L1_error) + __PYX_ERR(3, 7709, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":7504 + /* "PyCafe.pyx":7711 * raise _cafeException * * cdef unsigned int handleMatch = 0 # <<<<<<<<<<<<<< @@ -123277,7 +126955,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf */ __pyx_v_handleMatch = 0; - /* "PyCafe.pyx":7505 + /* "PyCafe.pyx":7712 * * cdef unsigned int handleMatch = 0 * if isinstance(handlePVMatch, (int, long)): # <<<<<<<<<<<<<< @@ -123298,17 +126976,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7506 + /* "PyCafe.pyx":7713 * cdef unsigned int handleMatch = 0 * if isinstance(handlePVMatch, (int, long)): * handleMatch = handlePVMatch # <<<<<<<<<<<<<< * elif isinstance(handlePVMatch, (str)): * handleMatch = self.checkForHandle(handlePVMatch) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePVMatch); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7506, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePVMatch); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7713, __pyx_L1_error) __pyx_v_handleMatch = __pyx_t_4; - /* "PyCafe.pyx":7505 + /* "PyCafe.pyx":7712 * * cdef unsigned int handleMatch = 0 * if isinstance(handlePVMatch, (int, long)): # <<<<<<<<<<<<<< @@ -123318,7 +126996,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf goto __pyx_L6; } - /* "PyCafe.pyx":7507 + /* "PyCafe.pyx":7714 * if isinstance(handlePVMatch, (int, long)): * handleMatch = handlePVMatch * elif isinstance(handlePVMatch, (str)): # <<<<<<<<<<<<<< @@ -123329,21 +127007,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7508 + /* "PyCafe.pyx":7715 * handleMatch = handlePVMatch * elif isinstance(handlePVMatch, (str)): * handleMatch = self.checkForHandle(handlePVMatch) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7508, __pyx_L1_error) - __pyx_t_6 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7508, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7715, __pyx_L1_error) + __pyx_t_6 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7508, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_6); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7715, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_handleMatch = __pyx_t_4; - /* "PyCafe.pyx":7507 + /* "PyCafe.pyx":7714 * if isinstance(handlePVMatch, (int, long)): * handleMatch = handlePVMatch * elif isinstance(handlePVMatch, (str)): # <<<<<<<<<<<<<< @@ -123353,7 +127031,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf goto __pyx_L6; } - /* "PyCafe.pyx":7510 + /* "PyCafe.pyx":7717 * handleMatch = self.checkForHandle(handlePVMatch) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< @@ -123362,33 +127040,33 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf */ /*else*/ { - /* "PyCafe.pyx":7511 + /* "PyCafe.pyx":7718 * else: * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _error_info=("Third input argument, should be of type if handle," + * "else if PV")) */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7511, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7511, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7511, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_kp_u_Third_input_argument_should_be_o_2) < 0) __PYX_ERR(3, 7511, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7718, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7718, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_kp_u_Third_input_argument_should_be_o_2) < 0) __PYX_ERR(3, 7718, __pyx_L1_error) - /* "PyCafe.pyx":7510 + /* "PyCafe.pyx":7717 * handleMatch = self.checkForHandle(handlePVMatch) * else: * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _error_info=("Third input argument, should be of type if handle," + */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7510, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7717, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7514 + /* "PyCafe.pyx":7721 * _error_info=("Third input argument, should be of type if handle," + * "else if PV")) * raise _cafeException # <<<<<<<<<<<<<< @@ -123396,11 +127074,11 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf * cdef int status */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7514, __pyx_L1_error) + __PYX_ERR(3, 7721, __pyx_L1_error) } __pyx_L6:; - /* "PyCafe.pyx":7518 + /* "PyCafe.pyx":7725 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -123415,7 +127093,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf #endif /*try:*/ { - /* "PyCafe.pyx":7519 + /* "PyCafe.pyx":7726 * * with nogil: * status = self._c_cafe.setAndMatch( # <<<<<<<<<<<<<< @@ -123425,7 +127103,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf __pyx_v_status = __pyx_v_self->_c_cafe->setAndMatch(__pyx_v_handleSet, __pyx_v_valSet, __pyx_v_handleMatch, __pyx_v_tolerance, __pyx_v_timeout, __pyx_v_printFlag); } - /* "PyCafe.pyx":7518 + /* "PyCafe.pyx":7725 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -123444,7 +127122,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf } } - /* "PyCafe.pyx":7522 + /* "PyCafe.pyx":7729 * handleSet, valSet, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -123454,7 +127132,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7523 + /* "PyCafe.pyx":7730 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -123464,7 +127142,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7524 + /* "PyCafe.pyx":7731 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -123473,7 +127151,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":7523 + /* "PyCafe.pyx":7730 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -123482,34 +127160,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":7526 + /* "PyCafe.pyx":7733 * self._c_cafe.printStatusMessage(status) * raise Exception( * "EXCEPTION RAISED in PyCafe def setAndMatch. Status = %d" % status) # <<<<<<<<<<<<<< * * return status */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7526, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7733, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_s_2, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7526, __pyx_L1_error) + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_s_2, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7733, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7525 + /* "PyCafe.pyx":7732 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def setAndMatch. Status = %d" % status) * */ - __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7525, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7732, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(3, 7525, __pyx_L1_error) + __PYX_ERR(3, 7732, __pyx_L1_error) - /* "PyCafe.pyx":7522 + /* "PyCafe.pyx":7729 * handleSet, valSet, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -123518,7 +127196,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf */ } - /* "PyCafe.pyx":7528 + /* "PyCafe.pyx":7735 * "EXCEPTION RAISED in PyCafe def setAndMatch. Status = %d" % status) * * return status # <<<<<<<<<<<<<< @@ -123526,13 +127204,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7528, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7486 + /* "PyCafe.pyx":7693 * ############################################################################ * * def setAndMatch(self, handlePVSet, double valSet, handlePVMatch, # <<<<<<<<<<<<<< @@ -123556,7 +127234,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_408setAndMatch(struct __pyx_obj_6PyCaf return __pyx_r; } -/* "PyCafe.pyx":7533 +/* "PyCafe.pyx":7740 * ################################################################################## * * def matchMany(self, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag): # <<<<<<<<<<<<<< @@ -123604,29 +127282,29 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_411matchMany(PyObject *__pyx_v_self, P case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_handlePVMatch)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, 1); __PYX_ERR(3, 7533, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, 1); __PYX_ERR(3, 7740, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tolerance)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, 2); __PYX_ERR(3, 7533, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, 2); __PYX_ERR(3, 7740, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, 3); __PYX_ERR(3, 7533, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, 3); __PYX_ERR(3, 7740, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_printFlag)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, 4); __PYX_ERR(3, 7533, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, 4); __PYX_ERR(3, 7740, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "matchMany") < 0)) __PYX_ERR(3, 7533, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "matchMany") < 0)) __PYX_ERR(3, 7740, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { goto __pyx_L5_argtuple_error; @@ -123639,20 +127317,20 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_411matchMany(PyObject *__pyx_v_self, P } __pyx_v_valSet = ((PyObject*)values[0]); __pyx_v_handlePVMatch = ((PyObject*)values[1]); - __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7533, __pyx_L3_error) - __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7533, __pyx_L3_error) - __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7533, __pyx_L3_error) + __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7740, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7740, __pyx_L3_error) + __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7740, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7533, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("matchMany", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7740, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.matchMany", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_valSet), (&PyList_Type), 1, "valSet", 1))) __PYX_ERR(3, 7533, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVMatch), (&PyList_Type), 1, "handlePVMatch", 1))) __PYX_ERR(3, 7533, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_valSet), (&PyList_Type), 1, "valSet", 1))) __PYX_ERR(3, 7740, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handlePVMatch), (&PyList_Type), 1, "handlePVMatch", 1))) __PYX_ERR(3, 7740, __pyx_L1_error) __pyx_r = __pyx_pf_6PyCafe_6CyCafe_410matchMany(((struct __pyx_obj_6PyCafe_CyCafe *)__pyx_v_self), __pyx_v_valSet, __pyx_v_handlePVMatch, __pyx_v_tolerance, __pyx_v_timeout, __pyx_v_printFlag); /* function exit code */ @@ -123685,7 +127363,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ double __pyx_t_10; __Pyx_RefNannySetupContext("matchMany", 0); - /* "PyCafe.pyx":7535 + /* "PyCafe.pyx":7742 * def matchMany(self, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag): * * cdef str _METHOD = "matchMany(list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag)" # <<<<<<<<<<<<<< @@ -123695,7 +127373,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ __Pyx_INCREF(__pyx_kp_u_matchMany_list_valSet_list_handl); __pyx_v__METHOD = __pyx_kp_u_matchMany_list_valSet_list_handl; - /* "PyCafe.pyx":7538 + /* "PyCafe.pyx":7745 * * * if (len(valSet) != len(handlePVMatch)): # <<<<<<<<<<<<<< @@ -123704,31 +127382,31 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7538, __pyx_L1_error) + __PYX_ERR(3, 7745, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7538, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7745, __pyx_L1_error) if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7538, __pyx_L1_error) + __PYX_ERR(3, 7745, __pyx_L1_error) } - __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7538, __pyx_L1_error) + __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7745, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_1 != __pyx_t_2) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7539 + /* "PyCafe.pyx":7746 * * 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!") * */ - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__139, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7539, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__134, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(3, 7539, __pyx_L1_error) + __PYX_ERR(3, 7746, __pyx_L1_error) - /* "PyCafe.pyx":7538 + /* "PyCafe.pyx":7745 * * * if (len(valSet) != len(handlePVMatch)): # <<<<<<<<<<<<<< @@ -123737,7 +127415,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":7543 + /* "PyCafe.pyx":7750 * * cdef vector[unsigned int] handleMatch * handleMatch.reserve(len(handlePVMatch)) # <<<<<<<<<<<<<< @@ -123746,12 +127424,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7543, __pyx_L1_error) + __PYX_ERR(3, 7750, __pyx_L1_error) } - __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7543, __pyx_L1_error) + __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7750, __pyx_L1_error) __pyx_v_handleMatch.reserve(__pyx_t_2); - /* "PyCafe.pyx":7546 + /* "PyCafe.pyx":7753 * * cdef vector[double] valSetV * valSetV.reserve(len(valSet)) # <<<<<<<<<<<<<< @@ -123760,12 +127438,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7546, __pyx_L1_error) + __PYX_ERR(3, 7753, __pyx_L1_error) } - __pyx_t_2 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7546, __pyx_L1_error) + __pyx_t_2 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7753, __pyx_L1_error) __pyx_v_valSetV.reserve(__pyx_t_2); - /* "PyCafe.pyx":7548 + /* "PyCafe.pyx":7755 * valSetV.reserve(len(valSet)) * * for i in range(0, len(handlePVMatch)): # <<<<<<<<<<<<<< @@ -123774,14 +127452,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7548, __pyx_L1_error) + __PYX_ERR(3, 7755, __pyx_L1_error) } - __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7548, __pyx_L1_error) + __pyx_t_2 = PyList_GET_SIZE(__pyx_v_handlePVMatch); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7755, __pyx_L1_error) __pyx_t_1 = __pyx_t_2; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_1; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":7549 + /* "PyCafe.pyx":7756 * * for i in range(0, len(handlePVMatch)): * if isinstance(handlePVMatch[i], (int, long)): # <<<<<<<<<<<<<< @@ -123790,9 +127468,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7549, __pyx_L1_error) + __PYX_ERR(3, 7756, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7549, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyInt_Check(__pyx_t_4); __pyx_t_7 = (__pyx_t_6 != 0); @@ -123809,7 +127487,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ __pyx_t_6 = (__pyx_t_3 != 0); if (__pyx_t_6) { - /* "PyCafe.pyx":7550 + /* "PyCafe.pyx":7757 * for i in range(0, len(handlePVMatch)): * if isinstance(handlePVMatch[i], (int, long)): * handleMatch.push_back(handlePVMatch[i]) # <<<<<<<<<<<<<< @@ -123818,20 +127496,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7550, __pyx_L1_error) + __PYX_ERR(3, 7757, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7550, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7550, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7757, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_handleMatch.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7550, __pyx_L1_error) + __PYX_ERR(3, 7757, __pyx_L1_error) } - /* "PyCafe.pyx":7549 + /* "PyCafe.pyx":7756 * * for i in range(0, len(handlePVMatch)): * if isinstance(handlePVMatch[i], (int, long)): # <<<<<<<<<<<<<< @@ -123841,7 +127519,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ goto __pyx_L6; } - /* "PyCafe.pyx":7551 + /* "PyCafe.pyx":7758 * if isinstance(handlePVMatch[i], (int, long)): * handleMatch.push_back(handlePVMatch[i]) * elif isinstance(handlePVMatch[i], (str)): # <<<<<<<<<<<<<< @@ -123850,35 +127528,35 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_handlePVMatch == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7551, __pyx_L1_error) + __PYX_ERR(3, 7758, __pyx_L1_error) } - __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7551, __pyx_L1_error) + __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_handlePVMatch, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyUnicode_Check(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__pyx_t_6 != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7552 + /* "PyCafe.pyx":7759 * handleMatch.push_back(handlePVMatch[i]) * elif isinstance(handlePVMatch[i], (str)): * handleMatch.push_back(self.checkForHandle(handlePVMatch)) # <<<<<<<<<<<<<< * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7552, __pyx_L1_error) - __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7552, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7759, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7759, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7552, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_unsigned_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7759, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; try { __pyx_v_handleMatch.push_back(__pyx_t_8); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7552, __pyx_L1_error) + __PYX_ERR(3, 7759, __pyx_L1_error) } - /* "PyCafe.pyx":7551 + /* "PyCafe.pyx":7758 * if isinstance(handlePVMatch[i], (int, long)): * handleMatch.push_back(handlePVMatch[i]) * elif isinstance(handlePVMatch[i], (str)): # <<<<<<<<<<<<<< @@ -123888,7 +127566,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ goto __pyx_L6; } - /* "PyCafe.pyx":7554 + /* "PyCafe.pyx":7761 * handleMatch.push_back(self.checkForHandle(handlePVMatch)) * else: * _cafeException = CafeException(_type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< @@ -123896,18 +127574,18 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ * raise _cafeException */ /*else*/ { - __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7554, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7554, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7554, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o) < 0) __PYX_ERR(3, 7554, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7554, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7761, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7761, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_error_info, __pyx_kp_u_First_input_argument_should_be_o) < 0) __PYX_ERR(3, 7761, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":7556 + /* "PyCafe.pyx":7763 * _cafeException = CafeException(_type='CafeError', _source=_METHOD, * _error_info="First input argument, should be of type if handle, else if PV") * raise _cafeException # <<<<<<<<<<<<<< @@ -123915,12 +127593,12 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ * for i in range(0, len(valSet)): */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7556, __pyx_L1_error) + __PYX_ERR(3, 7763, __pyx_L1_error) } __pyx_L6:; } - /* "PyCafe.pyx":7558 + /* "PyCafe.pyx":7765 * raise _cafeException * * for i in range(0, len(valSet)): # <<<<<<<<<<<<<< @@ -123929,14 +127607,14 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(3, 7558, __pyx_L1_error) + __PYX_ERR(3, 7765, __pyx_L1_error) } - __pyx_t_2 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7558, __pyx_L1_error) + __pyx_t_2 = PyList_GET_SIZE(__pyx_v_valSet); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(3, 7765, __pyx_L1_error) __pyx_t_1 = __pyx_t_2; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_1; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "PyCafe.pyx":7559 + /* "PyCafe.pyx":7766 * * for i in range(0, len(valSet)): * valSetV.push_back(valSet[i]) # <<<<<<<<<<<<<< @@ -123945,21 +127623,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ if (unlikely(__pyx_v_valSet == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(3, 7559, __pyx_L1_error) + __PYX_ERR(3, 7766, __pyx_L1_error) } - __pyx_t_9 = __Pyx_GetItemInt_List(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7559, __pyx_L1_error) + __pyx_t_9 = __Pyx_GetItemInt_List(__pyx_v_valSet, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7559, __pyx_L1_error) + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7766, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; try { __pyx_v_valSetV.push_back(__pyx_t_10); } catch(...) { __Pyx_CppExn2PyErr(); - __PYX_ERR(3, 7559, __pyx_L1_error) + __PYX_ERR(3, 7766, __pyx_L1_error) } } - /* "PyCafe.pyx":7563 + /* "PyCafe.pyx":7770 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -123974,7 +127652,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ #endif /*try:*/ { - /* "PyCafe.pyx":7564 + /* "PyCafe.pyx":7771 * * with nogil: * status = self._c_cafe.matchMany( # <<<<<<<<<<<<<< @@ -123984,7 +127662,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ __pyx_v_status = __pyx_v_self->_c_cafe->matchMany(__pyx_v_valSetV, __pyx_v_handleMatch, __pyx_v_tolerance, __pyx_v_timeout, __pyx_v_printFlag); } - /* "PyCafe.pyx":7563 + /* "PyCafe.pyx":7770 * cdef int status * * with nogil: # <<<<<<<<<<<<<< @@ -124003,7 +127681,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ } } - /* "PyCafe.pyx":7567 + /* "PyCafe.pyx":7774 * valSetV, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -124013,7 +127691,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ __pyx_t_3 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7568 + /* "PyCafe.pyx":7775 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -124023,7 +127701,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ __pyx_t_3 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_3) { - /* "PyCafe.pyx":7569 + /* "PyCafe.pyx":7776 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -124032,7 +127710,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":7568 + /* "PyCafe.pyx":7775 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -124041,34 +127719,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":7571 + /* "PyCafe.pyx":7778 * self._c_cafe.printStatusMessage(status) * raise Exception( * "EXCEPTION RAISED in PyCafe def matchMany. Status = %d" % status) # <<<<<<<<<<<<<< * * return status */ - __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7571, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7778, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_4 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_m_2, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7571, __pyx_L1_error) + __pyx_t_4 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_m_2, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 7778, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "PyCafe.pyx":7570 + /* "PyCafe.pyx":7777 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def matchMany. Status = %d" % status) * */ - __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7570, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7777, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_9, 0, 0, 0); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __PYX_ERR(3, 7570, __pyx_L1_error) + __PYX_ERR(3, 7777, __pyx_L1_error) - /* "PyCafe.pyx":7567 + /* "PyCafe.pyx":7774 * valSetV, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -124077,7 +127755,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ */ } - /* "PyCafe.pyx":7573 + /* "PyCafe.pyx":7780 * "EXCEPTION RAISED in PyCafe def matchMany. Status = %d" % status) * * return status # <<<<<<<<<<<<<< @@ -124085,13 +127763,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7573, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7780, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_r = __pyx_t_9; __pyx_t_9 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7533 + /* "PyCafe.pyx":7740 * ################################################################################## * * def matchMany(self, list valSet, list handlePVMatch, double tolerance, double timeout, bint printFlag): # <<<<<<<<<<<<<< @@ -124115,7 +127793,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_410matchMany(struct __pyx_obj_6PyCafe_ return __pyx_r; } -/* "PyCafe.pyx":7578 +/* "PyCafe.pyx":7785 * ############################################################################ * * def match(self, double valSet, handlePVMatch, double tolerance, double timeout, bint printFlag): # <<<<<<<<<<<<<< @@ -124163,29 +127841,29 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_413match(PyObject *__pyx_v_self, PyObj case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_handlePVMatch)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, 1); __PYX_ERR(3, 7578, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, 1); __PYX_ERR(3, 7785, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tolerance)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, 2); __PYX_ERR(3, 7578, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, 2); __PYX_ERR(3, 7785, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, 3); __PYX_ERR(3, 7578, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, 3); __PYX_ERR(3, 7785, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_printFlag)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, 4); __PYX_ERR(3, 7578, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, 4); __PYX_ERR(3, 7785, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "match") < 0)) __PYX_ERR(3, 7578, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "match") < 0)) __PYX_ERR(3, 7785, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { goto __pyx_L5_argtuple_error; @@ -124196,15 +127874,15 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_413match(PyObject *__pyx_v_self, PyObj values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); } - __pyx_v_valSet = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_valSet == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7578, __pyx_L3_error) + __pyx_v_valSet = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_valSet == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7785, __pyx_L3_error) __pyx_v_handlePVMatch = values[1]; - __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7578, __pyx_L3_error) - __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7578, __pyx_L3_error) - __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7578, __pyx_L3_error) + __pyx_v_tolerance = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_tolerance == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7785, __pyx_L3_error) + __pyx_v_timeout = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_timeout == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 7785, __pyx_L3_error) + __pyx_v_printFlag = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_printFlag == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7785, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7578, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("match", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7785, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.match", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -124234,7 +127912,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("match", 0); - /* "PyCafe.pyx":7580 + /* "PyCafe.pyx":7787 * 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)") # <<<<<<<<<<<<<< @@ -124244,7 +127922,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa __Pyx_INCREF(__pyx_kp_u_match_double_valSet_handlePVMatc); __pyx_v__METHOD = __pyx_kp_u_match_double_valSet_handlePVMatc; - /* "PyCafe.pyx":7582 + /* "PyCafe.pyx":7789 * cdef str _METHOD = ("match(double valSet, handlePVMatch, double tolerance, double timeout, bint printFlag)") * * cdef unsigned int handleMatch = 0 # <<<<<<<<<<<<<< @@ -124253,7 +127931,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa */ __pyx_v_handleMatch = 0; - /* "PyCafe.pyx":7584 + /* "PyCafe.pyx":7791 * cdef unsigned int handleMatch = 0 * * if isinstance(handlePVMatch, (int, long)): # <<<<<<<<<<<<<< @@ -124274,17 +127952,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7585 + /* "PyCafe.pyx":7792 * * if isinstance(handlePVMatch, (int, long)): * handleMatch = handlePVMatch # <<<<<<<<<<<<<< * elif isinstance(handlePVMatch, (str)): * handleMatch = self.checkForHandle(handlePVMatch) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePVMatch); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7585, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePVMatch); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7792, __pyx_L1_error) __pyx_v_handleMatch = __pyx_t_4; - /* "PyCafe.pyx":7584 + /* "PyCafe.pyx":7791 * cdef unsigned int handleMatch = 0 * * if isinstance(handlePVMatch, (int, long)): # <<<<<<<<<<<<<< @@ -124294,7 +127972,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa goto __pyx_L3; } - /* "PyCafe.pyx":7586 + /* "PyCafe.pyx":7793 * if isinstance(handlePVMatch, (int, long)): * handleMatch = handlePVMatch * elif isinstance(handlePVMatch, (str)): # <<<<<<<<<<<<<< @@ -124305,21 +127983,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7587 + /* "PyCafe.pyx":7794 * handleMatch = handlePVMatch * elif isinstance(handlePVMatch, (str)): * handleMatch = self.checkForHandle(handlePVMatch) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7587, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7587, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePVMatch))||((__pyx_v_handlePVMatch) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePVMatch)->tp_name), 0))) __PYX_ERR(3, 7794, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePVMatch), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7794, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7587, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7794, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handleMatch = __pyx_t_4; - /* "PyCafe.pyx":7586 + /* "PyCafe.pyx":7793 * if isinstance(handlePVMatch, (int, long)): * handleMatch = handlePVMatch * elif isinstance(handlePVMatch, (str)): # <<<<<<<<<<<<<< @@ -124329,7 +128007,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa goto __pyx_L3; } - /* "PyCafe.pyx":7589 + /* "PyCafe.pyx":7796 * handleMatch = self.checkForHandle(handlePVMatch) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -124337,10 +128015,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa * ("First Input argument should be of type " */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7589, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":7590 + /* "PyCafe.pyx":7797 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -124362,7 +128040,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7589, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7796, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -124370,13 +128048,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7589, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7796, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7589, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -124390,29 +128068,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa __Pyx_INCREF(__pyx_kp_u_First_Input_argument_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_First_Input_argument_should_be_o); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_Input_argument_should_be_o); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7589, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7589 + /* "PyCafe.pyx":7796 * handleMatch = self.checkForHandle(handlePVMatch) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First Input argument should be of type " */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7589, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7589, __pyx_L1_error) + __PYX_ERR(3, 7796, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":7594 + /* "PyCafe.pyx":7801 * "if handle, else if PV"))) * * cdef int status = ICAFE_NORMAL # <<<<<<<<<<<<<< @@ -124421,7 +128099,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa */ __pyx_v_status = ICAFE_NORMAL; - /* "PyCafe.pyx":7597 + /* "PyCafe.pyx":7804 * * * with nogil: # <<<<<<<<<<<<<< @@ -124436,7 +128114,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa #endif /*try:*/ { - /* "PyCafe.pyx":7598 + /* "PyCafe.pyx":7805 * * with nogil: * status = self._c_cafe.match( # <<<<<<<<<<<<<< @@ -124446,7 +128124,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa __pyx_v_status = __pyx_v_self->_c_cafe->match(__pyx_v_valSet, __pyx_v_handleMatch, __pyx_v_tolerance, __pyx_v_timeout, __pyx_v_printFlag); } - /* "PyCafe.pyx":7597 + /* "PyCafe.pyx":7804 * * * with nogil: # <<<<<<<<<<<<<< @@ -124465,7 +128143,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa } } - /* "PyCafe.pyx":7601 + /* "PyCafe.pyx":7808 * valSet, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -124475,7 +128153,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = ((__pyx_v_status != ICAFE_NORMAL) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7602 + /* "PyCafe.pyx":7809 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -124485,7 +128163,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7603 + /* "PyCafe.pyx":7810 * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) # <<<<<<<<<<<<<< @@ -124494,7 +128172,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa */ __pyx_v_self->_c_cafe->printStatusMessage(__pyx_v_status); - /* "PyCafe.pyx":7602 + /* "PyCafe.pyx":7809 * * if status != ICAFE_NORMAL: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -124503,34 +128181,34 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa */ } - /* "PyCafe.pyx":7605 + /* "PyCafe.pyx":7812 * self._c_cafe.printStatusMessage(status) * raise Exception( * "EXCEPTION RAISED in PyCafe def match. Status = %d" % status) # <<<<<<<<<<<<<< * * return status */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7605, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_m_3, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7605, __pyx_L1_error) + __pyx_t_5 = PyUnicode_Format(__pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_m_3, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7604 + /* "PyCafe.pyx":7811 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(status) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def match. Status = %d" % status) * */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7604, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7811, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7604, __pyx_L1_error) + __PYX_ERR(3, 7811, __pyx_L1_error) - /* "PyCafe.pyx":7601 + /* "PyCafe.pyx":7808 * valSet, handleMatch, tolerance, timeout, printFlag) * * if status != ICAFE_NORMAL: # <<<<<<<<<<<<<< @@ -124539,7 +128217,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa */ } - /* "PyCafe.pyx":7607 + /* "PyCafe.pyx":7814 * "EXCEPTION RAISED in PyCafe def match. Status = %d" % status) * * return status # <<<<<<<<<<<<<< @@ -124547,13 +128225,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa * return 1 */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7607, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_status); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7609 + /* "PyCafe.pyx":7816 * return status * * return 1 # <<<<<<<<<<<<<< @@ -124565,7 +128243,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa __pyx_r = __pyx_int_1; goto __pyx_L0; - /* "PyCafe.pyx":7578 + /* "PyCafe.pyx":7785 * ############################################################################ * * def match(self, double valSet, handlePVMatch, double tolerance, double timeout, bint printFlag): # <<<<<<<<<<<<<< @@ -124590,7 +128268,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_412match(struct __pyx_obj_6PyCafe_CyCa return __pyx_r; } -/* "PyCafe.pyx":7614 +/* "PyCafe.pyx":7821 * ############################################################################ * * def setNelemCtrl(self, handlePV, unsigned int nelem): # <<<<<<<<<<<<<< @@ -124629,11 +128307,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_415setNelemCtrl(PyObject *__pyx_v_self case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nelem_2)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setNelemCtrl", 1, 2, 2, 1); __PYX_ERR(3, 7614, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setNelemCtrl", 1, 2, 2, 1); __PYX_ERR(3, 7821, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNelemCtrl") < 0)) __PYX_ERR(3, 7614, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNelemCtrl") < 0)) __PYX_ERR(3, 7821, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -124642,11 +128320,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_415setNelemCtrl(PyObject *__pyx_v_self values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_handlePV = values[0]; - __pyx_v_nelem = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_nelem == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7614, __pyx_L3_error) + __pyx_v_nelem = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_nelem == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7821, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setNelemCtrl", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7614, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setNelemCtrl", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7821, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setNelemCtrl", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -124676,7 +128354,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("setNelemCtrl", 0); - /* "PyCafe.pyx":7615 + /* "PyCafe.pyx":7822 * * def setNelemCtrl(self, handlePV, unsigned int nelem): * cdef str _METHOD = "setNelemCtrl(handlePV, unsigned int nelem)" # <<<<<<<<<<<<<< @@ -124686,7 +128364,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_kp_u_setNelemCtrl_handlePV_unsigned_i); __pyx_v__METHOD = __pyx_kp_u_setNelemCtrl_handlePV_unsigned_i; - /* "PyCafe.pyx":7617 + /* "PyCafe.pyx":7824 * cdef str _METHOD = "setNelemCtrl(handlePV, unsigned int nelem)" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -124695,7 +128373,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa */ __pyx_v_handle = 0; - /* "PyCafe.pyx":7618 + /* "PyCafe.pyx":7825 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -124716,17 +128394,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7619 + /* "PyCafe.pyx":7826 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7619, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7826, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7618 + /* "PyCafe.pyx":7825 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -124736,7 +128414,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa goto __pyx_L3; } - /* "PyCafe.pyx":7620 + /* "PyCafe.pyx":7827 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -124747,21 +128425,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7621 + /* "PyCafe.pyx":7828 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7621, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7621, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7828, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7621, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7828, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7620 + /* "PyCafe.pyx":7827 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -124771,7 +128449,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa goto __pyx_L3; } - /* "PyCafe.pyx":7623 + /* "PyCafe.pyx":7830 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -124779,10 +128457,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa * ("First Input argument should be of type " */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7623, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":7624 + /* "PyCafe.pyx":7831 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -124804,7 +128482,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7623, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7830, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -124812,13 +128490,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7623, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7830, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7623, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -124832,29 +128510,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa __Pyx_INCREF(__pyx_kp_u_First_Input_argument_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_First_Input_argument_should_be_o); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_Input_argument_should_be_o); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7623, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7623 + /* "PyCafe.pyx":7830 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First Input argument should be of type " */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7623, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7623, __pyx_L1_error) + __PYX_ERR(3, 7830, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":7628 + /* "PyCafe.pyx":7835 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -124864,7 +128542,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7629 + /* "PyCafe.pyx":7836 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -124874,7 +128552,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7630 + /* "PyCafe.pyx":7837 * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) # <<<<<<<<<<<<<< @@ -124883,7 +128561,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa */ __pyx_v_self->_c_cafe->printStatusMessage(ECAFE_INVALID_HANDLE); - /* "PyCafe.pyx":7629 + /* "PyCafe.pyx":7836 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -124892,60 +128570,60 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":7632 + /* "PyCafe.pyx":7839 * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _error_code=ECAFE_INVALID_HANDLE, # <<<<<<<<<<<<<< * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7632, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7839, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7632, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7632, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_CAFE_ERROR_STATE(ECAFE_INVALID_HANDLE); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7632, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7839, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7839, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_CAFE_ERROR_STATE(ECAFE_INVALID_HANDLE); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7839, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 7632, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 7839, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7633 + /* "PyCafe.pyx":7840 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _error_code=ECAFE_INVALID_HANDLE, * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), # <<<<<<<<<<<<<< * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) * raise _cafeException */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7633, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7840, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 7632, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 7839, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7634 + /* "PyCafe.pyx":7841 * _type='CafeError', _source=_METHOD, _error_code=ECAFE_INVALID_HANDLE, * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7634, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7841, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 7632, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 7839, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7631 + /* "PyCafe.pyx":7838 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _error_code=ECAFE_INVALID_HANDLE, * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7631, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7838, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7635 + /* "PyCafe.pyx":7842 * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) * raise _cafeException # <<<<<<<<<<<<<< @@ -124953,9 +128631,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa * # returns nelem */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7635, __pyx_L1_error) + __PYX_ERR(3, 7842, __pyx_L1_error) - /* "PyCafe.pyx":7628 + /* "PyCafe.pyx":7835 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -124964,7 +128642,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa */ } - /* "PyCafe.pyx":7638 + /* "PyCafe.pyx":7845 * * # returns nelem * return self.hh.setNelemCtrl(handle, nelem) # <<<<<<<<<<<<<< @@ -124972,13 +128650,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa * ################################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.setNelemCtrl(__pyx_v_handle, __pyx_v_nelem)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7638, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.setNelemCtrl(__pyx_v_handle, __pyx_v_nelem)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7614 + /* "PyCafe.pyx":7821 * ############################################################################ * * def setNelemCtrl(self, handlePV, unsigned int nelem): # <<<<<<<<<<<<<< @@ -125004,7 +128682,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_414setNelemCtrl(struct __pyx_obj_6PyCa return __pyx_r; } -/* "PyCafe.pyx":7642 +/* "PyCafe.pyx":7849 * ################################################################################## * * def setNelem(self, handlePV, unsigned int nelem): # <<<<<<<<<<<<<< @@ -125043,11 +128721,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_417setNelem(PyObject *__pyx_v_self, Py case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nelem_2)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setNelem", 1, 2, 2, 1); __PYX_ERR(3, 7642, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setNelem", 1, 2, 2, 1); __PYX_ERR(3, 7849, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNelem") < 0)) __PYX_ERR(3, 7642, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNelem") < 0)) __PYX_ERR(3, 7849, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -125056,11 +128734,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_417setNelem(PyObject *__pyx_v_self, Py values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_handlePV = values[0]; - __pyx_v_nelem = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_nelem == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7642, __pyx_L3_error) + __pyx_v_nelem = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_nelem == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7849, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setNelem", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7642, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setNelem", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7849, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setNelem", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -125090,7 +128768,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("setNelem", 0); - /* "PyCafe.pyx":7643 + /* "PyCafe.pyx":7850 * * def setNelem(self, handlePV, unsigned int nelem): * cdef str _METHOD = "setNelem" # <<<<<<<<<<<<<< @@ -125100,7 +128778,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_n_u_setNelem); __pyx_v__METHOD = __pyx_n_u_setNelem; - /* "PyCafe.pyx":7645 + /* "PyCafe.pyx":7852 * cdef str _METHOD = "setNelem" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -125109,7 +128787,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C */ __pyx_v_handle = 0; - /* "PyCafe.pyx":7646 + /* "PyCafe.pyx":7853 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -125130,17 +128808,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7647 + /* "PyCafe.pyx":7854 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7647, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7854, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7646 + /* "PyCafe.pyx":7853 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -125150,7 +128828,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C goto __pyx_L3; } - /* "PyCafe.pyx":7648 + /* "PyCafe.pyx":7855 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -125161,21 +128839,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7649 + /* "PyCafe.pyx":7856 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7649, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7649, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7856, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7649, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7856, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7648 + /* "PyCafe.pyx":7855 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -125185,7 +128863,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C goto __pyx_L3; } - /* "PyCafe.pyx":7651 + /* "PyCafe.pyx":7858 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -125193,10 +128871,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C * ("First Input argument should be of type " */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7651, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7858, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":7652 + /* "PyCafe.pyx":7859 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -125218,7 +128896,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7651, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7858, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -125226,13 +128904,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7651, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7858, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7651, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7858, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -125246,29 +128924,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C __Pyx_INCREF(__pyx_kp_u_First_Input_argument_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_First_Input_argument_should_be_o); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_Input_argument_should_be_o); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7651, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7858, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7651 + /* "PyCafe.pyx":7858 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First Input argument should be of type " */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7651, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7858, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7651, __pyx_L1_error) + __PYX_ERR(3, 7858, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":7656 + /* "PyCafe.pyx":7863 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -125278,7 +128956,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7657 + /* "PyCafe.pyx":7864 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -125288,7 +128966,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7658 + /* "PyCafe.pyx":7865 * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) # <<<<<<<<<<<<<< @@ -125297,7 +128975,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C */ __pyx_v_self->_c_cafe->printStatusMessage(ECAFE_INVALID_HANDLE); - /* "PyCafe.pyx":7657 + /* "PyCafe.pyx":7864 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -125306,60 +128984,60 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":7660 + /* "PyCafe.pyx":7867 * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _error_code=ECAFE_INVALID_HANDLE, # <<<<<<<<<<<<<< * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7660, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7867, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7660, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7660, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyInt_From_CAFE_ERROR_STATE(ECAFE_INVALID_HANDLE); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7660, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7867, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7867, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_CAFE_ERROR_STATE(ECAFE_INVALID_HANDLE); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7867, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 7660, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 7867, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7661 + /* "PyCafe.pyx":7868 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, _error_code=ECAFE_INVALID_HANDLE, * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), # <<<<<<<<<<<<<< * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) * raise _cafeException */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7661, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7868, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 7660, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 7867, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7662 + /* "PyCafe.pyx":7869 * _type='CafeError', _source=_METHOD, _error_code=ECAFE_INVALID_HANDLE, * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7662, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7869, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 7660, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 7867, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7659 + /* "PyCafe.pyx":7866 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, _error_code=ECAFE_INVALID_HANDLE, * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7659, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7663 + /* "PyCafe.pyx":7870 * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) * raise _cafeException # <<<<<<<<<<<<<< @@ -125367,9 +129045,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C * */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7663, __pyx_L1_error) + __PYX_ERR(3, 7870, __pyx_L1_error) - /* "PyCafe.pyx":7656 + /* "PyCafe.pyx":7863 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -125378,7 +129056,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C */ } - /* "PyCafe.pyx":7667 + /* "PyCafe.pyx":7874 * * # returns nelem * return self.hh.setNelem(handle, nelem) # <<<<<<<<<<<<<< @@ -125386,13 +129064,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C * ############################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.setNelem(__pyx_v_handle, __pyx_v_nelem)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7667, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.setNelem(__pyx_v_handle, __pyx_v_nelem)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7874, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7642 + /* "PyCafe.pyx":7849 * ################################################################################## * * def setNelem(self, handlePV, unsigned int nelem): # <<<<<<<<<<<<<< @@ -125418,7 +129096,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_416setNelem(struct __pyx_obj_6PyCafe_C return __pyx_r; } -/* "PyCafe.pyx":7670 +/* "PyCafe.pyx":7877 * * ############################################################################ * def setNelemToNative(self, handlePV): # <<<<<<<<<<<<<< @@ -125456,7 +129134,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("setNelemToNative", 0); - /* "PyCafe.pyx":7671 + /* "PyCafe.pyx":7878 * ############################################################################ * def setNelemToNative(self, handlePV): * cdef str _METHOD = "setNelemToNative" # <<<<<<<<<<<<<< @@ -125466,7 +129144,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 __Pyx_INCREF(__pyx_n_u_setNelemToNative); __pyx_v__METHOD = __pyx_n_u_setNelemToNative; - /* "PyCafe.pyx":7673 + /* "PyCafe.pyx":7880 * cdef str _METHOD = "setNelemToNative" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -125475,7 +129153,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 */ __pyx_v_handle = 0; - /* "PyCafe.pyx":7674 + /* "PyCafe.pyx":7881 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -125496,17 +129174,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7675 + /* "PyCafe.pyx":7882 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7675, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7882, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7674 + /* "PyCafe.pyx":7881 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -125516,7 +129194,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 goto __pyx_L3; } - /* "PyCafe.pyx":7676 + /* "PyCafe.pyx":7883 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -125527,21 +129205,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7677 + /* "PyCafe.pyx":7884 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7677, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7677, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7884, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7677, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7676 + /* "PyCafe.pyx":7883 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -125551,7 +129229,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 goto __pyx_L3; } - /* "PyCafe.pyx":7679 + /* "PyCafe.pyx":7886 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -125559,10 +129237,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 * ("First Input argument should be of type " */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7679, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":7680 + /* "PyCafe.pyx":7887 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -125584,7 +129262,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7679, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7886, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -125592,13 +129270,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7679, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7886, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7679, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -125612,29 +129290,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 __Pyx_INCREF(__pyx_kp_u_First_Input_argument_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_First_Input_argument_should_be_o); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_Input_argument_should_be_o); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7679, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7679 + /* "PyCafe.pyx":7886 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First Input argument should be of type " */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7679, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7679, __pyx_L1_error) + __PYX_ERR(3, 7886, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":7684 + /* "PyCafe.pyx":7891 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -125644,7 +129322,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7685 + /* "PyCafe.pyx":7892 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -125654,7 +129332,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7686 + /* "PyCafe.pyx":7893 * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) # <<<<<<<<<<<<<< @@ -125663,7 +129341,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 */ __pyx_v_self->_c_cafe->printStatusMessage(ECAFE_INVALID_HANDLE); - /* "PyCafe.pyx":7685 + /* "PyCafe.pyx":7892 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -125672,68 +129350,68 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 */ } - /* "PyCafe.pyx":7688 + /* "PyCafe.pyx":7895 * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, # <<<<<<<<<<<<<< * _error_code=ECAFE_INVALID_HANDLE, * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7688, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7688, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7688, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_type, __pyx_n_u_CafeError) < 0) __PYX_ERR(3, 7895, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_source, __pyx_v__METHOD) < 0) __PYX_ERR(3, 7895, __pyx_L1_error) - /* "PyCafe.pyx":7689 + /* "PyCafe.pyx":7896 * _cafeException = CafeException( * _type='CafeError', _source=_METHOD, * _error_code=ECAFE_INVALID_HANDLE, # <<<<<<<<<<<<<< * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) */ - __pyx_t_5 = __Pyx_PyInt_From_CAFE_ERROR_STATE(ECAFE_INVALID_HANDLE); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7689, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_CAFE_ERROR_STATE(ECAFE_INVALID_HANDLE); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 7688, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_code, __pyx_t_5) < 0) __PYX_ERR(3, 7895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7690 + /* "PyCafe.pyx":7897 * _type='CafeError', _source=_METHOD, * _error_code=ECAFE_INVALID_HANDLE, * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), # <<<<<<<<<<<<<< * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) * raise _cafeException */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7690, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.code(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 7688, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_text, __pyx_t_5) < 0) __PYX_ERR(3, 7895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7691 + /* "PyCafe.pyx":7898 * _error_code=ECAFE_INVALID_HANDLE, * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) # <<<<<<<<<<<<<< * raise _cafeException * */ - __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7691, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_PyStr_string_to_py_std__in_string(__pyx_v_self->cs.info(ECAFE_INVALID_HANDLE)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 7688, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_error_info, __pyx_t_5) < 0) __PYX_ERR(3, 7895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7687 + /* "PyCafe.pyx":7894 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * _cafeException = CafeException( # <<<<<<<<<<<<<< * _type='CafeError', _source=_METHOD, * _error_code=ECAFE_INVALID_HANDLE, */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7687, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6PyCafe_CafeException), __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v__cafeException = ((struct __pyx_obj_6PyCafe_CafeException *)__pyx_t_5); __pyx_t_5 = 0; - /* "PyCafe.pyx":7692 + /* "PyCafe.pyx":7899 * _error_text=self.cs.code(ECAFE_INVALID_HANDLE), * _error_info=self.cs.info(ECAFE_INVALID_HANDLE)) * raise _cafeException # <<<<<<<<<<<<<< @@ -125741,9 +129419,9 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 * # returns nelem */ __Pyx_Raise(((PyObject *)__pyx_v__cafeException), 0, 0, 0); - __PYX_ERR(3, 7692, __pyx_L1_error) + __PYX_ERR(3, 7899, __pyx_L1_error) - /* "PyCafe.pyx":7684 + /* "PyCafe.pyx":7891 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -125752,7 +129430,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 */ } - /* "PyCafe.pyx":7695 + /* "PyCafe.pyx":7902 * * # returns nelem * return self.hh.setNelemToNative(handle) # <<<<<<<<<<<<<< @@ -125760,13 +129438,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 * ############################################################################## */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.setNelemToNative(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7695, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->hh.setNelemToNative(__pyx_v_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7902, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7670 + /* "PyCafe.pyx":7877 * * ############################################################################ * def setNelemToNative(self, handlePV): # <<<<<<<<<<<<<< @@ -125792,7 +129470,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_418setNelemToNative(struct __pyx_obj_6 return __pyx_r; } -/* "PyCafe.pyx":7699 +/* "PyCafe.pyx":7906 * ############################################################################## * * def setNelemToRetrieveFromCacheToOne(self, handlePV): # <<<<<<<<<<<<<< @@ -125829,7 +129507,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("setNelemToRetrieveFromCacheToOne", 0); - /* "PyCafe.pyx":7700 + /* "PyCafe.pyx":7907 * * def setNelemToRetrieveFromCacheToOne(self, handlePV): * cdef str _METHOD = "setNelemToRetrieveFromCacheToOne" # <<<<<<<<<<<<<< @@ -125839,7 +129517,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st __Pyx_INCREF(__pyx_n_u_setNelemToRetrieveFromCacheToOne); __pyx_v__METHOD = __pyx_n_u_setNelemToRetrieveFromCacheToOne; - /* "PyCafe.pyx":7702 + /* "PyCafe.pyx":7909 * cdef str _METHOD = "setNelemToRetrieveFromCacheToOne" * * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -125848,7 +129526,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st */ __pyx_v_handle = 0; - /* "PyCafe.pyx":7703 + /* "PyCafe.pyx":7910 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -125869,17 +129547,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7704 + /* "PyCafe.pyx":7911 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7704, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7911, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7703 + /* "PyCafe.pyx":7910 * * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -125889,7 +129567,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st goto __pyx_L3; } - /* "PyCafe.pyx":7705 + /* "PyCafe.pyx":7912 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -125900,21 +129578,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7706 + /* "PyCafe.pyx":7913 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7706, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7706, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7913, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7706, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7913, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7705 + /* "PyCafe.pyx":7912 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -125924,7 +129602,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st goto __pyx_L3; } - /* "PyCafe.pyx":7708 + /* "PyCafe.pyx":7915 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -125932,10 +129610,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st * ("First Input argument should be of type " */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7708, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7915, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":7709 + /* "PyCafe.pyx":7916 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -125957,7 +129635,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7708, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7915, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -125965,13 +129643,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7708, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7915, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7708, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7915, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -125985,29 +129663,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st __Pyx_INCREF(__pyx_kp_u_First_Input_argument_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_First_Input_argument_should_be_o); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_Input_argument_should_be_o); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7708, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7915, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7708 + /* "PyCafe.pyx":7915 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First Input argument should be of type " */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7708, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7915, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7708, __pyx_L1_error) + __PYX_ERR(3, 7915, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":7713 + /* "PyCafe.pyx":7920 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -126017,7 +129695,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7714 + /* "PyCafe.pyx":7921 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -126027,7 +129705,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7715 + /* "PyCafe.pyx":7922 * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) # <<<<<<<<<<<<<< @@ -126036,7 +129714,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st */ __pyx_v_self->_c_cafe->printStatusMessage(ECAFE_INVALID_HANDLE); - /* "PyCafe.pyx":7714 + /* "PyCafe.pyx":7921 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -126045,20 +129723,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st */ } - /* "PyCafe.pyx":7716 + /* "PyCafe.pyx":7923 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def setNelemToRetrieveFromCacheToOne") * */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__140, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7716, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__135, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7923, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7716, __pyx_L1_error) + __PYX_ERR(3, 7923, __pyx_L1_error) - /* "PyCafe.pyx":7713 + /* "PyCafe.pyx":7920 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -126067,7 +129745,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st */ } - /* "PyCafe.pyx":7720 + /* "PyCafe.pyx":7927 * * # returns previous nelem * return self._c_cafe.setNelemToRetrieveFromCacheToOne(handle) # <<<<<<<<<<<<<< @@ -126075,13 +129753,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st * ################################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->setNelemToRetrieveFromCacheToOne(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7720, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->setNelemToRetrieveFromCacheToOne(__pyx_v_handle)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7927, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7699 + /* "PyCafe.pyx":7906 * ############################################################################## * * def setNelemToRetrieveFromCacheToOne(self, handlePV): # <<<<<<<<<<<<<< @@ -126106,7 +129784,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_420setNelemToRetrieveFromCacheToOne(st return __pyx_r; } -/* "PyCafe.pyx":7723 +/* "PyCafe.pyx":7930 * * ################################################################################ * def setNelemToRetrieveFromCache(self, handlePV, int netrfc): # <<<<<<<<<<<<<< @@ -126145,11 +129823,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_423setNelemToRetrieveFromCache(PyObjec case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_netrfc)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("setNelemToRetrieveFromCache", 1, 2, 2, 1); __PYX_ERR(3, 7723, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setNelemToRetrieveFromCache", 1, 2, 2, 1); __PYX_ERR(3, 7930, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNelemToRetrieveFromCache") < 0)) __PYX_ERR(3, 7723, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNelemToRetrieveFromCache") < 0)) __PYX_ERR(3, 7930, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -126158,11 +129836,11 @@ static PyObject *__pyx_pw_6PyCafe_6CyCafe_423setNelemToRetrieveFromCache(PyObjec values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_handlePV = values[0]; - __pyx_v_netrfc = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_netrfc == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7723, __pyx_L3_error) + __pyx_v_netrfc = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_netrfc == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7930, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("setNelemToRetrieveFromCache", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7723, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("setNelemToRetrieveFromCache", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 7930, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("PyCafe.CyCafe.setNelemToRetrieveFromCache", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -126191,7 +129869,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("setNelemToRetrieveFromCache", 0); - /* "PyCafe.pyx":7724 + /* "PyCafe.pyx":7931 * ################################################################################ * def setNelemToRetrieveFromCache(self, handlePV, int netrfc): * cdef str _METHOD="etNelemToRetrieveFromCache" # <<<<<<<<<<<<<< @@ -126201,7 +129879,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct __Pyx_INCREF(__pyx_n_u_etNelemToRetrieveFromCache); __pyx_v__METHOD = __pyx_n_u_etNelemToRetrieveFromCache; - /* "PyCafe.pyx":7725 + /* "PyCafe.pyx":7932 * def setNelemToRetrieveFromCache(self, handlePV, int netrfc): * cdef str _METHOD="etNelemToRetrieveFromCache" * cdef unsigned int handle = 0 # <<<<<<<<<<<<<< @@ -126210,7 +129888,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct */ __pyx_v_handle = 0; - /* "PyCafe.pyx":7726 + /* "PyCafe.pyx":7933 * cdef str _METHOD="etNelemToRetrieveFromCache" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -126231,17 +129909,17 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "PyCafe.pyx":7727 + /* "PyCafe.pyx":7934 * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): * handle = handlePV # <<<<<<<<<<<<<< * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) */ - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7727, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_handlePV); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7934, __pyx_L1_error) __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7726 + /* "PyCafe.pyx":7933 * cdef str _METHOD="etNelemToRetrieveFromCache" * cdef unsigned int handle = 0 * if isinstance(handlePV, (int, long)): # <<<<<<<<<<<<<< @@ -126251,7 +129929,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct goto __pyx_L3; } - /* "PyCafe.pyx":7728 + /* "PyCafe.pyx":7935 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -126262,21 +129940,21 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7729 + /* "PyCafe.pyx":7936 * handle = handlePV * elif isinstance(handlePV, (str)): * handle = self.checkForHandle(handlePV) # <<<<<<<<<<<<<< * else: * raise TypeError("{} {} \n{}".format( */ - if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7729, __pyx_L1_error) - __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7729, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_v_handlePV))||((__pyx_v_handlePV) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_v_handlePV)->tp_name), 0))) __PYX_ERR(3, 7936, __pyx_L1_error) + __pyx_t_5 = ((struct __pyx_vtabstruct_6PyCafe_CyCafe *)__pyx_v_self->__pyx_vtab)->checkForHandle(__pyx_v_self, ((PyObject*)__pyx_v_handlePV), 0, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7936, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7729, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_t_5); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(3, 7936, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_handle = __pyx_t_4; - /* "PyCafe.pyx":7728 + /* "PyCafe.pyx":7935 * if isinstance(handlePV, (int, long)): * handle = handlePV * elif isinstance(handlePV, (str)): # <<<<<<<<<<<<<< @@ -126286,7 +129964,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct goto __pyx_L3; } - /* "PyCafe.pyx":7731 + /* "PyCafe.pyx":7938 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< @@ -126294,10 +129972,10 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct * ("First Input argument should be of type " */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7731, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__37, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7938, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "PyCafe.pyx":7732 + /* "PyCafe.pyx":7939 * else: * raise TypeError("{} {} \n{}".format( * self._exception_text, _METHOD, # <<<<<<<<<<<<<< @@ -126319,7 +129997,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7731, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7938, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -126327,13 +130005,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_self->_exception_text, __pyx_v__METHOD, __pyx_kp_u_First_Input_argument_should_be_o}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7731, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7938, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7731, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 7938, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -126347,29 +130025,29 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct __Pyx_INCREF(__pyx_kp_u_First_Input_argument_should_be_o); __Pyx_GIVEREF(__pyx_kp_u_First_Input_argument_should_be_o); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_kp_u_First_Input_argument_should_be_o); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7731, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 7938, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "PyCafe.pyx":7731 + /* "PyCafe.pyx":7938 * handle = self.checkForHandle(handlePV) * else: * raise TypeError("{} {} \n{}".format( # <<<<<<<<<<<<<< * self._exception_text, _METHOD, * ("First Input argument should be of type " */ - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7731, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7938, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7731, __pyx_L1_error) + __PYX_ERR(3, 7938, __pyx_L1_error) } __pyx_L3:; - /* "PyCafe.pyx":7736 + /* "PyCafe.pyx":7943 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -126379,7 +130057,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct __pyx_t_1 = ((__pyx_v_handle == 0) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7737 + /* "PyCafe.pyx":7944 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -126389,7 +130067,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct __pyx_t_1 = ((__pyx_v_6PyCafe_PYCAFE_PRINT_LEVEL >= __pyx_v_6PyCafe_PYCAFE_PRINT_LOW) != 0); if (__pyx_t_1) { - /* "PyCafe.pyx":7738 + /* "PyCafe.pyx":7945 * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) # <<<<<<<<<<<<<< @@ -126398,7 +130076,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct */ __pyx_v_self->_c_cafe->printStatusMessage(ECAFE_INVALID_HANDLE); - /* "PyCafe.pyx":7737 + /* "PyCafe.pyx":7944 * * if handle == 0: * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: # <<<<<<<<<<<<<< @@ -126407,20 +130085,20 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct */ } - /* "PyCafe.pyx":7739 + /* "PyCafe.pyx":7946 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def setNelemToRetrieveFromCacheToOne") * */ - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__140, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7739, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__135, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7946, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(3, 7739, __pyx_L1_error) + __PYX_ERR(3, 7946, __pyx_L1_error) - /* "PyCafe.pyx":7736 + /* "PyCafe.pyx":7943 * "if handle, else if PV"))) * * if handle == 0: # <<<<<<<<<<<<<< @@ -126429,7 +130107,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct */ } - /* "PyCafe.pyx":7743 + /* "PyCafe.pyx":7950 * * # returns new nelem * return self._c_cafe.setNelemToRetrieveFromCacheToPrevious(handle, netrfc) # <<<<<<<<<<<<<< @@ -126437,13 +130115,13 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct * ################################################################################ */ __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->setNelemToRetrieveFromCacheToPrevious(__pyx_v_handle, __pyx_v_netrfc)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7743, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_self->_c_cafe->setNelemToRetrieveFromCacheToPrevious(__pyx_v_handle, __pyx_v_netrfc)); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 7950, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "PyCafe.pyx":7723 + /* "PyCafe.pyx":7930 * * ################################################################################ * def setNelemToRetrieveFromCache(self, handlePV, int netrfc): # <<<<<<<<<<<<<< @@ -126468,7 +130146,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_422setNelemToRetrieveFromCache(struct return __pyx_r; } -/* "PyCafe.pyx":7747 +/* "PyCafe.pyx":7954 * ################################################################################ * * def terminate(self): # <<<<<<<<<<<<<< @@ -126494,7 +130172,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_424terminate(struct __pyx_obj_6PyCafe_ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("terminate", 0); - /* "PyCafe.pyx":7748 + /* "PyCafe.pyx":7955 * * def terminate(self): * with nogil: # <<<<<<<<<<<<<< @@ -126509,7 +130187,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_424terminate(struct __pyx_obj_6PyCafe_ #endif /*try:*/ { - /* "PyCafe.pyx":7749 + /* "PyCafe.pyx":7956 * def terminate(self): * with nogil: * self._c_cafe.terminate() # <<<<<<<<<<<<<< @@ -126519,7 +130197,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_424terminate(struct __pyx_obj_6PyCafe_ (void)(__pyx_v_self->_c_cafe->terminate()); } - /* "PyCafe.pyx":7748 + /* "PyCafe.pyx":7955 * * def terminate(self): * with nogil: # <<<<<<<<<<<<<< @@ -126538,7 +130216,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_424terminate(struct __pyx_obj_6PyCafe_ } } - /* "PyCafe.pyx":7750 + /* "PyCafe.pyx":7957 * with nogil: * self._c_cafe.terminate() * return # <<<<<<<<<<<<<< @@ -126549,7 +130227,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_424terminate(struct __pyx_obj_6PyCafe_ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "PyCafe.pyx":7747 + /* "PyCafe.pyx":7954 * ################################################################################ * * def terminate(self): # <<<<<<<<<<<<<< @@ -126596,7 +130274,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_426__reduce_cython__(CYTHON_UNUSED str * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__141, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__136, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -126652,7 +130330,7 @@ static PyObject *__pyx_pf_6PyCafe_6CyCafe_428__setstate_cython__(CYTHON_UNUSED s * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__142, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__137, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -127137,7 +130815,7 @@ static PyObject *__pyx_f_6PyCafe___pyx_unpickle_CafeException__set_state(struct return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< @@ -127186,7 +130864,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 * * cdef int i, ndim * cdef int endian_detector = 1 # <<<<<<<<<<<<<< @@ -127195,7 +130873,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_endian_detector = 1; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 * cdef int i, ndim * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< @@ -127204,7 +130882,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 * cdef bint little_endian = ((&endian_detector)[0] != 0) * * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< @@ -127213,7 +130891,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< @@ -127227,7 +130905,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P goto __pyx_L4_bool_binop_done; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< @@ -127238,7 +130916,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< @@ -127247,20 +130925,20 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ if (__pyx_t_1) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__143, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 272, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__138, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(4, 272, __pyx_L1_error) - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< @@ -127269,7 +130947,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< @@ -127283,7 +130961,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P goto __pyx_L7_bool_binop_done; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< @@ -127294,7 +130972,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< @@ -127303,20 +130981,20 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ if (__pyx_t_1) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__144, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 276, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__139, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(4, 276, __pyx_L1_error) - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< @@ -127325,7 +131003,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 * raise ValueError(u"ndarray is not Fortran contiguous") * * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< @@ -127334,7 +131012,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 * * info.buf = PyArray_DATA(self) * info.ndim = ndim # <<<<<<<<<<<<<< @@ -127343,7 +131021,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->ndim = __pyx_v_ndim; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< @@ -127353,7 +131031,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< @@ -127362,7 +131040,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim # <<<<<<<<<<<<<< @@ -127371,7 +131049,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim * for i in range(ndim): # <<<<<<<<<<<<<< @@ -127383,7 +131061,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 * info.shape = info.strides + ndim * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< @@ -127392,7 +131070,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< @@ -127402,7 +131080,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< @@ -127412,7 +131090,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P goto __pyx_L9; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 * info.shape[i] = PyArray_DIMS(self)[i] * else: * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< @@ -127422,7 +131100,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P /*else*/ { __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 * else: * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< @@ -127433,7 +131111,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P } __pyx_L9:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL # <<<<<<<<<<<<<< @@ -127442,7 +131120,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->suboffsets = NULL; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< @@ -127451,7 +131129,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< @@ -127460,7 +131138,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 * * cdef int t * cdef char* f = NULL # <<<<<<<<<<<<<< @@ -127469,7 +131147,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_f = NULL; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 * cdef int t * cdef char* f = NULL * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< @@ -127482,7 +131160,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); __pyx_t_3 = 0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 * cdef int offset * * info.obj = self # <<<<<<<<<<<<<< @@ -127495,7 +131173,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< @@ -127505,7 +131183,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); if (__pyx_t_1) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 * * if not PyDataType_HASFIELDS(descr): * t = descr.type_num # <<<<<<<<<<<<<< @@ -127515,7 +131193,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_4 = __pyx_v_descr->type_num; __pyx_v_t = __pyx_t_4; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -127535,7 +131213,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P } __pyx_L15_next_or:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< @@ -127552,7 +131230,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_1 = __pyx_t_2; __pyx_L14_bool_binop_done:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -127561,20 +131239,20 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ if (__pyx_t_1) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__145, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 306, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__140, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(4, 306, __pyx_L1_error) - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -127583,7 +131261,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< @@ -127596,7 +131274,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_UBYTE: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< @@ -127607,7 +131285,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_SHORT: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< @@ -127618,7 +131296,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_USHORT: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< @@ -127629,7 +131307,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_INT: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< @@ -127640,7 +131318,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_UINT: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< @@ -127651,7 +131329,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_LONG: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< @@ -127662,7 +131340,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_ULONG: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< @@ -127673,7 +131351,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_LONGLONG: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< @@ -127684,7 +131362,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_ULONGLONG: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< @@ -127695,7 +131373,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_FLOAT: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< @@ -127706,7 +131384,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_DOUBLE: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< @@ -127717,7 +131395,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_LONGDOUBLE: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< @@ -127728,7 +131406,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_CFLOAT: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< @@ -127739,7 +131417,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_CDOUBLE: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< @@ -127750,7 +131428,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_CLONGDOUBLE: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< @@ -127761,7 +131439,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; case NPY_OBJECT: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< @@ -127772,7 +131450,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; default: - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 * elif t == NPY_OBJECT: f = "O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< @@ -127793,7 +131471,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f # <<<<<<<<<<<<<< @@ -127802,7 +131480,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->format = __pyx_v_f; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f * return # <<<<<<<<<<<<<< @@ -127812,7 +131490,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_r = 0; goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< @@ -127822,7 +131500,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P goto __pyx_L12; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 * return * else: * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< @@ -127832,7 +131510,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P /*else*/ { __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 * else: * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< @@ -127841,7 +131519,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ (__pyx_v_info->format[0]) = '^'; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 # <<<<<<<<<<<<<< @@ -127850,7 +131528,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_offset = 0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< @@ -127860,7 +131538,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(4, 332, __pyx_L1_error) __pyx_v_f = __pyx_t_9; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 * info.format + _buffer_format_string_len, * &offset) * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< @@ -127871,7 +131549,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P } __pyx_L12:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< @@ -127903,7 +131581,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< @@ -127927,7 +131605,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s int __pyx_t_1; __Pyx_RefNannySetupContext("__releasebuffer__", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< @@ -127937,7 +131615,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); if (__pyx_t_1) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) # <<<<<<<<<<<<<< @@ -127946,7 +131624,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s */ PyObject_Free(__pyx_v_info->format); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< @@ -127955,7 +131633,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s */ } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< @@ -127965,7 +131643,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) # <<<<<<<<<<<<<< @@ -127974,7 +131652,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s */ PyObject_Free(__pyx_v_info->strides); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< @@ -127983,7 +131661,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s */ } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< @@ -127995,7 +131673,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s __Pyx_RefNannyFinishContext(); } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -128009,7 +131687,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< @@ -128023,7 +131701,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -128044,7 +131722,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -128058,7 +131736,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":825 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":825 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< @@ -128072,7 +131750,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -128093,7 +131771,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -128107,7 +131785,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< @@ -128121,7 +131799,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -128142,7 +131820,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -128156,7 +131834,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< @@ -128170,7 +131848,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -128191,7 +131869,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -128205,7 +131883,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< @@ -128219,7 +131897,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -128240,7 +131918,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -128254,7 +131932,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -128264,7 +131942,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< @@ -128276,7 +131954,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -128286,7 +131964,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ goto __pyx_L3; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< @@ -128301,7 +131979,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ } __pyx_L3:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -128317,7 +131995,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< @@ -128346,7 +132024,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx char *__pyx_t_9; __Pyx_RefNannySetupContext("_util_dtypestring", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 * * cdef dtype child * cdef int endian_detector = 1 # <<<<<<<<<<<<<< @@ -128355,7 +132033,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_endian_detector = 1; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":848 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":848 * cdef dtype child * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< @@ -128364,7 +132042,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< @@ -128387,7 +132065,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); __pyx_t_3 = 0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 * * for childname in descr.names: * fields = descr.fields[childname] # <<<<<<<<<<<<<< @@ -128404,7 +132082,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":853 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":853 * for childname in descr.names: * fields = descr.fields[childname] * child, new_offset = fields # <<<<<<<<<<<<<< @@ -128439,7 +132117,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); __pyx_t_4 = 0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< @@ -128456,20 +132134,20 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); if (__pyx_t_6) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__146, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 856, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__141, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(4, 856, __pyx_L1_error) - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< @@ -128478,7 +132156,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -128498,7 +132176,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx } __pyx_L8_next_or:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 * * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< @@ -128515,7 +132193,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_6 = __pyx_t_7; __pyx_L7_bool_binop_done:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -128524,20 +132202,20 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ if (__pyx_t_6) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":860 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":860 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__145, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 860, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__140, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(4, 860, __pyx_L1_error) - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -128546,7 +132224,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 * * # Output padding bytes * while offset[0] < new_offset: # <<<<<<<<<<<<<< @@ -128562,7 +132240,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) break; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 * # Output padding bytes * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< @@ -128571,7 +132249,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ (__pyx_v_f[0]) = 0x78; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte * f += 1 # <<<<<<<<<<<<<< @@ -128580,7 +132258,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_f = (__pyx_v_f + 1); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":873 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":873 * f[0] = 120 # "x"; pad byte * f += 1 * offset[0] += 1 # <<<<<<<<<<<<<< @@ -128591,7 +132269,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":875 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":875 * offset[0] += 1 * * offset[0] += child.itemsize # <<<<<<<<<<<<<< @@ -128601,7 +132279,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< @@ -128611,7 +132289,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); if (__pyx_t_6) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 * * if not PyDataType_HASFIELDS(child): * t = child.type_num # <<<<<<<<<<<<<< @@ -128623,7 +132301,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); __pyx_t_4 = 0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< @@ -128633,20 +132311,20 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); if (__pyx_t_6) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__147, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 880, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__142, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(4, 880, __pyx_L1_error) - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< @@ -128655,7 +132333,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 * * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< @@ -128673,7 +132351,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< @@ -128691,7 +132369,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< @@ -128709,7 +132387,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< @@ -128727,7 +132405,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< @@ -128745,7 +132423,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< @@ -128763,7 +132441,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< @@ -128781,7 +132459,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< @@ -128799,7 +132477,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< @@ -128817,7 +132495,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< @@ -128835,7 +132513,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< @@ -128853,7 +132531,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< @@ -128871,7 +132549,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< @@ -128889,7 +132567,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< @@ -128909,7 +132587,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< @@ -128929,7 +132607,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< @@ -128949,7 +132627,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":899 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":899 * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< @@ -128967,7 +132645,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< @@ -128986,7 +132664,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx } __pyx_L15:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":902 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":902 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * f += 1 # <<<<<<<<<<<<<< @@ -128995,7 +132673,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_f = (__pyx_v_f + 1); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< @@ -129005,7 +132683,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L13; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 * # Cython ignores struct boundary information ("T{...}"), * # so don't output it * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< @@ -129018,7 +132696,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx } __pyx_L13:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< @@ -129028,7 +132706,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":907 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":907 * # so don't output it * f = _util_dtypestring(child, f, end, offset) * return f # <<<<<<<<<<<<<< @@ -129038,7 +132716,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_r = __pyx_v_f; goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< @@ -129065,7 +132743,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -129077,7 +132755,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< @@ -129086,7 +132764,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ Py_INCREF(__pyx_v_base); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1024 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1024 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< @@ -129095,7 +132773,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -129107,7 +132785,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyFinishContext(); } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -129122,7 +132800,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< @@ -129131,7 +132809,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -129141,7 +132819,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< @@ -129152,7 +132830,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -129161,7 +132839,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1030 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1030 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< @@ -129173,7 +132851,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -129189,7 +132867,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< @@ -129210,7 +132888,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_array", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -129226,7 +132904,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 * cdef inline int import_array() except -1: * try: * _import_array() # <<<<<<<<<<<<<< @@ -129235,7 +132913,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(4, 1036, __pyx_L3_error) - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -129249,7 +132927,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 * try: * _import_array() * except Exception: # <<<<<<<<<<<<<< @@ -129264,14 +132942,14 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__148, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 1038, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__143, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 1038, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -129284,7 +132962,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -129304,7 +132982,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_L8_try_end:; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< @@ -129327,7 +133005,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -129348,7 +133026,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_umath", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -129364,7 +133042,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< @@ -129373,7 +133051,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(4, 1042, __pyx_L3_error) - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -129387,7 +133065,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -129402,14 +133080,14 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__149, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 1044, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__144, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 1044, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -129422,7 +133100,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -129442,7 +133120,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_L8_try_end:; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -129465,7 +133143,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { return __pyx_r; } -/* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 +/* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -129486,7 +133164,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -129502,7 +133180,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< @@ -129511,7 +133189,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(4, 1048, __pyx_L3_error) - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -129525,7 +133203,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -129539,12 +133217,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1050 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1050 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__149, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 1050, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__144, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 1050, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -129557,7 +133235,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -129577,7 +133255,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_L8_try_end:; } - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -131696,7 +135374,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * * if itemsize <= 0: */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__150, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 133, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__145, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 133, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -131728,7 +135406,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * * if not isinstance(format, bytes): */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__151, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 136, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__146, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -131855,7 +135533,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * * */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__152, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 148, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__147, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -132129,7 +135807,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * * if self.dtype_is_object: */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__153, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 176, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__148, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; @@ -132370,7 +136048,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru * info.buf = self.data * info.len = self.len */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__154, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 192, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__149, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 192, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -133086,7 +136764,7 @@ static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __p * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__155, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__150, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -133139,7 +136817,7 @@ static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__156, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__151, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -134783,7 +138461,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit * * have_slices, index = _unellipsify(index, self.view.ndim) */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__157, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 414, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__152, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 414, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -135810,7 +139488,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview * else: * if len(self.view.format) == 1: */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__158, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 491, __pyx_L5_except_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__153, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 491, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; @@ -136166,7 +139844,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu * * if flags & PyBUF_ND: */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__159, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__154, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -136706,7 +140384,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__160, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 566, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__155, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -136820,7 +140498,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__161, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 573, __pyx_L1_error) + __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__156, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; @@ -137821,7 +141499,7 @@ static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struc * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__162, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__157, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -137874,7 +141552,7 @@ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED st * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__163, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__158, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -138225,9 +141903,9 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __Pyx_GOTREF(__pyx_t_7); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { - __Pyx_INCREF(__pyx_slice__164); - __Pyx_GIVEREF(__pyx_slice__164); - PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__164); + __Pyx_INCREF(__pyx_slice__159); + __Pyx_GIVEREF(__pyx_slice__159); + PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__159); } } __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 678, __pyx_L1_error) @@ -138260,7 +141938,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { * else: */ /*else*/ { - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__164); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 681, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__159); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 681, __pyx_L1_error) } __pyx_L7:; @@ -138400,9 +142078,9 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __Pyx_GOTREF(__pyx_t_3); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { - __Pyx_INCREF(__pyx_slice__164); - __Pyx_GIVEREF(__pyx_slice__164); - PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__164); + __Pyx_INCREF(__pyx_slice__159); + __Pyx_GIVEREF(__pyx_slice__159); + PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__159); } } __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 692, __pyx_L1_error) @@ -138526,7 +142204,7 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ * * */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__165, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 699, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__160, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -140689,7 +144367,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__166, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__161, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -140742,7 +144420,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUS * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__167, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__162, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -147968,8 +151646,7 @@ static struct PyModuleDef __pyx_moduledef = { static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_0, __pyx_k_0, sizeof(__pyx_k_0), 0, 1, 0, 0}, {&__pyx_kp_u_0_1_2_3_4_5, __pyx_k_0_1_2_3_4_5, sizeof(__pyx_k_0_1_2_3_4_5), 0, 1, 0, 0}, - {&__pyx_kp_u_1, __pyx_k_1, sizeof(__pyx_k_1), 0, 1, 0, 0}, - {&__pyx_kp_u_1_15_0_py37_gcc_7_3_0, __pyx_k_1_15_0_py37_gcc_7_3_0, sizeof(__pyx_k_1_15_0_py37_gcc_7_3_0), 0, 1, 0, 0}, + {&__pyx_kp_u_1_15_1_py37_gcc_7_3_0, __pyx_k_1_15_1_py37_gcc_7_3_0, sizeof(__pyx_k_1_15_1_py37_gcc_7_3_0), 0, 1, 0, 0}, {&__pyx_kp_u_7_0_6, __pyx_k_7_0_6, sizeof(__pyx_k_7_0_6), 0, 1, 0, 0}, {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, {&__pyx_kp_u_A_handle_can_never_hold_a_negati, __pyx_k_A_handle_can_never_hold_a_negati, sizeof(__pyx_k_A_handle_can_never_hold_a_negati), 0, 1, 0, 0}, @@ -147999,6 +151676,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_Data_to_be_presented_in_native_d, __pyx_k_Data_to_be_presented_in_native_d, sizeof(__pyx_k_Data_to_be_presented_in_native_d), 0, 1, 0, 0}, {&__pyx_kp_u_Datatype_unknown_returning_value, __pyx_k_Datatype_unknown_returning_value, sizeof(__pyx_k_Datatype_unknown_returning_value), 0, 1, 0, 0}, {&__pyx_kp_u_EGU, __pyx_k_EGU, sizeof(__pyx_k_EGU), 0, 1, 0, 0}, + {&__pyx_kp_u_END_TIME_CHAR, __pyx_k_END_TIME_CHAR, sizeof(__pyx_k_END_TIME_CHAR), 0, 1, 0, 0}, {&__pyx_kp_u_ENUM_string_value, __pyx_k_ENUM_string_value, sizeof(__pyx_k_ENUM_string_value), 0, 1, 0, 0}, {&__pyx_kp_u_ENUM_value, __pyx_k_ENUM_value, sizeof(__pyx_k_ENUM_value), 0, 1, 0, 0}, {&__pyx_kp_u_ERROR_GROUP_MEMBER_MISMATCH, __pyx_k_ERROR_GROUP_MEMBER_MISMATCH, sizeof(__pyx_k_ERROR_GROUP_MEMBER_MISMATCH), 0, 1, 0, 0}, @@ -148124,7 +151802,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_PV_3, __pyx_k_PV_3, sizeof(__pyx_k_PV_3), 0, 1, 0, 0}, {&__pyx_n_u_PV_4, __pyx_k_PV_4, sizeof(__pyx_k_PV_4), 0, 1, 0, 1}, {&__pyx_kp_u_PY_VERSION_HEX_is, __pyx_k_PY_VERSION_HEX_is, sizeof(__pyx_k_PY_VERSION_HEX_is), 0, 1, 0, 0}, - {&__pyx_kp_u_Parameter, __pyx_k_Parameter, sizeof(__pyx_k_Parameter), 0, 1, 0, 0}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_kp_u_Possible_types_are, __pyx_k_Possible_types_are, sizeof(__pyx_k_Possible_types_are), 0, 1, 0, 0}, {&__pyx_n_s_PyCafe, __pyx_k_PyCafe, sizeof(__pyx_k_PyCafe), 0, 0, 1, 1}, @@ -148136,8 +151813,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_PyCafe_pyx_getArray_array_type_d, __pyx_k_PyCafe_pyx_getArray_array_type_d, sizeof(__pyx_k_PyCafe_pyx_getArray_array_type_d), 0, 1, 0, 0}, {&__pyx_kp_u_Returning_memoryview, __pyx_k_Returning_memoryview, sizeof(__pyx_k_Returning_memoryview), 0, 1, 0, 0}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, - {&__pyx_kp_u_SIGNATURE, __pyx_k_SIGNATURE, sizeof(__pyx_k_SIGNATURE), 0, 1, 0, 0}, - {&__pyx_kp_u_SIGNATURE_2, __pyx_k_SIGNATURE_2, sizeof(__pyx_k_SIGNATURE_2), 0, 1, 0, 0}, {&__pyx_kp_u_Second_input_argument_if_not_a_l, __pyx_k_Second_input_argument_if_not_a_l, sizeof(__pyx_k_Second_input_argument_if_not_a_l), 0, 1, 0, 0}, {&__pyx_kp_u_Second_input_argument_should_be, __pyx_k_Second_input_argument_should_be, sizeof(__pyx_k_Second_input_argument_should_be), 0, 1, 0, 0}, {&__pyx_kp_u_Second_input_argument_should_be_2, __pyx_k_Second_input_argument_should_be_2, sizeof(__pyx_k_Second_input_argument_should_be_2), 0, 1, 0, 0}, @@ -148175,14 +151850,13 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_Warning_from_groupMonitorStartW, __pyx_k_Warning_from_groupMonitorStartW, sizeof(__pyx_k_Warning_from_groupMonitorStartW), 0, 1, 0, 0}, {&__pyx_kp_u_Warning_from_monitorStart_for_h, __pyx_k_Warning_from_monitorStart_for_h, sizeof(__pyx_k_Warning_from_monitorStart_for_h), 0, 1, 0, 0}, {&__pyx_kp_u__10, __pyx_k__10, sizeof(__pyx_k__10), 0, 1, 0, 0}, - {&__pyx_kp_u__103, __pyx_k__103, sizeof(__pyx_k__103), 0, 1, 0, 0}, - {&__pyx_kp_u__106, __pyx_k__106, sizeof(__pyx_k__106), 0, 1, 0, 0}, - {&__pyx_kp_u__110, __pyx_k__110, sizeof(__pyx_k__110), 0, 1, 0, 0}, - {&__pyx_kp_u__113, __pyx_k__113, sizeof(__pyx_k__113), 0, 1, 0, 0}, - {&__pyx_kp_u__114, __pyx_k__114, sizeof(__pyx_k__114), 0, 1, 0, 0}, - {&__pyx_kp_u__135, __pyx_k__135, sizeof(__pyx_k__135), 0, 1, 0, 0}, + {&__pyx_kp_u__101, __pyx_k__101, sizeof(__pyx_k__101), 0, 1, 0, 0}, + {&__pyx_kp_u__105, __pyx_k__105, sizeof(__pyx_k__105), 0, 1, 0, 0}, + {&__pyx_kp_u__108, __pyx_k__108, sizeof(__pyx_k__108), 0, 1, 0, 0}, + {&__pyx_kp_u__109, __pyx_k__109, sizeof(__pyx_k__109), 0, 1, 0, 0}, + {&__pyx_kp_u__130, __pyx_k__130, sizeof(__pyx_k__130), 0, 1, 0, 0}, {&__pyx_kp_u__15, __pyx_k__15, sizeof(__pyx_k__15), 0, 1, 0, 0}, - {&__pyx_kp_u__168, __pyx_k__168, sizeof(__pyx_k__168), 0, 1, 0, 0}, + {&__pyx_kp_u__163, __pyx_k__163, sizeof(__pyx_k__163), 0, 1, 0, 0}, {&__pyx_kp_u__23, __pyx_k__23, sizeof(__pyx_k__23), 0, 1, 0, 0}, {&__pyx_kp_u__24, __pyx_k__24, sizeof(__pyx_k__24), 0, 1, 0, 0}, {&__pyx_kp_u__26, __pyx_k__26, sizeof(__pyx_k__26), 0, 1, 0, 0}, @@ -148275,6 +151949,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_u_cinit, __pyx_k_cinit, sizeof(__pyx_k_cinit), 0, 1, 0, 1}, {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, {&__pyx_kp_u_className_s, __pyx_k_className_s, sizeof(__pyx_k_className_s), 0, 1, 0, 0}, + {&__pyx_n_u_client, __pyx_k_client, sizeof(__pyx_k_client), 0, 1, 0, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_u_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 1, 0, 1}, {&__pyx_n_u_closeChannelKeepHandle, __pyx_k_closeChannelKeepHandle, sizeof(__pyx_k_closeChannelKeepHandle), 0, 1, 0, 1}, @@ -148299,7 +151974,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_dbrDataType, __pyx_k_dbrDataType, sizeof(__pyx_k_dbrDataType), 0, 1, 0, 0}, {&__pyx_kp_u_dbr_base_type_should_be_one_of_D, __pyx_k_dbr_base_type_should_be_one_of_D, sizeof(__pyx_k_dbr_base_type_should_be_one_of_D), 0, 1, 0, 0}, {&__pyx_kp_u_dbr_base_type_should_be_one_of_D_2, __pyx_k_dbr_base_type_should_be_one_of_D_2, sizeof(__pyx_k_dbr_base_type_should_be_one_of_D_2), 0, 1, 0, 0}, - {&__pyx_kp_u_dbr_mask_notify_milliseconds, __pyx_k_dbr_mask_notify_milliseconds, sizeof(__pyx_k_dbr_mask_notify_milliseconds), 0, 1, 0, 0}, {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, {&__pyx_kp_u_decode_utf_16_error, __pyx_k_decode_utf_16_error, sizeof(__pyx_k_decode_utf_16_error), 0, 1, 0, 0}, {&__pyx_n_s_deepcopy, __pyx_k_deepcopy, sizeof(__pyx_k_deepcopy), 0, 0, 1, 1}, @@ -148314,6 +151988,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1}, {&__pyx_n_u_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 1, 0, 1}, {&__pyx_n_s_dt, __pyx_k_dt, sizeof(__pyx_k_dt), 0, 0, 1, 1}, + {&__pyx_n_u_dtcheck, __pyx_k_dtcheck, sizeof(__pyx_k_dtcheck), 0, 1, 0, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1}, @@ -148499,8 +152174,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_keys, __pyx_k_keys, sizeof(__pyx_k_keys), 0, 0, 1, 1}, {&__pyx_n_s_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 0, 1, 1}, {&__pyx_kp_u_latin_1, __pyx_k_latin_1, sizeof(__pyx_k_latin_1), 0, 1, 0, 0}, - {&__pyx_n_u_len1, __pyx_k_len1, sizeof(__pyx_k_len1), 0, 1, 0, 1}, - {&__pyx_n_u_len2, __pyx_k_len2, sizeof(__pyx_k_len2), 0, 1, 0, 1}, + {&__pyx_kp_u_length_of_ui8val, __pyx_k_length_of_ui8val, sizeof(__pyx_k_length_of_ui8val), 0, 1, 0, 0}, {&__pyx_n_s_longlong, __pyx_k_longlong, sizeof(__pyx_k_longlong), 0, 0, 1, 1}, {&__pyx_kp_u_lowerAlarmLimit_f, __pyx_k_lowerAlarmLimit_f, sizeof(__pyx_k_lowerAlarmLimit_f), 0, 1, 0, 0}, {&__pyx_kp_u_lowerControlLimit_f, __pyx_k_lowerControlLimit_f, sizeof(__pyx_k_lowerControlLimit_f), 0, 1, 0, 0}, @@ -148532,8 +152206,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_monitorStop, __pyx_k_monitorStop, sizeof(__pyx_k_monitorStop), 0, 0, 1, 1}, {&__pyx_kp_u_monitorStopAll, __pyx_k_monitorStopAll, sizeof(__pyx_k_monitorStopAll), 0, 1, 0, 0}, {&__pyx_kp_u_monitorStop_handlePV_mpid_None, __pyx_k_monitorStop_handlePV_mpid_None, sizeof(__pyx_k_monitorStop_handlePV_mpid_None), 0, 1, 0, 0}, - {&__pyx_kp_u_monitor_id, __pyx_k_monitor_id, sizeof(__pyx_k_monitor_id), 0, 1, 0, 0}, - {&__pyx_n_u_monitorid, __pyx_k_monitorid, sizeof(__pyx_k_monitorid), 0, 1, 0, 1}, {&__pyx_n_s_monitorpolicy, __pyx_k_monitorpolicy, sizeof(__pyx_k_monitorpolicy), 0, 0, 1, 1}, {&__pyx_n_s_mpid, __pyx_k_mpid, sizeof(__pyx_k_mpid), 0, 0, 1, 1}, {&__pyx_n_u_mv, __pyx_k_mv, sizeof(__pyx_k_mv), 0, 1, 0, 1}, @@ -148646,6 +152318,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_kp_u_reports_the_following_error, __pyx_k_reports_the_following_error, sizeof(__pyx_k_reports_the_following_error), 0, 1, 0, 0}, + {&__pyx_n_u_request, __pyx_k_request, sizeof(__pyx_k_request), 0, 1, 0, 1}, {&__pyx_kp_u_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 1, 0, 0}, {&__pyx_n_s_scalarOnly, __pyx_k_scalarOnly, sizeof(__pyx_k_scalarOnly), 0, 0, 1, 1}, {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, @@ -148749,12 +152422,12 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_userArgs, __pyx_k_userArgs, sizeof(__pyx_k_userArgs), 0, 1, 0, 0}, {&__pyx_n_s_ushort, __pyx_k_ushort, sizeof(__pyx_k_ushort), 0, 0, 1, 1}, {&__pyx_n_u_ushort, __pyx_k_ushort, sizeof(__pyx_k_ushort), 0, 1, 0, 1}, - {&__pyx_n_u_utf_16, __pyx_k_utf_16, sizeof(__pyx_k_utf_16), 0, 1, 0, 1}, - {&__pyx_kp_u_utf_16_2, __pyx_k_utf_16_2, sizeof(__pyx_k_utf_16_2), 0, 1, 0, 0}, + {&__pyx_kp_u_utf_16, __pyx_k_utf_16, sizeof(__pyx_k_utf_16), 0, 1, 0, 0}, + {&__pyx_n_u_utf_16_2, __pyx_k_utf_16_2, sizeof(__pyx_k_utf_16_2), 0, 1, 0, 1}, {&__pyx_n_u_utf_32, __pyx_k_utf_32, sizeof(__pyx_k_utf_32), 0, 1, 0, 1}, {&__pyx_kp_u_utf_32_2, __pyx_k_utf_32_2, sizeof(__pyx_k_utf_32_2), 0, 1, 0, 0}, - {&__pyx_n_u_utf_8, __pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 1, 0, 1}, - {&__pyx_kp_u_utf_8_2, __pyx_k_utf_8_2, sizeof(__pyx_k_utf_8_2), 0, 1, 0, 0}, + {&__pyx_kp_u_utf_8, __pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 1, 0, 0}, + {&__pyx_n_u_utf_8_2, __pyx_k_utf_8_2, sizeof(__pyx_k_utf_8_2), 0, 1, 0, 1}, {&__pyx_kp_u_utf_none, __pyx_k_utf_none, sizeof(__pyx_k_utf_none), 0, 1, 0, 0}, {&__pyx_n_s_valAction, __pyx_k_valAction, sizeof(__pyx_k_valAction), 0, 0, 1, 1}, {&__pyx_n_s_valList, __pyx_k_valList, sizeof(__pyx_k_valList), 0, 0, 1, 1}, @@ -148789,13 +152462,13 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) __pyx_builtin_hex = __Pyx_GetBuiltinName(__pyx_n_s_hex); if (!__pyx_builtin_hex) __PYX_ERR(2, 697, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 814, __pyx_L1_error) - __pyx_builtin_UnicodeDecodeError = __Pyx_GetBuiltinName(__pyx_n_s_UnicodeDecodeError); if (!__pyx_builtin_UnicodeDecodeError) __PYX_ERR(2, 1203, __pyx_L1_error) + __pyx_builtin_UnicodeDecodeError = __Pyx_GetBuiltinName(__pyx_n_s_UnicodeDecodeError); if (!__pyx_builtin_UnicodeDecodeError) __PYX_ERR(2, 1126, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(3, 92, __pyx_L1_error) - __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(3, 184, __pyx_L1_error) - __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(3, 195, __pyx_L1_error) - __pyx_builtin_UserWarning = __Pyx_GetBuiltinName(__pyx_n_s_UserWarning); if (!__pyx_builtin_UserWarning) __PYX_ERR(3, 718, __pyx_L1_error) - __pyx_builtin_zip = __Pyx_GetBuiltinName(__pyx_n_s_zip); if (!__pyx_builtin_zip) __PYX_ERR(3, 1478, __pyx_L1_error) - __pyx_builtin_UnicodeEncodeError = __Pyx_GetBuiltinName(__pyx_n_s_UnicodeEncodeError); if (!__pyx_builtin_UnicodeEncodeError) __PYX_ERR(3, 7001, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(3, 183, __pyx_L1_error) + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(3, 194, __pyx_L1_error) + __pyx_builtin_UserWarning = __Pyx_GetBuiltinName(__pyx_n_s_UserWarning); if (!__pyx_builtin_UserWarning) __PYX_ERR(3, 717, __pyx_L1_error) + __pyx_builtin_zip = __Pyx_GetBuiltinName(__pyx_n_s_zip); if (!__pyx_builtin_zip) __PYX_ERR(3, 1477, __pyx_L1_error) + __pyx_builtin_UnicodeEncodeError = __Pyx_GetBuiltinName(__pyx_n_s_UnicodeEncodeError); if (!__pyx_builtin_UnicodeEncodeError) __PYX_ERR(3, 7208, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(4, 1038, __pyx_L1_error) __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 151, __pyx_L1_error) __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 400, __pyx_L1_error) @@ -149023,25 +152696,25 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); - /* "PyCafeDefs.pxi":1158 + /* "PyCafeDefs.pxi":1187 * dtcheck = dtn # need a line here * else: * print("Valid input parameters for data type are variations of: 'int', 'float', 'str', or 'native'") # <<<<<<<<<<<<<< * print("Data to be presented in native data type") * */ - __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_u_Valid_input_parameters_for_data); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(2, 1158, __pyx_L1_error) + __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_u_Valid_input_parameters_for_data); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(2, 1187, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); - /* "PyCafeDefs.pxi":1159 + /* "PyCafeDefs.pxi":1188 * else: * print("Valid input parameters for data type are variations of: 'int', 'float', 'str', or 'native'") * print("Data to be presented in native data type") # <<<<<<<<<<<<<< * * return dtcheck */ - __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_u_Data_to_be_presented_in_native_d); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(2, 1159, __pyx_L1_error) + __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_u_Data_to_be_presented_in_native_d); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(2, 1188, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); @@ -149057,212 +152730,212 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GIVEREF(__pyx_tuple__32); __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PyCafe_pyx, __pyx_n_s_wrapper, 76, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(3, 76, __pyx_L1_error) - /* "PyCafe.pyx":184 + /* "PyCafe.pyx":183 * * if self._c_cafe is NULL: * raise MemoryError("Failed to instantiate CAFE()") # <<<<<<<<<<<<<< * * self.cs = self._c_cafe.getCafeStatus() */ - __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_Failed_to_instantiate_CAFE); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(3, 184, __pyx_L1_error) + __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_Failed_to_instantiate_CAFE); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(3, 183, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); - /* "PyCafe.pyx":208 + /* "PyCafe.pyx":207 * * * print("PY_VERSION_HEX is ", hex(PY_VERSION_HEX)) # <<<<<<<<<<<<<< * * IF PY_EXT_C: */ - __pyx_tuple__35 = PyTuple_Pack(1, __pyx_int_50792432); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(3, 208, __pyx_L1_error) + __pyx_tuple__35 = PyTuple_Pack(1, __pyx_int_50792432); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(3, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__35); __Pyx_GIVEREF(__pyx_tuple__35); - /* "PyCafe.pyx":211 + /* "PyCafe.pyx":210 * * IF PY_EXT_C: * print("USING PUBLIC PyCafe.h INTERFACE FOR CALLBACKS") # <<<<<<<<<<<<<< * ELSE: * print("USING API PyCafe_api.h INTERFACE FOR CALLBACKS") */ - __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_u_USING_PUBLIC_PyCafe_h_INTERFACE); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(3, 211, __pyx_L1_error) + __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_u_USING_PUBLIC_PyCafe_h_INTERFACE); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(3, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); - /* "PyCafe.pyx":1738 + /* "PyCafe.pyx":1737 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def getChannelDataStore") * */ - __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_g); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(3, 1738, __pyx_L1_error) + __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_g); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(3, 1737, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__43); __Pyx_GIVEREF(__pyx_tuple__43); - /* "PyCafe.pyx":1925 + /* "PyCafe.pyx":1924 * # Print Warning Message * if dbrBase > DBR_TIME: * print("WARNING: PyCafe def setDbrBase(handle/PV, DBR_TYPE)") # <<<<<<<<<<<<<< * print("Allowed DBR_TYPEs are:") * print("DBR_PLAIN (0), DBR_STS(1), DBR_TIME(2)") */ - __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setDbrBase_ha); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(3, 1925, __pyx_L1_error) + __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setDbrBase_ha); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(3, 1924, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__45); __Pyx_GIVEREF(__pyx_tuple__45); - /* "PyCafe.pyx":1926 + /* "PyCafe.pyx":1925 * if dbrBase > DBR_TIME: * print("WARNING: PyCafe def setDbrBase(handle/PV, DBR_TYPE)") * print("Allowed DBR_TYPEs are:") # <<<<<<<<<<<<<< * print("DBR_PLAIN (0), DBR_STS(1), DBR_TIME(2)") * print("The value entered was", dbrBase, "hence assuming DBR_TIME") */ - __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_u_Allowed_DBR_TYPEs_are); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(3, 1926, __pyx_L1_error) + __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_u_Allowed_DBR_TYPEs_are); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(3, 1925, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__46); __Pyx_GIVEREF(__pyx_tuple__46); - /* "PyCafe.pyx":1927 + /* "PyCafe.pyx":1926 * print("WARNING: PyCafe def setDbrBase(handle/PV, DBR_TYPE)") * print("Allowed DBR_TYPEs are:") * print("DBR_PLAIN (0), DBR_STS(1), DBR_TIME(2)") # <<<<<<<<<<<<<< * print("The value entered was", dbrBase, "hence assuming DBR_TIME") * dbrBase = DBR_TIME */ - __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_DBR_PLAIN_0_DBR_STS_1_DBR_TIME_2); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(3, 1927, __pyx_L1_error) + __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_DBR_PLAIN_0_DBR_STS_1_DBR_TIME_2); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(3, 1926, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__47); __Pyx_GIVEREF(__pyx_tuple__47); - /* "PyCafe.pyx":1952 + /* "PyCafe.pyx":1951 * # Print Warning Message * if wpk > GET_CACHE_WAIT: * print( # <<<<<<<<<<<<<< * ("WARNING: PyCafe def setGetCacheWaitPolicy(" * "handle/PV, ChannelGetCacheWaitPolicyKind)")) */ - __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setGetCacheWa); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(3, 1952, __pyx_L1_error) + __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setGetCacheWa); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(3, 1951, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__48); __Pyx_GIVEREF(__pyx_tuple__48); - /* "PyCafe.pyx":1955 + /* "PyCafe.pyx":1954 * ("WARNING: PyCafe def setGetCacheWaitPolicy(" * "handle/PV, ChannelGetCacheWaitPolicyKind)")) * print("Allowed ChannelGetCacheWaitPolicyKind are:") # <<<<<<<<<<<<<< * print( * ("GET_CACHE_NO_CHECK (0), GET_CACHE_NO_WAIT (1)," */ - __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_u_Allowed_ChannelGetCacheWaitPolic); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(3, 1955, __pyx_L1_error) + __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_u_Allowed_ChannelGetCacheWaitPolic); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(3, 1954, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__49); __Pyx_GIVEREF(__pyx_tuple__49); - /* "PyCafe.pyx":1956 + /* "PyCafe.pyx":1955 * "handle/PV, ChannelGetCacheWaitPolicyKind)")) * print("Allowed ChannelGetCacheWaitPolicyKind are:") * print( # <<<<<<<<<<<<<< * ("GET_CACHE_NO_CHECK (0), GET_CACHE_NO_WAIT (1)," * "GET_CACHE_WAIT (2)")) */ - __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_u_GET_CACHE_NO_CHECK_0_GET_CACHE_N); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(3, 1956, __pyx_L1_error) + __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_u_GET_CACHE_NO_CHECK_0_GET_CACHE_N); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(3, 1955, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__50); __Pyx_GIVEREF(__pyx_tuple__50); - /* "PyCafe.pyx":1977 + /* "PyCafe.pyx":1976 * # Print Warning Message * if wpk > GET_CACHE_WAIT: * print( # <<<<<<<<<<<<<< * "WARNING: PyCafe def setGetCacheWaitPolicyAllHandles( \ * ChannelGetCacheWaitPolicyKind)") */ - __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setGetCacheWa_2); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(3, 1977, __pyx_L1_error) + __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setGetCacheWa_2); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(3, 1976, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__51); __Pyx_GIVEREF(__pyx_tuple__51); - /* "PyCafe.pyx":1981 + /* "PyCafe.pyx":1980 * ChannelGetCacheWaitPolicyKind)") * print("Allowed ChannelGetCacheWaitPolicyKind are:") * print( # <<<<<<<<<<<<<< * "GET_CACHE_NO_CHECK (0), GET_CACHE_NO_WAIT (1), \ * GET_CACHE_WAIT (2)") */ - __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_u_GET_CACHE_NO_CHECK_0_GET_CACHE_N_2); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(3, 1981, __pyx_L1_error) + __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_u_GET_CACHE_NO_CHECK_0_GET_CACHE_N_2); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(3, 1980, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__52); __Pyx_GIVEREF(__pyx_tuple__52); - /* "PyCafe.pyx":2003 + /* "PyCafe.pyx":2002 * # Print Warning Message * if wmpk > GET_FROM_IOC: * print("WARNING: PyCafe def setGetActionWhenMonitorPolicy") # <<<<<<<<<<<<<< * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print("GET_FROM_CACHE (0), GET_FROM_IOC (1)") */ - __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setGetActionW); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(3, 2003, __pyx_L1_error) + __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setGetActionW); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(3, 2002, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); - /* "PyCafe.pyx":2004 + /* "PyCafe.pyx":2003 * if wmpk > GET_FROM_IOC: * print("WARNING: PyCafe def setGetActionWhenMonitorPolicy") * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") # <<<<<<<<<<<<<< * print("GET_FROM_CACHE (0), GET_FROM_IOC (1)") * print("The value entered was", wmpk, */ - __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_u_Allowed_ChannelGetActionWhenMoni); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(3, 2004, __pyx_L1_error) + __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_u_Allowed_ChannelGetActionWhenMoni); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(3, 2003, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__54); __Pyx_GIVEREF(__pyx_tuple__54); - /* "PyCafe.pyx":2005 + /* "PyCafe.pyx":2004 * print("WARNING: PyCafe def setGetActionWhenMonitorPolicy") * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print("GET_FROM_CACHE (0), GET_FROM_IOC (1)") # <<<<<<<<<<<<<< * print("The value entered was", wmpk, * "hence assuming default value GET_FROM_IOC") */ - __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_u_GET_FROM_CACHE_0_GET_FROM_IOC_1); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(3, 2005, __pyx_L1_error) + __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_u_GET_FROM_CACHE_0_GET_FROM_IOC_1); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(3, 2004, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__55); __Pyx_GIVEREF(__pyx_tuple__55); - /* "PyCafe.pyx":2023 + /* "PyCafe.pyx":2022 * # Print Warning Message * if wmpk > GET_FROM_IOC: * print("WARNING: PyCafe def setGetActionWhenMonitorPolicyAllHandles") # <<<<<<<<<<<<<< * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print(" GET_FROM_CACHE (0), GET_FROM_IOC (1)") */ - __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setGetActionW_2); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(3, 2023, __pyx_L1_error) + __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_u_WARNING_PyCafe_def_setGetActionW_2); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(3, 2022, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__56); __Pyx_GIVEREF(__pyx_tuple__56); - /* "PyCafe.pyx":2025 + /* "PyCafe.pyx":2024 * print("WARNING: PyCafe def setGetActionWhenMonitorPolicyAllHandles") * print("Allowed ChannelGetActionWhenMonitorPolicyKind are:") * print(" GET_FROM_CACHE (0), GET_FROM_IOC (1)") # <<<<<<<<<<<<<< * print( * "The value entered was", wmpk, */ - __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_GET_FROM_CACHE_0_GET_FROM_IOC_1_2); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(3, 2025, __pyx_L1_error) + __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_GET_FROM_CACHE_0_GET_FROM_IOC_1_2); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(3, 2024, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__57); __Pyx_GIVEREF(__pyx_tuple__57); - /* "PyCafe.pyx":2214 + /* "PyCafe.pyx":2213 * return self.valInt * else: * print("This line in PyCafe def get should never appear!") # <<<<<<<<<<<<<< * return None * */ - __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_get_shou); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(3, 2214, __pyx_L1_error) + __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_get_shou); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(3, 2213, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__58); __Pyx_GIVEREF(__pyx_tuple__58); - /* "PyCafe.pyx":2492 + /* "PyCafe.pyx":2491 * return None * else: * print("This line in PyCafe def getAsList should never appear!") # <<<<<<<<<<<<<< * return None * */ - __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_getAsLis); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(3, 2492, __pyx_L1_error) + __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_getAsLis); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(3, 2491, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__59); __Pyx_GIVEREF(__pyx_tuple__59); @@ -149299,687 +152972,643 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__62); __Pyx_GIVEREF(__pyx_tuple__62); - /* "PyCafe.pyx":2832 - * elif art in ['array', 'array.array']: + /* "PyCafe.pyx":2833 * + * elif art in ['array', 'array.array']: * a = array.array('h') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): - * a.append( < short > i16val[ij]) + * a.append( < short > ui8val[ij]) */ - __pyx_tuple__63 = PyTuple_Pack(1, __pyx_n_u_h); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(3, 2832, __pyx_L1_error) + __pyx_tuple__63 = PyTuple_Pack(1, __pyx_n_u_h); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(3, 2833, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); - /* "PyCafe.pyx":2998 + /* "PyCafe.pyx":3088 * elif art in ['array', 'array.array']: * * a = array.array('f') # <<<<<<<<<<<<<< * * for ij in range(0, nelemMethod): */ - __pyx_tuple__64 = PyTuple_Pack(1, __pyx_n_u_f); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(3, 2998, __pyx_L1_error) + __pyx_tuple__64 = PyTuple_Pack(1, __pyx_n_u_f); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(3, 3088, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__64); __Pyx_GIVEREF(__pyx_tuple__64); - /* "PyCafe.pyx":3080 + /* "PyCafe.pyx":3170 * * elif art in ['array', 'array.array']: * a = array.array('d') # <<<<<<<<<<<<<< * for ij in range(0, nelemMethod): * a.append(dval[ij]) */ - __pyx_tuple__65 = PyTuple_Pack(1, __pyx_n_u_d); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(3, 3080, __pyx_L1_error) + __pyx_tuple__65 = PyTuple_Pack(1, __pyx_n_u_d); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(3, 3170, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); - /* "PyCafe.pyx":3502 + /* "PyCafe.pyx":3592 * if (status != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error/Warning from def getAsyn: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * */ - __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_u_Error_Warning_from_def_getAsyn); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(3, 3502, __pyx_L1_error) + __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_u_Error_Warning_from_def_getAsyn); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(3, 3592, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__66); __Pyx_GIVEREF(__pyx_tuple__66); - /* "PyCafe.pyx":3534 + /* "PyCafe.pyx":3624 * * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def waitForBundledEvents. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_w); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(3, 3534, __pyx_L1_error) + __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_w); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(3, 3624, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__67); __Pyx_GIVEREF(__pyx_tuple__67); - /* "PyCafe.pyx":3540 + /* "PyCafe.pyx":3630 * 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 of type if handles or if PVs") * */ - __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_w_2); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(3, 3540, __pyx_L1_error) + __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_w_2); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(3, 3630, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__68); __Pyx_GIVEREF(__pyx_tuple__68); - /* "PyCafe.pyx":3557 + /* "PyCafe.pyx":3647 * if (status != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def waitForBundledEvents: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * return status */ - __pyx_tuple__69 = PyTuple_Pack(1, __pyx_kp_u_Error_in_def_waitForBundledEvent); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(3, 3557, __pyx_L1_error) + __pyx_tuple__69 = PyTuple_Pack(1, __pyx_kp_u_Error_in_def_waitForBundledEvent); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(3, 3647, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__69); __Pyx_GIVEREF(__pyx_tuple__69); - /* "PyCafe.pyx":3574 + /* "PyCafe.pyx":3664 * * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def getScalarArray. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(3, 3574, __pyx_L1_error) + __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(3, 3664, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__70); __Pyx_GIVEREF(__pyx_tuple__70); - /* "PyCafe.pyx":3580 + /* "PyCafe.pyx":3670 * handleList = self.checkForHandleList(handleList) * elif not isinstance(handleList[0], (int, long)): * raise Exception("EXCEPTION RAISED IN PyCafe def getScalarArray. \n\ # <<<<<<<<<<<<<< * First input argument, should be a 'list' of of type if handles or if PVs") * */ - __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_2); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(3, 3580, __pyx_L1_error) + __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_2); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(3, 3670, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__71); __Pyx_GIVEREF(__pyx_tuple__71); - /* "PyCafe.pyx":3631 + /* "PyCafe.pyx":3721 * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def getScalarArray: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(statusBundle) * */ - __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_u_Error_in_def_getScalarArray); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(3, 3631, __pyx_L1_error) + __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_u_Error_in_def_getScalarArray); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(3, 3721, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__72); __Pyx_GIVEREF(__pyx_tuple__72); - /* "PyCafe.pyx":3855 + /* "PyCafe.pyx":3945 * localList.append(0) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: * print("def getScalarArray:") # <<<<<<<<<<<<<< * print("Entering 0 for element", i, * "as channel is not connected!") */ - __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_u_def_getScalarArray); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(3, 3855, __pyx_L1_error) + __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_u_def_getScalarArray); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(3, 3945, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__73); __Pyx_GIVEREF(__pyx_tuple__73); - /* "PyCafe.pyx":3900 + /* "PyCafe.pyx":3990 * * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def getScalarList. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_3); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(3, 3900, __pyx_L1_error) + __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_3); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(3, 3990, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__74); __Pyx_GIVEREF(__pyx_tuple__74); - /* "PyCafe.pyx":3906 + /* "PyCafe.pyx":3996 * 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 of type if handles or if PVs") * */ - __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_4); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(3, 3906, __pyx_L1_error) + __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_4); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(3, 3996, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__75); __Pyx_GIVEREF(__pyx_tuple__75); - /* "PyCafe.pyx":3970 + /* "PyCafe.pyx":4060 * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def getScalarList: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(statusBundle) * */ - __pyx_tuple__76 = PyTuple_Pack(1, __pyx_kp_u_Error_in_def_getScalarList); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(3, 3970, __pyx_L1_error) + __pyx_tuple__76 = PyTuple_Pack(1, __pyx_kp_u_Error_in_def_getScalarList); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(3, 4060, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__76); __Pyx_GIVEREF(__pyx_tuple__76); - /* "PyCafe.pyx":4196 + /* "PyCafe.pyx":4286 * localList.append(0) * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_HIGH: * print("def getScalarList:") # <<<<<<<<<<<<<< * print("Entering 0 for element", i, * "as channel is not connected!") */ - __pyx_tuple__77 = PyTuple_Pack(1, __pyx_kp_u_def_getScalarList); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(3, 4196, __pyx_L1_error) + __pyx_tuple__77 = PyTuple_Pack(1, __pyx_kp_u_def_getScalarList); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(3, 4286, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__77); __Pyx_GIVEREF(__pyx_tuple__77); - /* "PyCafe.pyx":4225 + /* "PyCafe.pyx":4315 * handleList = self.getHandlesFromWithinGroup(handleList) * if not handleList: * raise Exception(("EXCEPTION RAISED IN PyCafe def getDictionary. \n" + # <<<<<<<<<<<<<< * "First input argument should be " + * "of handles or PVs\nelse for " + */ - __pyx_tuple__78 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_5); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(3, 4225, __pyx_L1_error) + __pyx_tuple__78 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_5); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(3, 4315, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__78); __Pyx_GIVEREF(__pyx_tuple__78); - /* "PyCafe.pyx":4231 + /* "PyCafe.pyx":4321 * else: * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def getCompoundList. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_6); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(3, 4231, __pyx_L1_error) + __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_6); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(3, 4321, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__79); __Pyx_GIVEREF(__pyx_tuple__79); - /* "PyCafe.pyx":4238 + /* "PyCafe.pyx":4328 * 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 of type if handles or if PVs") * */ - __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_7); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(3, 4238, __pyx_L1_error) + __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_7); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(3, 4328, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__80); __Pyx_GIVEREF(__pyx_tuple__80); - /* "PyCafe.pyx":4264 + /* "PyCafe.pyx":4354 * handleList = self.getHandlesFromWithinGroup(handleList) * if not handleList: * raise Exception(("EXCEPTION RAISED IN PyCafe def getCompoundList. \n" + # <<<<<<<<<<<<<< * "First input argument should be " + * "of handles or PVs\nelse for " + */ - __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_8); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(3, 4264, __pyx_L1_error) + __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_8); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(3, 4354, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__81); __Pyx_GIVEREF(__pyx_tuple__81); - /* "PyCafe.pyx":4319 + /* "PyCafe.pyx":4409 * if (statusBundle != ICAFE_NORMAL): * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * print("Error in def getCompoundList: ") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(statusBundle) * */ - __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_u_Error_in_def_getCompoundList); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(3, 4319, __pyx_L1_error) + __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_u_Error_in_def_getCompoundList); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(3, 4409, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__82); __Pyx_GIVEREF(__pyx_tuple__82); - /* "PyCafe.pyx":4562 + /* "PyCafe.pyx":4652 * else: * * raise Exception("EXCEPTION RAISED IN PyCafe def getCompoundPVGroup. \n\ # <<<<<<<<<<<<<< * First input argument, should be of type if group handle, else if group name") * */ - __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_9); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(3, 4562, __pyx_L1_error) + __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_9); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(3, 4652, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__83); __Pyx_GIVEREF(__pyx_tuple__83); - /* "PyCafe.pyx":4670 + /* "PyCafe.pyx":4760 * handle = self.checkForHandle(handlePV) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getCache. \n\ # <<<<<<<<<<<<<< * First input argument, should be of type if handle, else if PV") * */ - __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_10); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(3, 4670, __pyx_L1_error) + __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_10); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(3, 4760, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__84); __Pyx_GIVEREF(__pyx_tuple__84); - /* "PyCafe.pyx":4776 + /* "PyCafe.pyx":4866 * 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 */ - __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_getCache); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(3, 4776, __pyx_L1_error) + __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_getCache); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(3, 4866, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__85); __Pyx_GIVEREF(__pyx_tuple__85); - /* "PyCafe.pyx":4777 + /* "PyCafe.pyx":4867 * if status == ICAFE_NORMAL: * print("This line in PyCafe def getCache should never appear!") * print("Datatype unknown, returning value 0") # <<<<<<<<<<<<<< * return 0 * */ - __pyx_tuple__86 = PyTuple_Pack(1, __pyx_kp_u_Datatype_unknown_returning_value); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(3, 4777, __pyx_L1_error) + __pyx_tuple__86 = PyTuple_Pack(1, __pyx_kp_u_Datatype_unknown_returning_value); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(3, 4867, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__86); __Pyx_GIVEREF(__pyx_tuple__86); - /* "PyCafe.pyx":5288 + /* "PyCafe.pyx":5493 * handle = self.checkForHandle(handlePV) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getPVCache. \n \ # <<<<<<<<<<<<<< * First input argument, should be of type if handle, else if PV") * */ - __pyx_tuple__87 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_11); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(3, 5288, __pyx_L1_error) + __pyx_tuple__87 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_11); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(3, 5493, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__87); __Pyx_GIVEREF(__pyx_tuple__87); - /* "PyCafe.pyx":5334 + /* "PyCafe.pyx":5539 * handle = self.checkForHandle(handlePV) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getCtrl. \n\ # <<<<<<<<<<<<<< * First input argument, should be of type if handle, else if PV") * */ - __pyx_tuple__88 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_12); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(3, 5334, __pyx_L1_error) + __pyx_tuple__88 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_12); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(3, 5539, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__88); __Pyx_GIVEREF(__pyx_tuple__88); - /* "PyCafe.pyx":5380 + /* "PyCafe.pyx":5585 * handle = self.checkForHandle(handlePV) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getCtrlCache. \n\ # <<<<<<<<<<<<<< * First input argument, should be of type if handle, else if PV") * */ - __pyx_tuple__89 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_13); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(3, 5380, __pyx_L1_error) + __pyx_tuple__89 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_13); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(3, 5585, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__89); __Pyx_GIVEREF(__pyx_tuple__89); - /* "PyCafe.pyx":5461 + /* "PyCafe.pyx":5666 * handle = self.checkForHandle(handlePV, force=True) * else: * raise Exception("EXCEPTION RAISED IN PyCafe def getMonitorPolicyVector \n\ # <<<<<<<<<<<<<< * First input argument, should be of type if handle, else if PV") * */ - __pyx_tuple__90 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_14); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(3, 5461, __pyx_L1_error) + __pyx_tuple__90 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_14); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(3, 5666, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__90); __Pyx_GIVEREF(__pyx_tuple__90); - /* "PyCafe.pyx":5522 + /* "PyCafe.pyx":5727 * 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") */ - __pyx_tuple__95 = PyTuple_Pack(1, __pyx_kp_u_dbr_base_type_should_be_one_of_D); if (unlikely(!__pyx_tuple__95)) __PYX_ERR(3, 5522, __pyx_L1_error) + __pyx_tuple__95 = PyTuple_Pack(1, __pyx_kp_u_dbr_base_type_should_be_one_of_D); if (unlikely(!__pyx_tuple__95)) __PYX_ERR(3, 5727, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__95); __Pyx_GIVEREF(__pyx_tuple__95); - /* "PyCafe.pyx":5524 + /* "PyCafe.pyx":5729 * 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 * */ - __pyx_tuple__96 = PyTuple_Pack(1, __pyx_kp_u_Assuming_DBR_TIME); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(3, 5524, __pyx_L1_error) + __pyx_tuple__96 = PyTuple_Pack(1, __pyx_kp_u_Assuming_DBR_TIME); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(3, 5729, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__96); __Pyx_GIVEREF(__pyx_tuple__96); - /* "PyCafe.pyx":5556 - * mp.setPyCyHandler( cb) - * - * print('============//1//') # <<<<<<<<<<<<<< - * print('SIGNATURE:') - * print(str(sig)) - */ - __pyx_tuple__97 = PyTuple_Pack(1, __pyx_kp_u_1); if (unlikely(!__pyx_tuple__97)) __PYX_ERR(3, 5556, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__97); - __Pyx_GIVEREF(__pyx_tuple__97); - - /* "PyCafe.pyx":5557 - * - * print('============//1//') - * print('SIGNATURE:') # <<<<<<<<<<<<<< - * print(str(sig)) - * for param in sig.parameters.values(): - */ - __pyx_tuple__98 = PyTuple_Pack(1, __pyx_kp_u_SIGNATURE); if (unlikely(!__pyx_tuple__98)) __PYX_ERR(3, 5557, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__98); - __Pyx_GIVEREF(__pyx_tuple__98); - - /* "PyCafe.pyx":5613 + /* "PyCafe.pyx":5820 * * 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") * */ - __pyx_tuple__101 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_15); if (unlikely(!__pyx_tuple__101)) __PYX_ERR(3, 5613, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__101); - __Pyx_GIVEREF(__pyx_tuple__101); + __pyx_tuple__99 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_15); if (unlikely(!__pyx_tuple__99)) __PYX_ERR(3, 5820, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__99); + __Pyx_GIVEREF(__pyx_tuple__99); - /* "PyCafe.pyx":5628 + /* "PyCafe.pyx":5835 * 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") * */ - __pyx_tuple__102 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_16); if (unlikely(!__pyx_tuple__102)) __PYX_ERR(3, 5628, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__102); - __Pyx_GIVEREF(__pyx_tuple__102); + __pyx_tuple__100 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_g_16); if (unlikely(!__pyx_tuple__100)) __PYX_ERR(3, 5835, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__100); + __Pyx_GIVEREF(__pyx_tuple__100); - /* "PyCafe.pyx":5654 - * mp[i].setPyCyHandler( cb[i]) - * - * print('============') # <<<<<<<<<<<<<< - * print('SIGNATURE//2//:') - * print(str(sig)) - */ - __pyx_tuple__104 = PyTuple_Pack(1, __pyx_kp_u__103); if (unlikely(!__pyx_tuple__104)) __PYX_ERR(3, 5654, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__104); - __Pyx_GIVEREF(__pyx_tuple__104); - - /* "PyCafe.pyx":5655 - * - * print('============') - * print('SIGNATURE//2//:') # <<<<<<<<<<<<<< - * print(str(sig)) - * for param in sig.parameters.values(): - */ - __pyx_tuple__105 = PyTuple_Pack(1, __pyx_kp_u_SIGNATURE_2); if (unlikely(!__pyx_tuple__105)) __PYX_ERR(3, 5655, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__105); - __Pyx_GIVEREF(__pyx_tuple__105); - - /* "PyCafe.pyx":5738 + /* "PyCafe.pyx":5945 * * if status == ECA_TIMEOUT: * print("======================================================") # <<<<<<<<<<<<<< * self._c_cafe.printStatusMessage(status) * print("TIMEOUT in getGroup; switching to getCompoundList") */ - __pyx_tuple__107 = PyTuple_Pack(1, __pyx_kp_u__106); if (unlikely(!__pyx_tuple__107)) __PYX_ERR(3, 5738, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__107); - __Pyx_GIVEREF(__pyx_tuple__107); + __pyx_tuple__102 = PyTuple_Pack(1, __pyx_kp_u__101); if (unlikely(!__pyx_tuple__102)) __PYX_ERR(3, 5945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__102); + __Pyx_GIVEREF(__pyx_tuple__102); - /* "PyCafe.pyx":5740 + /* "PyCafe.pyx":5947 * print("======================================================") * self._c_cafe.printStatusMessage(status) * print("TIMEOUT in getGroup; switching to getCompoundList") # <<<<<<<<<<<<<< * print("======================================================") * return self.getCompoundList(pvg.getNameAsString(), dt) */ - __pyx_tuple__108 = PyTuple_Pack(1, __pyx_kp_u_TIMEOUT_in_getGroup_switching_to); if (unlikely(!__pyx_tuple__108)) __PYX_ERR(3, 5740, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__108); - __Pyx_GIVEREF(__pyx_tuple__108); + __pyx_tuple__103 = PyTuple_Pack(1, __pyx_kp_u_TIMEOUT_in_getGroup_switching_to); if (unlikely(!__pyx_tuple__103)) __PYX_ERR(3, 5947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__103); + __Pyx_GIVEREF(__pyx_tuple__103); - /* "PyCafe.pyx":6093 + /* "PyCafe.pyx":6300 * if status == ECA_TIMEOUT: * print("======================================================") * print("TIMEOUT in getGroup; swithing to getCompoundPVGroup") # <<<<<<<<<<<<<< * print("======================================================") * return self.getCompoundPVGroup(ghandle, dt) */ - __pyx_tuple__109 = PyTuple_Pack(1, __pyx_kp_u_TIMEOUT_in_getGroup_swithing_to); if (unlikely(!__pyx_tuple__109)) __PYX_ERR(3, 6093, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__109); - __Pyx_GIVEREF(__pyx_tuple__109); + __pyx_tuple__104 = PyTuple_Pack(1, __pyx_kp_u_TIMEOUT_in_getGroup_swithing_to); if (unlikely(!__pyx_tuple__104)) __PYX_ERR(3, 6300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__104); + __Pyx_GIVEREF(__pyx_tuple__104); - /* "PyCafe.pyx":6146 + /* "PyCafe.pyx":6353 * with nogil: * self._c_cafe.groupAttach(ghandle, pvg) * print("==============" ) # <<<<<<<<<<<<<< * print(_METHOD) * pvg.showMax(1) */ - __pyx_tuple__111 = PyTuple_Pack(1, __pyx_kp_u__110); if (unlikely(!__pyx_tuple__111)) __PYX_ERR(3, 6146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__111); - __Pyx_GIVEREF(__pyx_tuple__111); + __pyx_tuple__106 = PyTuple_Pack(1, __pyx_kp_u__105); if (unlikely(!__pyx_tuple__106)) __PYX_ERR(3, 6353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__106); + __Pyx_GIVEREF(__pyx_tuple__106); - /* "PyCafe.pyx":6271 + /* "PyCafe.pyx":6478 * 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: */ - __pyx_tuple__112 = PyTuple_Pack(1, __pyx_kp_u_Analysing_statusList); if (unlikely(!__pyx_tuple__112)) __PYX_ERR(3, 6271, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__112); - __Pyx_GIVEREF(__pyx_tuple__112); + __pyx_tuple__107 = PyTuple_Pack(1, __pyx_kp_u_Analysing_statusList); if (unlikely(!__pyx_tuple__107)) __PYX_ERR(3, 6478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__107); + __Pyx_GIVEREF(__pyx_tuple__107); - /* "PyCafe.pyx":6502 + /* "PyCafe.pyx":6709 * 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") */ - __pyx_tuple__119 = PyTuple_Pack(1, __pyx_kp_u_dbr_base_type_should_be_one_of_D_2); if (unlikely(!__pyx_tuple__119)) __PYX_ERR(3, 6502, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__119); - __Pyx_GIVEREF(__pyx_tuple__119); + __pyx_tuple__114 = PyTuple_Pack(1, __pyx_kp_u_dbr_base_type_should_be_one_of_D_2); if (unlikely(!__pyx_tuple__114)) __PYX_ERR(3, 6709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__114); + __Pyx_GIVEREF(__pyx_tuple__114); - /* "PyCafe.pyx":6578 + /* "PyCafe.pyx":6785 * del hmd[l] * else: * raise Exception("EXCEPTION RAISED IN PyCafe def monitorStop. \n \ # <<<<<<<<<<<<<< * monitorPolicy ID (mpid) should be of type ") * else: */ - __pyx_tuple__120 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_m); if (unlikely(!__pyx_tuple__120)) __PYX_ERR(3, 6578, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__120); - __Pyx_GIVEREF(__pyx_tuple__120); + __pyx_tuple__115 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_m); if (unlikely(!__pyx_tuple__115)) __PYX_ERR(3, 6785, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__115); + __Pyx_GIVEREF(__pyx_tuple__115); - /* "PyCafe.pyx":6727 + /* "PyCafe.pyx":6934 * # print('OK for memoryview') * * if _python_version > (2,6): # <<<<<<<<<<<<<< * #if ((_python_version[0] > 2) or (_python_version[0] == 2 and _python_version[1] > 6)): * */ - __pyx_tuple__121 = PyTuple_Pack(2, __pyx_int_2, __pyx_int_6); if (unlikely(!__pyx_tuple__121)) __PYX_ERR(3, 6727, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__121); - __Pyx_GIVEREF(__pyx_tuple__121); + __pyx_tuple__116 = PyTuple_Pack(2, __pyx_int_2, __pyx_int_6); if (unlikely(!__pyx_tuple__116)) __PYX_ERR(3, 6934, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__116); + __Pyx_GIVEREF(__pyx_tuple__116); - /* "PyCafe.pyx":6881 + /* "PyCafe.pyx":7088 * temp = (valSet[i]).decode('utf_8') * encoding = True * print('utf-8') # <<<<<<<<<<<<<< * vecS.push_back(temp.encode('utf_8')) * except UnicodeDecodeError: */ - __pyx_tuple__122 = PyTuple_Pack(1, __pyx_kp_u_utf_8_2); if (unlikely(!__pyx_tuple__122)) __PYX_ERR(3, 6881, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__122); - __Pyx_GIVEREF(__pyx_tuple__122); + __pyx_tuple__117 = PyTuple_Pack(1, __pyx_kp_u_utf_8); if (unlikely(!__pyx_tuple__117)) __PYX_ERR(3, 7088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__117); + __Pyx_GIVEREF(__pyx_tuple__117); - /* "PyCafe.pyx":6889 + /* "PyCafe.pyx":7096 * temp = (valSet[i]).decode('utf_16') * encoding = True * print('utf-16') # <<<<<<<<<<<<<< * vecS.push_back(temp.encode('utf_16').decode('utf_16')) * except UnicodeDecodeError: */ - __pyx_tuple__123 = PyTuple_Pack(1, __pyx_kp_u_utf_16_2); if (unlikely(!__pyx_tuple__123)) __PYX_ERR(3, 6889, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__123); - __Pyx_GIVEREF(__pyx_tuple__123); + __pyx_tuple__118 = PyTuple_Pack(1, __pyx_kp_u_utf_16); if (unlikely(!__pyx_tuple__118)) __PYX_ERR(3, 7096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__118); + __Pyx_GIVEREF(__pyx_tuple__118); - /* "PyCafe.pyx":6897 + /* "PyCafe.pyx":7104 * temp = (valSet[i]).decode('utf_32') * encoding = True * print('utf-32') # <<<<<<<<<<<<<< * vecS.push_back(temp.encode('utf_32')) * except UnicodeDecodeError: */ - __pyx_tuple__124 = PyTuple_Pack(1, __pyx_kp_u_utf_32_2); if (unlikely(!__pyx_tuple__124)) __PYX_ERR(3, 6897, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__124); - __Pyx_GIVEREF(__pyx_tuple__124); + __pyx_tuple__119 = PyTuple_Pack(1, __pyx_kp_u_utf_32_2); if (unlikely(!__pyx_tuple__119)) __PYX_ERR(3, 7104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__119); + __Pyx_GIVEREF(__pyx_tuple__119); - /* "PyCafe.pyx":6999 + /* "PyCafe.pyx":7206 * encoding = True * except UnicodeDecodeError: * print('decode utf_16 error') # <<<<<<<<<<<<<< * pass * except UnicodeEncodeError as ex: */ - __pyx_tuple__125 = PyTuple_Pack(1, __pyx_kp_u_decode_utf_16_error); if (unlikely(!__pyx_tuple__125)) __PYX_ERR(3, 6999, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__125); - __Pyx_GIVEREF(__pyx_tuple__125); + __pyx_tuple__120 = PyTuple_Pack(1, __pyx_kp_u_decode_utf_16_error); if (unlikely(!__pyx_tuple__120)) __PYX_ERR(3, 7206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__120); + __Pyx_GIVEREF(__pyx_tuple__120); - /* "PyCafe.pyx":7005 + /* "PyCafe.pyx":7212 * pass * if not encoding: * print('no encoding done') # <<<<<<<<<<<<<< * valSetS = valSet * with nogil: */ - __pyx_tuple__126 = PyTuple_Pack(1, __pyx_kp_u_no_encoding_done); if (unlikely(!__pyx_tuple__126)) __PYX_ERR(3, 7005, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__126); - __Pyx_GIVEREF(__pyx_tuple__126); + __pyx_tuple__121 = PyTuple_Pack(1, __pyx_kp_u_no_encoding_done); if (unlikely(!__pyx_tuple__121)) __PYX_ERR(3, 7212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__121); + __Pyx_GIVEREF(__pyx_tuple__121); - /* "PyCafe.pyx":7015 + /* "PyCafe.pyx":7222 * 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 of type , or ") */ - __pyx_tuple__127 = PyTuple_Pack(1, __pyx_kp_u_PyCafe_def_set_WARNING_DATA_TYPE); if (unlikely(!__pyx_tuple__127)) __PYX_ERR(3, 7015, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__127); - __Pyx_GIVEREF(__pyx_tuple__127); + __pyx_tuple__122 = PyTuple_Pack(1, __pyx_kp_u_PyCafe_def_set_WARNING_DATA_TYPE); if (unlikely(!__pyx_tuple__122)) __PYX_ERR(3, 7222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__122); + __Pyx_GIVEREF(__pyx_tuple__122); - /* "PyCafe.pyx":7016 + /* "PyCafe.pyx":7223 * 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 of type , or ") * type(valSet) */ - __pyx_tuple__128 = PyTuple_Pack(1, __pyx_kp_u_Input_data_whether_within_a_list); if (unlikely(!__pyx_tuple__128)) __PYX_ERR(3, 7016, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__128); - __Pyx_GIVEREF(__pyx_tuple__128); + __pyx_tuple__123 = PyTuple_Pack(1, __pyx_kp_u_Input_data_whether_within_a_list); if (unlikely(!__pyx_tuple__123)) __PYX_ERR(3, 7223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__123); + __Pyx_GIVEREF(__pyx_tuple__123); - /* "PyCafe.pyx":7045 + /* "PyCafe.pyx":7252 * 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 of type \ * if handles or if PVs") */ - __pyx_tuple__129 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s); if (unlikely(!__pyx_tuple__129)) __PYX_ERR(3, 7045, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__129); - __Pyx_GIVEREF(__pyx_tuple__129); + __pyx_tuple__124 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s); if (unlikely(!__pyx_tuple__124)) __PYX_ERR(3, 7252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__124); + __Pyx_GIVEREF(__pyx_tuple__124); - /* "PyCafe.pyx":7091 + /* "PyCafe.pyx":7298 * pvd[i].setInt(valList[i]) * else: * print("This line in PyCafe def setScalarList should never appear!") # <<<<<<<<<<<<<< * * cdef int status = ICAFE_NORMAL */ - __pyx_tuple__130 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_setScala); if (unlikely(!__pyx_tuple__130)) __PYX_ERR(3, 7091, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__130); - __Pyx_GIVEREF(__pyx_tuple__130); + __pyx_tuple__125 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_setScala); if (unlikely(!__pyx_tuple__125)) __PYX_ERR(3, 7298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__125); + __Pyx_GIVEREF(__pyx_tuple__125); - /* "PyCafe.pyx":7133 + /* "PyCafe.pyx":7340 * else: * if not isinstance(handleList, (list)): * raise Exception("EXCEPTION RAISED IN PyCafe def setCompoundList. \n\ # <<<<<<<<<<<<<< * First input argument, should be of handles or PVs") * */ - __pyx_tuple__131 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_3); if (unlikely(!__pyx_tuple__131)) __PYX_ERR(3, 7133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__131); - __Pyx_GIVEREF(__pyx_tuple__131); + __pyx_tuple__126 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_3); if (unlikely(!__pyx_tuple__126)) __PYX_ERR(3, 7340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__126); + __Pyx_GIVEREF(__pyx_tuple__126); - /* "PyCafe.pyx":7139 + /* "PyCafe.pyx":7346 * 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 of type if handles or if PVs") * */ - __pyx_tuple__132 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_4); if (unlikely(!__pyx_tuple__132)) __PYX_ERR(3, 7139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__132); - __Pyx_GIVEREF(__pyx_tuple__132); + __pyx_tuple__127 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_4); if (unlikely(!__pyx_tuple__127)) __PYX_ERR(3, 7346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__127); + __Pyx_GIVEREF(__pyx_tuple__127); - /* "PyCafe.pyx":7198 + /* "PyCafe.pyx":7405 * * 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 of type , , , ") */ - __pyx_tuple__133 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_setCompo); if (unlikely(!__pyx_tuple__133)) __PYX_ERR(3, 7198, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__133); - __Pyx_GIVEREF(__pyx_tuple__133); + __pyx_tuple__128 = PyTuple_Pack(1, __pyx_kp_u_This_line_in_PyCafe_def_setCompo); if (unlikely(!__pyx_tuple__128)) __PYX_ERR(3, 7405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__128); + __Pyx_GIVEREF(__pyx_tuple__128); - /* "PyCafe.pyx":7199 + /* "PyCafe.pyx":7406 * 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 of type , , , ") * */ - __pyx_tuple__134 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_6); if (unlikely(!__pyx_tuple__134)) __PYX_ERR(3, 7199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__134); - __Pyx_GIVEREF(__pyx_tuple__134); + __pyx_tuple__129 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_6); if (unlikely(!__pyx_tuple__129)) __PYX_ERR(3, 7406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__129); + __Pyx_GIVEREF(__pyx_tuple__129); - /* "PyCafe.pyx":7297 + /* "PyCafe.pyx":7504 * 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 of type , , , ") * */ - __pyx_tuple__136 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_7); if (unlikely(!__pyx_tuple__136)) __PYX_ERR(3, 7297, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__136); - __Pyx_GIVEREF(__pyx_tuple__136); + __pyx_tuple__131 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_7); if (unlikely(!__pyx_tuple__131)) __PYX_ERR(3, 7504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__131); + __Pyx_GIVEREF(__pyx_tuple__131); - /* "PyCafe.pyx":7337 + /* "PyCafe.pyx":7544 * * 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!") * */ - __pyx_tuple__137 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_8); if (unlikely(!__pyx_tuple__137)) __PYX_ERR(3, 7337, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__137); - __Pyx_GIVEREF(__pyx_tuple__137); + __pyx_tuple__132 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_8); if (unlikely(!__pyx_tuple__132)) __PYX_ERR(3, 7544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__132); + __Pyx_GIVEREF(__pyx_tuple__132); - /* "PyCafe.pyx":7341 + /* "PyCafe.pyx":7548 * * 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!") * */ - __pyx_tuple__138 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_9); if (unlikely(!__pyx_tuple__138)) __PYX_ERR(3, 7341, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__138); - __Pyx_GIVEREF(__pyx_tuple__138); + __pyx_tuple__133 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_s_9); if (unlikely(!__pyx_tuple__133)) __PYX_ERR(3, 7548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__133); + __Pyx_GIVEREF(__pyx_tuple__133); - /* "PyCafe.pyx":7539 + /* "PyCafe.pyx":7746 * * 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!") * */ - __pyx_tuple__139 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_m_2); if (unlikely(!__pyx_tuple__139)) __PYX_ERR(3, 7539, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__139); - __Pyx_GIVEREF(__pyx_tuple__139); + __pyx_tuple__134 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_IN_PyCafe_def_m_2); if (unlikely(!__pyx_tuple__134)) __PYX_ERR(3, 7746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__134); + __Pyx_GIVEREF(__pyx_tuple__134); - /* "PyCafe.pyx":7716 + /* "PyCafe.pyx":7923 * if PYCAFE_PRINT_LEVEL >= PYCAFE_PRINT_LOW: * self._c_cafe.printStatusMessage(ECAFE_INVALID_HANDLE) * raise Exception( # <<<<<<<<<<<<<< * "EXCEPTION RAISED in PyCafe def setNelemToRetrieveFromCacheToOne") * */ - __pyx_tuple__140 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_s_3); if (unlikely(!__pyx_tuple__140)) __PYX_ERR(3, 7716, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__140); - __Pyx_GIVEREF(__pyx_tuple__140); + __pyx_tuple__135 = PyTuple_Pack(1, __pyx_kp_u_EXCEPTION_RAISED_in_PyCafe_def_s_3); if (unlikely(!__pyx_tuple__135)) __PYX_ERR(3, 7923, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__135); + __Pyx_GIVEREF(__pyx_tuple__135); /* "(tree fragment)":2 * def __reduce_cython__(self): @@ -149987,95 +153616,95 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__141 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__141)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__141); - __Pyx_GIVEREF(__pyx_tuple__141); + __pyx_tuple__136 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__136)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__136); + __Pyx_GIVEREF(__pyx_tuple__136); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__142 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__142)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__142); - __Pyx_GIVEREF(__pyx_tuple__142); + __pyx_tuple__137 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__137)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__137); + __Pyx_GIVEREF(__pyx_tuple__137); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ - __pyx_tuple__143 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__143)) __PYX_ERR(4, 272, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__143); - __Pyx_GIVEREF(__pyx_tuple__143); + __pyx_tuple__138 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__138)) __PYX_ERR(4, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__138); + __Pyx_GIVEREF(__pyx_tuple__138); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ - __pyx_tuple__144 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__144)) __PYX_ERR(4, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__144); - __Pyx_GIVEREF(__pyx_tuple__144); + __pyx_tuple__139 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__139)) __PYX_ERR(4, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__139); + __Pyx_GIVEREF(__pyx_tuple__139); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ - __pyx_tuple__145 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__145)) __PYX_ERR(4, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__145); - __Pyx_GIVEREF(__pyx_tuple__145); + __pyx_tuple__140 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__140)) __PYX_ERR(4, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__140); + __Pyx_GIVEREF(__pyx_tuple__140); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ - __pyx_tuple__146 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__146)) __PYX_ERR(4, 856, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__146); - __Pyx_GIVEREF(__pyx_tuple__146); + __pyx_tuple__141 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__141)) __PYX_ERR(4, 856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__141); + __Pyx_GIVEREF(__pyx_tuple__141); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_tuple__147 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__147)) __PYX_ERR(4, 880, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__147); - __Pyx_GIVEREF(__pyx_tuple__147); + __pyx_tuple__142 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__142)) __PYX_ERR(4, 880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__142); + __Pyx_GIVEREF(__pyx_tuple__142); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_tuple__148 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__148)) __PYX_ERR(4, 1038, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__148); - __Pyx_GIVEREF(__pyx_tuple__148); + __pyx_tuple__143 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__143)) __PYX_ERR(4, 1038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__143); + __Pyx_GIVEREF(__pyx_tuple__143); - /* "../../../../../../../opt/gfa/python-3.7/latest/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 + /* "../../../../../../../opt/gfa/python-3.7/2018.12/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_tuple__149 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__149)) __PYX_ERR(4, 1044, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__149); - __Pyx_GIVEREF(__pyx_tuple__149); + __pyx_tuple__144 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__144)) __PYX_ERR(4, 1044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__144); + __Pyx_GIVEREF(__pyx_tuple__144); /* "View.MemoryView":133 * @@ -150084,9 +153713,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * if itemsize <= 0: */ - __pyx_tuple__150 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__150)) __PYX_ERR(1, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__150); - __Pyx_GIVEREF(__pyx_tuple__150); + __pyx_tuple__145 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__145)) __PYX_ERR(1, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__145); + __Pyx_GIVEREF(__pyx_tuple__145); /* "View.MemoryView":136 * @@ -150095,9 +153724,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * if not isinstance(format, bytes): */ - __pyx_tuple__151 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__151)) __PYX_ERR(1, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__151); - __Pyx_GIVEREF(__pyx_tuple__151); + __pyx_tuple__146 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__146)) __PYX_ERR(1, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__146); + __Pyx_GIVEREF(__pyx_tuple__146); /* "View.MemoryView":148 * @@ -150106,9 +153735,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__152 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__152)) __PYX_ERR(1, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__152); - __Pyx_GIVEREF(__pyx_tuple__152); + __pyx_tuple__147 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__147)) __PYX_ERR(1, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__147); + __Pyx_GIVEREF(__pyx_tuple__147); /* "View.MemoryView":176 * self.data = malloc(self.len) @@ -150117,9 +153746,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * if self.dtype_is_object: */ - __pyx_tuple__153 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__153)) __PYX_ERR(1, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__153); - __Pyx_GIVEREF(__pyx_tuple__153); + __pyx_tuple__148 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__148)) __PYX_ERR(1, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__148); + __Pyx_GIVEREF(__pyx_tuple__148); /* "View.MemoryView":192 * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS @@ -150128,9 +153757,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * info.buf = self.data * info.len = self.len */ - __pyx_tuple__154 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__154)) __PYX_ERR(1, 192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__154); - __Pyx_GIVEREF(__pyx_tuple__154); + __pyx_tuple__149 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__149)) __PYX_ERR(1, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__149); + __Pyx_GIVEREF(__pyx_tuple__149); /* "(tree fragment)":2 * def __reduce_cython__(self): @@ -150138,18 +153767,18 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__155 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__155)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__155); - __Pyx_GIVEREF(__pyx_tuple__155); + __pyx_tuple__150 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__150)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__150); + __Pyx_GIVEREF(__pyx_tuple__150); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__156 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__156)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__156); - __Pyx_GIVEREF(__pyx_tuple__156); + __pyx_tuple__151 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__151)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__151); + __Pyx_GIVEREF(__pyx_tuple__151); /* "View.MemoryView":414 * def __setitem__(memoryview self, object index, object value): @@ -150158,9 +153787,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * have_slices, index = _unellipsify(index, self.view.ndim) */ - __pyx_tuple__157 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__157)) __PYX_ERR(1, 414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__157); - __Pyx_GIVEREF(__pyx_tuple__157); + __pyx_tuple__152 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__152)) __PYX_ERR(1, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__152); + __Pyx_GIVEREF(__pyx_tuple__152); /* "View.MemoryView":491 * result = struct.unpack(self.view.format, bytesitem) @@ -150169,9 +153798,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * else: * if len(self.view.format) == 1: */ - __pyx_tuple__158 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__158)) __PYX_ERR(1, 491, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__158); - __Pyx_GIVEREF(__pyx_tuple__158); + __pyx_tuple__153 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__153)) __PYX_ERR(1, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__153); + __Pyx_GIVEREF(__pyx_tuple__153); /* "View.MemoryView":516 * def __getbuffer__(self, Py_buffer *info, int flags): @@ -150180,9 +153809,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * if flags & PyBUF_ND: */ - __pyx_tuple__159 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__159)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__159); - __Pyx_GIVEREF(__pyx_tuple__159); + __pyx_tuple__154 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__154)) __PYX_ERR(1, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__154); + __Pyx_GIVEREF(__pyx_tuple__154); /* "View.MemoryView":566 * if self.view.strides == NULL: @@ -150191,9 +153820,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) */ - __pyx_tuple__160 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__160)) __PYX_ERR(1, 566, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__160); - __Pyx_GIVEREF(__pyx_tuple__160); + __pyx_tuple__155 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__155)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__155); + __Pyx_GIVEREF(__pyx_tuple__155); /* "View.MemoryView":573 * def suboffsets(self): @@ -150202,12 +153831,12 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) */ - __pyx_tuple__161 = PyTuple_New(1); if (unlikely(!__pyx_tuple__161)) __PYX_ERR(1, 573, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__161); + __pyx_tuple__156 = PyTuple_New(1); if (unlikely(!__pyx_tuple__156)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__156); __Pyx_INCREF(__pyx_int_neg_1); __Pyx_GIVEREF(__pyx_int_neg_1); - PyTuple_SET_ITEM(__pyx_tuple__161, 0, __pyx_int_neg_1); - __Pyx_GIVEREF(__pyx_tuple__161); + PyTuple_SET_ITEM(__pyx_tuple__156, 0, __pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_tuple__156); /* "(tree fragment)":2 * def __reduce_cython__(self): @@ -150215,18 +153844,18 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__162 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__162)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__162); - __Pyx_GIVEREF(__pyx_tuple__162); + __pyx_tuple__157 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__157)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__157); + __Pyx_GIVEREF(__pyx_tuple__157); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__163 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__163)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__163); - __Pyx_GIVEREF(__pyx_tuple__163); + __pyx_tuple__158 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__158)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__158); + __Pyx_GIVEREF(__pyx_tuple__158); /* "View.MemoryView":678 * if item is Ellipsis: @@ -150235,9 +153864,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * seen_ellipsis = True * else: */ - __pyx_slice__164 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__164)) __PYX_ERR(1, 678, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__164); - __Pyx_GIVEREF(__pyx_slice__164); + __pyx_slice__159 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__159)) __PYX_ERR(1, 678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__159); + __Pyx_GIVEREF(__pyx_slice__159); /* "View.MemoryView":699 * for suboffset in suboffsets[:ndim]: @@ -150246,9 +153875,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__165 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__165)) __PYX_ERR(1, 699, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__165); - __Pyx_GIVEREF(__pyx_tuple__165); + __pyx_tuple__160 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__160)) __PYX_ERR(1, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__160); + __Pyx_GIVEREF(__pyx_tuple__160); /* "(tree fragment)":2 * def __reduce_cython__(self): @@ -150256,18 +153885,18 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__166 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__166)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__166); - __Pyx_GIVEREF(__pyx_tuple__166); + __pyx_tuple__161 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__161)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__161); + __Pyx_GIVEREF(__pyx_tuple__161); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__167 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__167)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__167); - __Pyx_GIVEREF(__pyx_tuple__167); + __pyx_tuple__162 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__162)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__162); + __Pyx_GIVEREF(__pyx_tuple__162); /* "PyCafe.pyx":45 * @@ -150276,9 +153905,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * _appname = _pymodule_parts[0] * */ - __pyx_tuple__169 = PyTuple_Pack(1, __pyx_kp_u__168); if (unlikely(!__pyx_tuple__169)) __PYX_ERR(3, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__169); - __Pyx_GIVEREF(__pyx_tuple__169); + __pyx_tuple__164 = PyTuple_Pack(1, __pyx_kp_u__163); if (unlikely(!__pyx_tuple__164)) __PYX_ERR(3, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__164); + __Pyx_GIVEREF(__pyx_tuple__164); /* "PyCafe.pyx":54 * include "PyCafeDefs.pxi" @@ -150287,20 +153916,20 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Decorator to validate handle/PV input argument. * */ - __pyx_tuple__170 = PyTuple_Pack(3, __pyx_n_s_func, __pyx_n_s_wrapper, __pyx_n_s_wrapper); if (unlikely(!__pyx_tuple__170)) __PYX_ERR(3, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__170); - __Pyx_GIVEREF(__pyx_tuple__170); - __pyx_codeobj__171 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__170, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PyCafe_pyx, __pyx_n_s_verify_handlepv, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__171)) __PYX_ERR(3, 54, __pyx_L1_error) + __pyx_tuple__165 = PyTuple_Pack(3, __pyx_n_s_func, __pyx_n_s_wrapper, __pyx_n_s_wrapper); if (unlikely(!__pyx_tuple__165)) __PYX_ERR(3, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__165); + __Pyx_GIVEREF(__pyx_tuple__165); + __pyx_codeobj__166 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__165, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PyCafe_pyx, __pyx_n_s_verify_handlepv, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__166)) __PYX_ERR(3, 54, __pyx_L1_error) /* "(tree fragment)":1 * def __pyx_unpickle_CafeException(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ - __pyx_tuple__172 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__172)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__172); - __Pyx_GIVEREF(__pyx_tuple__172); - __pyx_codeobj__173 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__172, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_CafeException, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__173)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_tuple__167 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__167)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__167); + __Pyx_GIVEREF(__pyx_tuple__167); + __pyx_codeobj__168 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__167, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_CafeException, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__168)) __PYX_ERR(1, 1, __pyx_L1_error) /* "View.MemoryView":286 * return self.name @@ -150309,9 +153938,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef strided = Enum("") # default * cdef indirect = Enum("") */ - __pyx_tuple__174 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__174)) __PYX_ERR(1, 286, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__174); - __Pyx_GIVEREF(__pyx_tuple__174); + __pyx_tuple__169 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__169)) __PYX_ERR(1, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__169); + __Pyx_GIVEREF(__pyx_tuple__169); /* "View.MemoryView":287 * @@ -150320,9 +153949,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef indirect = Enum("") * */ - __pyx_tuple__175 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__175)) __PYX_ERR(1, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__175); - __Pyx_GIVEREF(__pyx_tuple__175); + __pyx_tuple__170 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__170)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__170); + __Pyx_GIVEREF(__pyx_tuple__170); /* "View.MemoryView":288 * cdef generic = Enum("") @@ -150331,9 +153960,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__176 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__176)) __PYX_ERR(1, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__176); - __Pyx_GIVEREF(__pyx_tuple__176); + __pyx_tuple__171 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__171)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__171); + __Pyx_GIVEREF(__pyx_tuple__171); /* "View.MemoryView":291 * @@ -150342,9 +153971,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef indirect_contiguous = Enum("") * */ - __pyx_tuple__177 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__177)) __PYX_ERR(1, 291, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__177); - __Pyx_GIVEREF(__pyx_tuple__177); + __pyx_tuple__172 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__172)) __PYX_ERR(1, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__172); + __Pyx_GIVEREF(__pyx_tuple__172); /* "View.MemoryView":292 * @@ -150353,19 +153982,19 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__178 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__178)) __PYX_ERR(1, 292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__178); - __Pyx_GIVEREF(__pyx_tuple__178); + __pyx_tuple__173 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__173)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__173); + __Pyx_GIVEREF(__pyx_tuple__173); /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ - __pyx_tuple__179 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__179)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__179); - __Pyx_GIVEREF(__pyx_tuple__179); - __pyx_codeobj__180 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__179, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__180)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_tuple__174 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__174)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__174); + __Pyx_GIVEREF(__pyx_tuple__174); + __pyx_codeobj__175 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__174, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__175)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -151032,7 +154661,7 @@ if (!__Pyx_RefNanny) { __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__169, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 45, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__164, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_pymodule_parts, __pyx_t_1) < 0) __PYX_ERR(3, 45, __pyx_L1_error) @@ -151174,24 +154803,24 @@ if (!__Pyx_RefNanny) { if (PyDict_SetItem(__pyx_d, __pyx_n_s_verify_handlepv, __pyx_t_1) < 0) __PYX_ERR(3, 54, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "PyCafe.pyx":238 + /* "PyCafe.pyx":237 * return EPICS_VERSION * * @verify_handlepv # <<<<<<<<<<<<<< * def setPyConnectCallbackFn(self, handlePV, cb: object = None): * if cb is None: */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 238, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":239 + /* "PyCafe.pyx":238 * * @verify_handlepv * def setPyConnectCallbackFn(self, handlePV, cb: object = None): # <<<<<<<<<<<<<< * if cb is None: * return */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_setPyConnectCallbackFn); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 239, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_setPyConnectCallbackFn); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151206,31 +154835,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 238, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_setPyConnectCallbackFn, __pyx_t_1) < 0) __PYX_ERR(3, 239, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_setPyConnectCallbackFn, __pyx_t_1) < 0) __PYX_ERR(3, 238, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1371 + /* "PyCafe.pyx":1370 * ############################################################################ * * @verify_handlepv # <<<<<<<<<<<<<< * def isConnected(self, handlePV): * cdef str _METHOD = "isConnected" */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1371, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1372 + /* "PyCafe.pyx":1371 * * @verify_handlepv * def isConnected(self, handlePV): # <<<<<<<<<<<<<< * cdef str _METHOD = "isConnected" * return self._c_cafe.isChannelConnected(handlePV) */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_isConnected); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1372, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_isConnected); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151245,31 +154874,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1371, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_isConnected, __pyx_t_1) < 0) __PYX_ERR(3, 1372, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_isConnected, __pyx_t_1) < 0) __PYX_ERR(3, 1371, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1395 + /* "PyCafe.pyx":1394 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def supplementHandle(self, handlePV): * #decorator casts handlePV to int */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1395, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1396 + /* "PyCafe.pyx":1395 * ############################################################################ * @verify_handlepv * def supplementHandle(self, handlePV): # <<<<<<<<<<<<<< * #decorator casts handlePV to int * cdef unsigned int handle = handlePV */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_supplementHandle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1396, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_supplementHandle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151284,31 +154913,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1395, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_supplementHandle, __pyx_t_1) < 0) __PYX_ERR(3, 1396, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_supplementHandle, __pyx_t_1) < 0) __PYX_ERR(3, 1395, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1438 + /* "PyCafe.pyx":1437 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def printHandle(self, handlePV): * self._c_cafe.printHandle(handlePV) */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1438, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1439 + /* "PyCafe.pyx":1438 * ############################################################################ * @verify_handlepv * def printHandle(self, handlePV): # <<<<<<<<<<<<<< * self._c_cafe.printHandle(handlePV) * */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_printHandle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1439, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_printHandle); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151323,31 +154952,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1438, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_printHandle, __pyx_t_1) < 0) __PYX_ERR(3, 1439, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_printHandle, __pyx_t_1) < 0) __PYX_ERR(3, 1438, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1514 + /* "PyCafe.pyx":1513 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getStatus(self, handlePV): * return self.hh.getStatus(handlePV) */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1514, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1513, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1515 + /* "PyCafe.pyx":1514 * ############################################################################ * @verify_handlepv * def getStatus(self, handlePV): # <<<<<<<<<<<<<< * return self.hh.getStatus(handlePV) * */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1515, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getStatus); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151362,31 +154991,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1514, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1513, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getStatus, __pyx_t_1) < 0) __PYX_ERR(3, 1515, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getStatus, __pyx_t_1) < 0) __PYX_ERR(3, 1514, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1568 + /* "PyCafe.pyx":1567 * ############################################################################ * * @verify_handlepv # <<<<<<<<<<<<<< * def getDescription(self, handlePV): * cdef unsigned int handle = handlePV */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1568, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1569 + /* "PyCafe.pyx":1568 * * @verify_handlepv * def getDescription(self, handlePV): # <<<<<<<<<<<<<< * cdef unsigned int handle = handlePV * if not self.hh.hasDescription(handle): */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getDescription); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1569, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getDescription); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151401,31 +155030,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1568, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getDescription, __pyx_t_1) < 0) __PYX_ERR(3, 1569, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getDescription, __pyx_t_1) < 0) __PYX_ERR(3, 1568, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1579 + /* "PyCafe.pyx":1578 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def hasDescription(self, handlePV): * return self.hh.hasDescription(handlePV) */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1579, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1580 + /* "PyCafe.pyx":1579 * ############################################################################ * @verify_handlepv * def hasDescription(self, handlePV): # <<<<<<<<<<<<<< * return self.hh.hasDescription(handlePV) * */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_hasDescription); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1580, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_hasDescription); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151440,31 +155069,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1579, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_hasDescription, __pyx_t_1) < 0) __PYX_ERR(3, 1580, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_hasDescription, __pyx_t_1) < 0) __PYX_ERR(3, 1579, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1584 + /* "PyCafe.pyx":1583 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getUnits(self, handlePV): * cdef string valString */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1584, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1585 + /* "PyCafe.pyx":1584 * ############################################################################ * @verify_handlepv * def getUnits(self, handlePV): # <<<<<<<<<<<<<< * cdef string valString * self.hh.getUnits(handlePV, valString) */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getUnits); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1585, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getUnits); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1584, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151479,31 +155108,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1584, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getUnits, __pyx_t_1) < 0) __PYX_ERR(3, 1585, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getUnits, __pyx_t_1) < 0) __PYX_ERR(3, 1584, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1594 + /* "PyCafe.pyx":1593 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getPrecision(self, handlePV): * cdef short precision = 0 */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1594, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1595 + /* "PyCafe.pyx":1594 * ############################################################################ * @verify_handlepv * def getPrecision(self, handlePV): # <<<<<<<<<<<<<< * cdef short precision = 0 * self.hh.getPrecision(handlePV, precision) */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getPrecision); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1595, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getPrecision); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151518,31 +155147,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1594, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getPrecision, __pyx_t_1) < 0) __PYX_ERR(3, 1595, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getPrecision, __pyx_t_1) < 0) __PYX_ERR(3, 1594, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1601 + /* "PyCafe.pyx":1600 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def hasAlarmStatusSeverity(self, handlePV): * return self.hh.hasAlarmStatusSeverity(handlePV) */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1601, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1602 + /* "PyCafe.pyx":1601 * ############################################################################ * @verify_handlepv * def hasAlarmStatusSeverity(self, handlePV): # <<<<<<<<<<<<<< * return self.hh.hasAlarmStatusSeverity(handlePV) * */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_hasAlarmStatusSeverity); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1602, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_hasAlarmStatusSeverity); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151557,31 +155186,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1601, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_hasAlarmStatusSeverity, __pyx_t_1) < 0) __PYX_ERR(3, 1602, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_hasAlarmStatusSeverity, __pyx_t_1) < 0) __PYX_ERR(3, 1601, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1606 + /* "PyCafe.pyx":1605 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getAlarmStatusSeverity(self, handlePV): * cdef short aStatSev[2] */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1606, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1607 + /* "PyCafe.pyx":1606 * ############################################################################ * @verify_handlepv * def getAlarmStatusSeverity(self, handlePV): # <<<<<<<<<<<<<< * cdef short aStatSev[2] * self.hh.getAlarmStatusSeverity(handlePV, aStatSev) */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getAlarmStatusSeverity); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1607, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getAlarmStatusSeverity); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1606, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151596,31 +155225,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1606, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getAlarmStatusSeverity, __pyx_t_1) < 0) __PYX_ERR(3, 1607, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getAlarmStatusSeverity, __pyx_t_1) < 0) __PYX_ERR(3, 1606, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1613 + /* "PyCafe.pyx":1612 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getTimeStamp(self, handlePV): * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1613, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1614 + /* "PyCafe.pyx":1613 * ############################################################################ * @verify_handlepv * def getTimeStamp(self, handlePV): # <<<<<<<<<<<<<< * * cdef HandleHelper hh */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getTimeStamp); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1614, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getTimeStamp); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1613, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151635,31 +155264,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1613, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getTimeStamp, __pyx_t_1) < 0) __PYX_ERR(3, 1614, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getTimeStamp, __pyx_t_1) < 0) __PYX_ERR(3, 1613, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1626 + /* "PyCafe.pyx":1625 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getTimeStampAsDate(self, handlePV): * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1626, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1625, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1627 + /* "PyCafe.pyx":1626 * ############################################################################ * @verify_handlepv * def getTimeStampAsDate(self, handlePV): # <<<<<<<<<<<<<< * * cdef HandleHelper hh */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getTimeStampAsDate); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1627, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getTimeStampAsDate); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151674,31 +155303,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1626, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1625, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getTimeStampAsDate, __pyx_t_1) < 0) __PYX_ERR(3, 1627, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getTimeStampAsDate, __pyx_t_1) < 0) __PYX_ERR(3, 1626, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1787 + /* "PyCafe.pyx":1786 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getChannelInfo(self, handlePV): * cdef str _METHOD = "getChannelInfo(handlePV)" */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1787, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1788 + /* "PyCafe.pyx":1787 * ############################################################################ * @verify_handlepv * def getChannelInfo(self, handlePV): # <<<<<<<<<<<<<< * cdef str _METHOD = "getChannelInfo(handlePV)" * */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getChannelInfo); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1788, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getChannelInfo); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151713,31 +155342,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1787, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getChannelInfo, __pyx_t_1) < 0) __PYX_ERR(3, 1788, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getChannelInfo, __pyx_t_1) < 0) __PYX_ERR(3, 1787, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1811 + /* "PyCafe.pyx":1810 * * ################################################################################## * @verify_handlepv # <<<<<<<<<<<<<< * def getWFAsString(self, handlePV, cache: bool = False): * cdef str _METHOD = "getWFAsString" */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1811, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1812 + /* "PyCafe.pyx":1811 * ################################################################################## * @verify_handlepv * def getWFAsString(self, handlePV, cache: bool = False): # <<<<<<<<<<<<<< * cdef str _METHOD = "getWFAsString" * cdef string strWF */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getWFAsString); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1812, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getWFAsString); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1811, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151752,31 +155381,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1811, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getWFAsString, __pyx_t_1) < 0) __PYX_ERR(3, 1812, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getWFAsString, __pyx_t_1) < 0) __PYX_ERR(3, 1811, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1872 + /* "PyCafe.pyx":1871 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def isEnum(self, handlePV): * return self._c_cafe.isEnum(handlePV) */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1872, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1871, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1873 + /* "PyCafe.pyx":1872 * ############################################################################ * @verify_handlepv * def isEnum(self, handlePV): # <<<<<<<<<<<<<< * return self._c_cafe.isEnum(handlePV) * ############################################################################ */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_isEnum); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1873, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_isEnum); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1872, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151791,31 +155420,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1872, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1871, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_isEnum, __pyx_t_1) < 0) __PYX_ERR(3, 1873, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_isEnum, __pyx_t_1) < 0) __PYX_ERR(3, 1872, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1878 + /* "PyCafe.pyx":1877 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getEnumStrings(self, handlePV): * return self.hh.getEnumStrings(handlePV) */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1878, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1879 + /* "PyCafe.pyx":1878 * ############################################################################ * @verify_handlepv * def getEnumStrings(self, handlePV): # <<<<<<<<<<<<<< * return self.hh.getEnumStrings(handlePV) * */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getEnumStrings); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1879, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getEnumStrings); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151830,31 +155459,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1878, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getEnumStrings, __pyx_t_1) < 0) __PYX_ERR(3, 1879, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getEnumStrings, __pyx_t_1) < 0) __PYX_ERR(3, 1878, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1883 + /* "PyCafe.pyx":1882 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getEnumFromString(self, handlePV, str enumString): * cdef str _METHOD = "getEnumFromString" */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1883, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1884 + /* "PyCafe.pyx":1883 * ############################################################################ * @verify_handlepv * def getEnumFromString(self, handlePV, str enumString): # <<<<<<<<<<<<<< * cdef str _METHOD = "getEnumFromString" * cdef short enumValue */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getEnumFromString); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1884, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getEnumFromString); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151869,31 +155498,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1883, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getEnumFromString, __pyx_t_1) < 0) __PYX_ERR(3, 1884, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getEnumFromString, __pyx_t_1) < 0) __PYX_ERR(3, 1883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1897 + /* "PyCafe.pyx":1896 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getStringFromEnum(self, handlePV, unsigned short enumValue = 0): * cdef str _METHOD = "getStringFromEnum" */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1897, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1898 + /* "PyCafe.pyx":1897 * ############################################################################ * @verify_handlepv * def getStringFromEnum(self, handlePV, unsigned short enumValue = 0): # <<<<<<<<<<<<<< * cdef str _METHOD = "getStringFromEnum" * cdef string enumString = self.hh.getStringFromEnum(handlePV, enumValue) */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getStringFromEnum); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1898, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getStringFromEnum); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151908,31 +155537,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1897, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getStringFromEnum, __pyx_t_1) < 0) __PYX_ERR(3, 1898, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getStringFromEnum, __pyx_t_1) < 0) __PYX_ERR(3, 1897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1920 + /* "PyCafe.pyx":1919 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def setDbrBase(self, handlePV, DBR_TYPE dbrBase): * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1920, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1919, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1921 + /* "PyCafe.pyx":1920 * ############################################################################ * @verify_handlepv * def setDbrBase(self, handlePV, DBR_TYPE dbrBase): # <<<<<<<<<<<<<< * * # Print Warning Message */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_setDbrBase); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1921, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_setDbrBase); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1920, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151947,31 +155576,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1920, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1919, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_setDbrBase, __pyx_t_1) < 0) __PYX_ERR(3, 1921, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_setDbrBase, __pyx_t_1) < 0) __PYX_ERR(3, 1920, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1935 + /* "PyCafe.pyx":1934 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getDbrBase(self, handlePV): * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1935, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1934, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1936 + /* "PyCafe.pyx":1935 * ############################################################################ * @verify_handlepv * def getDbrBase(self, handlePV): # <<<<<<<<<<<<<< * * cdef DBR_TYPE _cafeDbrType = DBR_PLAIN */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getDbrBase); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1936, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getDbrBase); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1935, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -151986,31 +155615,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1935, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1934, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getDbrBase, __pyx_t_1) < 0) __PYX_ERR(3, 1936, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getDbrBase, __pyx_t_1) < 0) __PYX_ERR(3, 1935, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1946 + /* "PyCafe.pyx":1945 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def setGetCacheWaitPolicy( * self, handlePV, ChannelGetCacheWaitPolicyKind wpk): */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1946, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1947 + /* "PyCafe.pyx":1946 * ############################################################################ * @verify_handlepv * def setGetCacheWaitPolicy( # <<<<<<<<<<<<<< * self, handlePV, ChannelGetCacheWaitPolicyKind wpk): * */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_setGetCacheWaitPolicy); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1947, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_setGetCacheWaitPolicy); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1946, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152025,31 +155654,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1946, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_setGetCacheWaitPolicy, __pyx_t_1) < 0) __PYX_ERR(3, 1947, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_setGetCacheWaitPolicy, __pyx_t_1) < 0) __PYX_ERR(3, 1946, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":1997 + /* "PyCafe.pyx":1996 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def setGetActionWhenMonitorPolicy( * self, handlePV, ChannelGetActionWhenMonitorPolicyKind wmpk): */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1997, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1996, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":1998 + /* "PyCafe.pyx":1997 * ############################################################################ * @verify_handlepv * def setGetActionWhenMonitorPolicy( # <<<<<<<<<<<<<< * self, handlePV, ChannelGetActionWhenMonitorPolicyKind wmpk): * */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_setGetActionWhenMonitorPolicy); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1998, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_setGetActionWhenMonitorPolicy); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152064,31 +155693,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1997, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1996, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_setGetActionWhenMonitorPolicy, __pyx_t_1) < 0) __PYX_ERR(3, 1998, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_setGetActionWhenMonitorPolicy, __pyx_t_1) < 0) __PYX_ERR(3, 1997, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":2039 + /* "PyCafe.pyx":2038 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getNonBlocking(self, handlePV): * '''Requires cafe.ca_flush_io by user. */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2039, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2038, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":2040 + /* "PyCafe.pyx":2039 * ############################################################################ * @verify_handlepv * def getNonBlocking(self, handlePV): # <<<<<<<<<<<<<< * '''Requires cafe.ca_flush_io by user. * In this resepct, it differs from cafe.getAsync */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getNonBlocking); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2040, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getNonBlocking); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2039, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152103,31 +155732,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2039, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2038, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getNonBlocking, __pyx_t_1) < 0) __PYX_ERR(3, 2040, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getNonBlocking, __pyx_t_1) < 0) __PYX_ERR(3, 2039, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":2088 + /* "PyCafe.pyx":2087 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def get(self, handlePV = 0, str dt='native'): * cdef str _METHOD = "get(handlePV, dt)" */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2088, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2087, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":2089 + /* "PyCafe.pyx":2088 * ############################################################################ * @verify_handlepv * def get(self, handlePV = 0, str dt='native'): # <<<<<<<<<<<<<< * cdef str _METHOD = "get(handlePV, dt)" * */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2089, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2088, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152142,31 +155771,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2088, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2087, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_get, __pyx_t_1) < 0) __PYX_ERR(3, 2089, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_get, __pyx_t_1) < 0) __PYX_ERR(3, 2088, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":2249 + /* "PyCafe.pyx":2248 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getList(self, handlePV, str dt='native'): * cdef str _METHOD = "getList" */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2249, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":2250 + /* "PyCafe.pyx":2249 * ############################################################################ * @verify_handlepv * def getList(self, handlePV, str dt='native'): # <<<<<<<<<<<<<< * cdef str _METHOD = "getList" * cdef unsigned int handle = handlePV */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getList); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2250, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getList); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152181,31 +155810,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2249, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getList, __pyx_t_1) < 0) __PYX_ERR(3, 2250, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getList, __pyx_t_1) < 0) __PYX_ERR(3, 2249, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":2529 + /* "PyCafe.pyx":2528 * * ############################################################################ * @verify_handlepv # <<<<<<<<<<<<<< * def getArray(self, handlePV, str dt='native', str art='numpy'): * ############################################################################ */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2529, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":2530 + /* "PyCafe.pyx":2529 * ############################################################################ * @verify_handlepv * def getArray(self, handlePV, str dt='native', str art='numpy'): # <<<<<<<<<<<<<< * ############################################################################ * # Typed Memoryviews from K.W. Smith */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getArray); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2530, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getArray); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 2529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152220,31 +155849,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2529, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getArray, __pyx_t_1) < 0) __PYX_ERR(3, 2530, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getArray, __pyx_t_1) < 0) __PYX_ERR(3, 2529, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":3512 + /* "PyCafe.pyx":3602 * * ################################################################################## * @verify_handlepv # <<<<<<<<<<<<<< * def waitForGetEvent(self, handlePV): * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3512, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":3513 + /* "PyCafe.pyx":3603 * ################################################################################## * @verify_handlepv * def waitForGetEvent(self, handlePV): # <<<<<<<<<<<<<< * * cdef unsigned int handle = handlePV */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_waitForGetEvent); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3513, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_waitForGetEvent); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3603, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152259,14 +155888,14 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3512, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_waitForGetEvent, __pyx_t_1) < 0) __PYX_ERR(3, 3513, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_waitForGetEvent, __pyx_t_1) < 0) __PYX_ERR(3, 3603, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":5495 + /* "PyCafe.pyx":5700 * return mp * * def groupMonitor(self, ghandleName, object cb=None, DBR_TYPE dbr=DBR_TIME, # <<<<<<<<<<<<<< @@ -152275,7 +155904,7 @@ if (!__Pyx_RefNanny) { */ __pyx_k__91 = DBR_TIME; - /* "PyCafe.pyx":5496 + /* "PyCafe.pyx":5701 * * def groupMonitor(self, ghandleName, object cb=None, DBR_TYPE dbr=DBR_TIME, * unsigned int mask=DBE_VALUE | DBE_LOG | DBE_ALARM, # <<<<<<<<<<<<<< @@ -152284,7 +155913,7 @@ if (!__Pyx_RefNanny) { */ __pyx_k__92 = ((DBE_VALUE | DBE_LOG) | DBE_ALARM); - /* "PyCafe.pyx":5502 + /* "PyCafe.pyx":5707 * ################################################################################## * def groupMonitorStart(self, ghandleName, object cb=None, * DBR_TYPE dbr=DBR_TIME, # <<<<<<<<<<<<<< @@ -152293,7 +155922,7 @@ if (!__Pyx_RefNanny) { */ __pyx_k__93 = DBR_TIME; - /* "PyCafe.pyx":5503 + /* "PyCafe.pyx":5708 * def groupMonitorStart(self, ghandleName, object cb=None, * DBR_TYPE dbr=DBR_TIME, * unsigned int mask=DBE_VALUE | DBE_LOG | DBE_ALARM, # <<<<<<<<<<<<<< @@ -152302,42 +155931,42 @@ if (!__Pyx_RefNanny) { */ __pyx_k__94 = ((DBE_VALUE | DBE_LOG) | DBE_ALARM); - /* "PyCafe.pyx":5585 + /* "PyCafe.pyx":5792 * def groupMonitorStartWithCBList(self, * ghandleName, list cb=None, * DBR_TYPE dbr=DBR_TIME, # <<<<<<<<<<<<<< * unsigned int mask=\ * DBE_VALUE | DBE_LOG | DBE_ALARM, */ - __pyx_k__99 = DBR_TIME; + __pyx_k__97 = DBR_TIME; - /* "PyCafe.pyx":5587 + /* "PyCafe.pyx":5794 * DBR_TYPE dbr=DBR_TIME, * unsigned int mask=\ * DBE_VALUE | DBE_LOG | DBE_ALARM, # <<<<<<<<<<<<<< * unsigned short notify_milliseconds=0): * ############################################################################ */ - __pyx_k__100 = ((DBE_VALUE | DBE_LOG) | DBE_ALARM); + __pyx_k__98 = ((DBE_VALUE | DBE_LOG) | DBE_ALARM); - /* "PyCafe.pyx":6404 + /* "PyCafe.pyx":6611 * * ################################################################################## * @verify_handlepv # <<<<<<<<<<<<<< * def getNoMonitors(self, handlePV): * cdef unsigned int handle = handlePV */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6404, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":6405 + /* "PyCafe.pyx":6612 * ################################################################################## * @verify_handlepv * def getNoMonitors(self, handlePV): # <<<<<<<<<<<<<< * cdef unsigned int handle = handlePV * return self.hh.getNmonitor(handle) */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getNoMonitors); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6405, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getNoMonitors); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152352,31 +155981,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6404, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getNoMonitors, __pyx_t_1) < 0) __PYX_ERR(3, 6405, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getNoMonitors, __pyx_t_1) < 0) __PYX_ERR(3, 6612, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":6412 + /* "PyCafe.pyx":6619 * * ################################################################################## * @verify_handlepv # <<<<<<<<<<<<<< * def getMonitorIDsInWaiting(self, handlePV): * cdef unsigned int handle = handlePV */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6412, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":6413 + /* "PyCafe.pyx":6620 * ################################################################################## * @verify_handlepv * def getMonitorIDsInWaiting(self, handlePV): # <<<<<<<<<<<<<< * cdef unsigned int handle = handlePV * return self.hh.getMonitorIDsInWaiting(handle) */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getMonitorIDsInWaiting); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6413, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getMonitorIDsInWaiting); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6620, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152391,31 +156020,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6412, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getMonitorIDsInWaiting, __pyx_t_1) < 0) __PYX_ERR(3, 6413, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getMonitorIDsInWaiting, __pyx_t_1) < 0) __PYX_ERR(3, 6620, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":6420 + /* "PyCafe.pyx":6627 * * ################################################################################## * @verify_handlepv # <<<<<<<<<<<<<< * def getMonitorIDs(self, handlePV): * cdef unsigned int handle = handlePV */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6420, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6627, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":6421 + /* "PyCafe.pyx":6628 * ################################################################################## * @verify_handlepv * def getMonitorIDs(self, handlePV): # <<<<<<<<<<<<<< * cdef unsigned int handle = handlePV * return self.hh.getMonitorIDs(handle) */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getMonitorIDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6421, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_getMonitorIDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152430,31 +156059,31 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6420, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6627, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getMonitorIDs, __pyx_t_1) < 0) __PYX_ERR(3, 6421, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_getMonitorIDs, __pyx_t_1) < 0) __PYX_ERR(3, 6628, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":6426 + /* "PyCafe.pyx":6633 * ############################################################################ * * @verify_handlepv # <<<<<<<<<<<<<< * def updateMonitorPolicyDeltaMS( * self, handlePV, unsigned int monid=0, unsigned int deltaMS=0): */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6426, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_verify_handlepv); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 6633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "PyCafe.pyx":6427 + /* "PyCafe.pyx":6634 * * @verify_handlepv * def updateMonitorPolicyDeltaMS( # <<<<<<<<<<<<<< * self, handlePV, unsigned int monid=0, unsigned int deltaMS=0): * cdef unsigned int handle = handlePV */ - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_updateMonitorPolicyDeltaMS); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6427, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6PyCafe_CyCafe, __pyx_n_s_updateMonitorPolicyDeltaMS); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 6634, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -152469,48 +156098,48 @@ if (!__Pyx_RefNanny) { __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6426, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 6633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_updateMonitorPolicyDeltaMS, __pyx_t_1) < 0) __PYX_ERR(3, 6427, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_6PyCafe_CyCafe->tp_dict, __pyx_n_s_updateMonitorPolicyDeltaMS, __pyx_t_1) < 0) __PYX_ERR(3, 6634, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_6PyCafe_CyCafe); - /* "PyCafe.pyx":6436 + /* "PyCafe.pyx":6643 * ############################################################################ * def monitor( * self, handlePV, object cb=None, DBR_TYPE dbr=DBR_TIME, # <<<<<<<<<<<<<< * unsigned int mask=DBE_VALUE | DBE_LOG | DBE_ALARM, * unsigned short notify_milliseconds=0): */ - __pyx_k__115 = DBR_TIME; + __pyx_k__110 = DBR_TIME; - /* "PyCafe.pyx":6437 + /* "PyCafe.pyx":6644 * def monitor( * self, handlePV, object cb=None, DBR_TYPE dbr=DBR_TIME, * unsigned int mask=DBE_VALUE | DBE_LOG | DBE_ALARM, # <<<<<<<<<<<<<< * unsigned short notify_milliseconds=0): * */ - __pyx_k__116 = ((DBE_VALUE | DBE_LOG) | DBE_ALARM); + __pyx_k__111 = ((DBE_VALUE | DBE_LOG) | DBE_ALARM); - /* "PyCafe.pyx":6444 + /* "PyCafe.pyx":6651 * ############################################################################ * def monitorStart( * self, handlePV, cb: object = None, DBR_TYPE dbr=DBR_TIME, # <<<<<<<<<<<<<< * unsigned int mask=DBE_VALUE | DBE_LOG | DBE_ALARM, * unsigned short notify_milliseconds=0): */ - __pyx_k__117 = DBR_TIME; + __pyx_k__112 = DBR_TIME; - /* "PyCafe.pyx":6445 + /* "PyCafe.pyx":6652 * def monitorStart( * self, handlePV, cb: object = None, DBR_TYPE dbr=DBR_TIME, * unsigned int mask=DBE_VALUE | DBE_LOG | DBE_ALARM, # <<<<<<<<<<<<<< * unsigned short notify_milliseconds=0): * */ - __pyx_k__118 = ((DBE_VALUE | DBE_LOG) | DBE_ALARM); + __pyx_k__113 = ((DBE_VALUE | DBE_LOG) | DBE_ALARM); /* "(tree fragment)":1 * def __pyx_unpickle_CafeException(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< @@ -152552,7 +156181,7 @@ if (!__Pyx_RefNanny) { * cdef strided = Enum("") # default * cdef indirect = Enum("") */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__174, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__169, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(generic); __Pyx_DECREF_SET(generic, __pyx_t_1); @@ -152566,7 +156195,7 @@ if (!__Pyx_RefNanny) { * cdef indirect = Enum("") * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__175, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__170, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(strided); __Pyx_DECREF_SET(strided, __pyx_t_1); @@ -152580,7 +156209,7 @@ if (!__Pyx_RefNanny) { * * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__176, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__171, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(indirect); __Pyx_DECREF_SET(indirect, __pyx_t_1); @@ -152594,7 +156223,7 @@ if (!__Pyx_RefNanny) { * cdef indirect_contiguous = Enum("") * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__177, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 291, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__172, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(contiguous); __Pyx_DECREF_SET(contiguous, __pyx_t_1); @@ -152608,7 +156237,7 @@ if (!__Pyx_RefNanny) { * * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__178, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__173, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(indirect_contiguous); __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); @@ -154134,33 +157763,6 @@ static PyObject* __Pyx_PyObject_Format(PyObject* obj, PyObject* format_spec) { } #endif -/* decode_c_bytes */ -static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( - const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { - if (unlikely((start < 0) | (stop < 0))) { - if (start < 0) { - start += length; - if (start < 0) - start = 0; - } - if (stop < 0) - stop += length; - } - if (stop > length) - stop = length; - length = stop - start; - if (unlikely(length <= 0)) - return PyUnicode_FromUnicode(NULL, 0); - cstring += start; - if (decode_func) { - return decode_func(cstring, length, errors); - } else { - return PyUnicode_Decode(cstring, length, encoding, errors); - } -} - /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * @@ -154217,6 +157819,38 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject } #endif +/* None */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* decode_c_bytes */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + length = stop - start; + if (unlikely(length <= 0)) + return PyUnicode_FromUnicode(NULL, 0); + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; @@ -154344,11 +157978,6 @@ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { return 0; } -/* None */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { - PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); -} - /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) @@ -155704,203 +159333,6 @@ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { return 0; } -/* PyObjectCallMethod0 */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { - PyObject *method = NULL, *result = NULL; - int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); - if (likely(is_method)) { - result = __Pyx_PyObject_CallOneArg(method, obj); - Py_DECREF(method); - return result; - } - if (unlikely(!method)) goto bad; - result = __Pyx_PyObject_CallNoArg(method); - Py_DECREF(method); -bad: - return result; -} - -/* RaiseNoneIterError */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); -} - -/* UnpackTupleError */ -static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { - if (t == Py_None) { - __Pyx_RaiseNoneNotIterableError(); - } else if (PyTuple_GET_SIZE(t) < index) { - __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); - } else { - __Pyx_RaiseTooManyValuesError(index); - } -} - -/* UnpackTuple2 */ -static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( - PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { - PyObject *value1 = NULL, *value2 = NULL; -#if CYTHON_COMPILING_IN_PYPY - value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; - value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; -#else - value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); - value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); -#endif - if (decref_tuple) { - Py_DECREF(tuple); - } - *pvalue1 = value1; - *pvalue2 = value2; - return 0; -#if CYTHON_COMPILING_IN_PYPY -bad: - Py_XDECREF(value1); - Py_XDECREF(value2); - if (decref_tuple) { Py_XDECREF(tuple); } - return -1; -#endif -} -static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, - int has_known_size, int decref_tuple) { - Py_ssize_t index; - PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; - iternextfunc iternext; - iter = PyObject_GetIter(tuple); - if (unlikely(!iter)) goto bad; - if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } - iternext = Py_TYPE(iter)->tp_iternext; - value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } - value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } - if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; - Py_DECREF(iter); - *pvalue1 = value1; - *pvalue2 = value2; - return 0; -unpacking_failed: - if (!has_known_size && __Pyx_IterFinish() == 0) - __Pyx_RaiseNeedMoreValuesError(index); -bad: - Py_XDECREF(iter); - Py_XDECREF(value1); - Py_XDECREF(value2); - if (decref_tuple) { Py_XDECREF(tuple); } - return -1; -} - -/* dict_iter */ -static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, - Py_ssize_t* p_orig_length, int* p_source_is_dict) { - is_dict = is_dict || likely(PyDict_CheckExact(iterable)); - *p_source_is_dict = is_dict; - if (is_dict) { -#if !CYTHON_COMPILING_IN_PYPY - *p_orig_length = PyDict_Size(iterable); - Py_INCREF(iterable); - return iterable; -#elif PY_MAJOR_VERSION >= 3 - static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; - PyObject **pp = NULL; - if (method_name) { - const char *name = PyUnicode_AsUTF8(method_name); - if (strcmp(name, "iteritems") == 0) pp = &py_items; - else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; - else if (strcmp(name, "itervalues") == 0) pp = &py_values; - if (pp) { - if (!*pp) { - *pp = PyUnicode_FromString(name + 4); - if (!*pp) - return NULL; - } - method_name = *pp; - } - } -#endif - } - *p_orig_length = 0; - if (method_name) { - PyObject* iter; - iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); - if (!iterable) - return NULL; -#if !CYTHON_COMPILING_IN_PYPY - if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) - return iterable; -#endif - iter = PyObject_GetIter(iterable); - Py_DECREF(iterable); - return iter; - } - return PyObject_GetIter(iterable); -} -static CYTHON_INLINE int __Pyx_dict_iter_next( - PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, - PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { - PyObject* next_item; -#if !CYTHON_COMPILING_IN_PYPY - if (source_is_dict) { - PyObject *key, *value; - if (unlikely(orig_length != PyDict_Size(iter_obj))) { - PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); - return -1; - } - if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { - return 0; - } - if (pitem) { - PyObject* tuple = PyTuple_New(2); - if (unlikely(!tuple)) { - return -1; - } - Py_INCREF(key); - Py_INCREF(value); - PyTuple_SET_ITEM(tuple, 0, key); - PyTuple_SET_ITEM(tuple, 1, value); - *pitem = tuple; - } else { - if (pkey) { - Py_INCREF(key); - *pkey = key; - } - if (pvalue) { - Py_INCREF(value); - *pvalue = value; - } - } - return 1; - } else if (PyTuple_CheckExact(iter_obj)) { - Py_ssize_t pos = *ppos; - if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; - *ppos = pos + 1; - next_item = PyTuple_GET_ITEM(iter_obj, pos); - Py_INCREF(next_item); - } else if (PyList_CheckExact(iter_obj)) { - Py_ssize_t pos = *ppos; - if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; - *ppos = pos + 1; - next_item = PyList_GET_ITEM(iter_obj, pos); - Py_INCREF(next_item); - } else -#endif - { - next_item = PyIter_Next(iter_obj); - if (unlikely(!next_item)) { - return __Pyx_IterFinish(); - } - } - if (pitem) { - *pitem = next_item; - } else if (pkey && pvalue) { - if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) - return -1; - } else if (pkey) { - *pkey = next_item; - } else { - *pvalue = next_item; - } - return 1; -} - /* UnpackUnboundCMethod */ static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { PyObject *method; @@ -156144,6 +159576,11 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { } #endif +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { diff --git a/src/cafe.cpp b/src/cafe.cpp index 13c9cf4..0d7af53 100644 --- a/src/cafe.cpp +++ b/src/cafe.cpp @@ -42,7 +42,7 @@ map, string> groupPseudoMap; cafeGroup_set gs; cafeConduit_set cs; - +epicsMutex cafeMutex; //5+ long long /** diff --git a/src/conduit.cpp b/src/conduit.cpp index 47a0d64..7b8d809 100644 --- a/src/conduit.cpp +++ b/src/conduit.cpp @@ -565,13 +565,14 @@ int Conduit::putWithCallback(pCallback callbackHandlerPut) const int Conduit::get(void) const { #define __METHOD__ "Conduit::get(void) " - /* For testing readout time for waveforms! + /* For testing readout time for waveforms! */ + /* using namespace boost::posix_time; ptime timeStart(microsec_clock::local_time()); double timeElapsed=0; unsigned int nPoll=0; - - for (int i=0; i< 100000; ++i) { + unsigned nevent = 10; + for (int i=0; i< nevent; ++i) { ca_array_get(channelRequestMetaData.dbrDataType, channelRequestMetaData.nelem, channelRegalia.channelID,dataBuffer); } @@ -580,7 +581,8 @@ int Conduit::get(void) const timeElapsed= (double) duration.total_microseconds()/1000000.0; std::cout << "Time Elapsed " << timeElapsed << std::endl; - */ + std::cout << "Time Elapsed/per event " << timeElapsed/nevent << std::endl; + */ return ca_array_get(channelRequestMetaData.dbrDataType, channelRequestMetaData.nelem, channelRegalia.channelID, dataBuffer); @@ -597,6 +599,47 @@ int Conduit::getWithCallback(pCallback callbackHandlerGet) const { #define __METHOD__ "Conduit::getCallback(pCallback callbackHandlerGet) " + /* + if (channelRequestMetaData.nelem > 1) { + + using namespace boost::posix_time; + ptime timeStart(microsec_clock::local_time()); + double timeElapsed=0; + unsigned int nPoll=0; + unsigned int nevent = 1000; + + std::cout << "NELM ==> " << channelRequestMetaData.nelem << std::endl; + + for (int i=0; i< nevent; ++i) { + ca_array_get(channelRequestMetaData.dbrDataType, channelRequestMetaData.nelem, + channelRegalia.channelID,dataBuffer); + } + ptime timeEnd(microsec_clock::local_time()); + time_duration duration(timeEnd-timeStart); + timeElapsed= (double) duration.total_microseconds()/1000000.0; + + std::cout << "Time Elapsed nevents " << timeElapsed << " " << nevent << std::endl; + std::cout << "Time Elapsed/per event " << timeElapsed/nevent << std::endl; + + ptime timeStart2(microsec_clock::local_time()); + timeElapsed=0; + nPoll=0; + + for (int i=0; i&2; \ - exit 1;; \ - esac; \ - has_opt=no; \ - sane_makeflags=$$MAKEFLAGS; \ - if $(am__is_gnu_make); then \ - sane_makeflags=$$MFLAGS; \ - else \ - case $$MAKEFLAGS in \ - *\\[\ \ ]*) \ - bs=\\; \ - sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ - | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ - esac; \ - fi; \ - skip_next=no; \ - strip_trailopt () \ - { \ - flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ - }; \ - for flg in $$sane_makeflags; do \ - test $$skip_next = yes && { skip_next=no; continue; }; \ - case $$flg in \ - *=*|--*) continue;; \ - -*I) strip_trailopt 'I'; skip_next=yes;; \ - -*I?*) strip_trailopt 'I';; \ - -*O) strip_trailopt 'O'; skip_next=yes;; \ - -*O?*) strip_trailopt 'O';; \ - -*l) strip_trailopt 'l'; skip_next=yes;; \ - -*l?*) strip_trailopt 'l';; \ - -[dEDm]) skip_next=yes;; \ - -[JT]) skip_next=yes;; \ - esac; \ - case $$flg in \ - *$$target_option*) has_opt=yes; break;; \ - esac; \ - done; \ - test $$has_opt = yes -am__make_dryrun = (target_option=n; $(am__make_running_with_option)) -am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/cafe pkgincludedir = $(includedir)/cafe pkglibdir = $(libdir)/cafe @@ -83,8 +39,7 @@ am__append_1 = PyCafe.cpp # bitshuffle/bitshuffle_core.c bitshuffle/bitshuffle.c bitshuffle/iochain.c subdir = src -DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \ - $(top_srcdir)/./depcomp +DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \ $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \ @@ -117,12 +72,6 @@ am__nobase_list = $(am__nobase_strip_setup); \ am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' -am__uninstall_files_from_dir = { \ - test -z "$$files" \ - || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ - || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ - $(am__cd) "$$dir" && rm -f $$files; }; \ - } am__installdirs = "$(DESTDIR)$(libdir)" LTLIBRARIES = $(lib_LTLIBRARIES) libcafe_la_LIBADD = @@ -152,94 +101,38 @@ am_libcafe_la_OBJECTS = cafe.lo cafeCache.lo cafeGroup.lo \ policyHelper.lo conduitGroup.lo connectGroup.lo transpose.lo \ restorePVGroupXMLParser.lo $(am__objects_1) $(am__objects_2) libcafe_la_OBJECTS = $(am_libcafe_la_OBJECTS) -AM_V_lt = $(am__v_lt_$(V)) -am__v_lt_ = $(am__v_lt_$(AM_DEFAULT_VERBOSITY)) -am__v_lt_0 = --silent -am__v_lt_1 = -libcafe_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ +libcafe_la_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ $(CXXFLAGS) $(libcafe_la_LDFLAGS) $(LDFLAGS) -o $@ -AM_V_P = $(am__v_P_$(V)) -am__v_P_ = $(am__v_P_$(AM_DEFAULT_VERBOSITY)) -am__v_P_0 = false -am__v_P_1 = : -AM_V_GEN = $(am__v_GEN_$(V)) -am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY)) -am__v_GEN_0 = @echo " GEN " $@; -am__v_GEN_1 = -AM_V_at = $(am__v_at_$(V)) -am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY)) -am__v_at_0 = @ -am__v_at_1 = DEFAULT_INCLUDES = -I. -I$(top_builddir)/./include depcomp = $(SHELL) $(top_srcdir)/./depcomp am__depfiles_maybe = depfiles am__mv = mv -f COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ - $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ - $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ - $(AM_CFLAGS) $(CFLAGS) -AM_V_CC = $(am__v_CC_$(V)) -am__v_CC_ = $(am__v_CC_$(AM_DEFAULT_VERBOSITY)) -am__v_CC_0 = @echo " CC " $@; -am__v_CC_1 = +LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) CCLD = $(CC) -LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ - $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ - $(AM_LDFLAGS) $(LDFLAGS) -o $@ -AM_V_CCLD = $(am__v_CCLD_$(V)) -am__v_CCLD_ = $(am__v_CCLD_$(AM_DEFAULT_VERBOSITY)) -am__v_CCLD_0 = @echo " CCLD " $@; -am__v_CCLD_1 = +LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \ + $(LDFLAGS) -o $@ CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ - $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ - $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ - $(AM_CXXFLAGS) $(CXXFLAGS) -AM_V_CXX = $(am__v_CXX_$(V)) -am__v_CXX_ = $(am__v_CXX_$(AM_DEFAULT_VERBOSITY)) -am__v_CXX_0 = @echo " CXX " $@; -am__v_CXX_1 = +LTCXXCOMPILE = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) CXXLD = $(CXX) -CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ - $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ - $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ -AM_V_CXXLD = $(am__v_CXXLD_$(V)) -am__v_CXXLD_ = $(am__v_CXXLD_$(AM_DEFAULT_VERBOSITY)) -am__v_CXXLD_0 = @echo " CXXLD " $@; -am__v_CXXLD_1 = +CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \ + $(LDFLAGS) -o $@ SOURCES = $(libcafe_la_SOURCES) DIST_SOURCES = $(am__libcafe_la_SOURCES_DIST) -am__can_run_installinfo = \ - case $$AM_UPDATE_INFO_DIR in \ - n|no|NO) false;; \ - *) (install-info --version) >/dev/null 2>&1;; \ - esac -am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) -# Read a list of newline-separated strings from the standard input, -# and print each of them once, without duplicates. Input order is -# *not* preserved. -am__uniquify_input = $(AWK) '\ - BEGIN { nonempty = 0; } \ - { items[$$0] = 1; nonempty = 1; } \ - END { if (nonempty) { for (i in items) print i; }; } \ -' -# Make sure the list of sources is unique. This is necessary because, -# e.g., the same source file might be shared among _SOURCES variables -# for different programs/libraries. -am__define_uniq_tagged_files = \ - list='$(am__tagged_files)'; \ - unique=`for i in $$list; do \ - if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ - done | $(am__uniquify_input)` ETAGS = etags CTAGS = ctags DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) -ACLOCAL = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing aclocal-1.13 -AMTAR = $${TAR-tar} +ACLOCAL = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run aclocal-1.11 +AMTAR = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run tar #if HAVE_PYCAFE_EXT_ #libcafe_la_SOURCES += PyCafe.cpp @@ -248,20 +141,19 @@ AMTAR = $${TAR-tar} #if HAVE_PYTHON_ #libcafe_la_SOURCES += pycafe/PyCafe.cpp #endif -AM_CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base-7.0.6/include/ -I/usr/local/epics/base-7.0.6/include/os/Linux -I/usr/local/epics/base-7.0.6/include/compiler/gcc -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml -I$(top_srcdir)/include -AM_DEFAULT_VERBOSITY = 1 -AM_LDFLAGS = -L/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -Wl,-rpath,/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib +AM_CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml -I$(top_srcdir)/include +AM_LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib AR = ar -AUTOCONF = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing autoconf -AUTOHEADER = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing autoheader -AUTOMAKE = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing automake-1.13 +AUTOCONF = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run autoconf +AUTOHEADER = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run autoheader +AUTOMAKE = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run automake-1.11 AWK = gawk CAFE_CPPFLAGS = -I$(top_srcdir)/include CC = /opt/psi/Programming/gcc/7.3.0/bin/gcc CCDEPMODE = depmode=gcc3 CFLAGS = -g -O2 CPP = /opt/psi/Programming/gcc/7.3.0/bin/gcc -E -CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base-7.0.6/include/ -I/usr/local/epics/base-7.0.6/include/os/Linux -I/usr/local/epics/base-7.0.6/include/compiler/gcc -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml +CPPFLAGS = -fexceptions -fPIC -std=c++1z -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/opt/gfa/python-3.5/latest/include/python3.5m -I/opt/gfa/python-3.5/latest/lib/python3.5/site-packages/numpy/core/include -I/opt/gfa/python-3.5/latest/include -I/opt/gfa/python-3.5/latest/include/QtCore -I/opt/gfa/python-3.5/latest/include/QtXml CXX = /opt/psi/Programming/gcc/7.3.0/bin/g++ CXXCPP = /opt/psi/Programming/gcc/7.3.0/bin/g++ -E CXXDEPMODE = depmode=gcc3 @@ -275,17 +167,17 @@ DUMPBIN = ECHO_C = ECHO_N = -n ECHO_T = -EGREP = /usr/bin/grep -E +EGREP = /bin/grep -E EXEEXT = -FGREP = /usr/bin/grep -F -GREP = /usr/bin/grep +FGREP = /bin/grep -F +GREP = /bin/grep INSTALL = /usr/bin/install -c INSTALL_DATA = ${INSTALL} -m 644 INSTALL_PROGRAM = ${INSTALL} INSTALL_SCRIPT = ${INSTALL} INSTALL_STRIP_PROGRAM = $(install_sh) -c -s LD = /usr/bin/ld -m elf_x86_64 -LDFLAGS = -L/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -Wl,-rpath,/usr/local/epics/base-7.0.6/lib/RHEL7-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib +LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib LIBOBJS = LIBS = -lQtXml -lQtCore -lpython3.5m LIBTOOL = $(SHELL) $(top_builddir)/libtool @@ -293,9 +185,9 @@ LIPO = LN_S = ln -s LTLIBOBJS = LT_SYS_LIBRARY_PATH = -MAKEINFO = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing makeinfo +MAKEINFO = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run makeinfo MANIFEST_TOOL = : -MKDIR_P = /usr/bin/mkdir -p +MKDIR_P = /bin/mkdir -p NM = /usr/bin/nm -B NMEDIT = OBJDUMP = objdump @@ -305,17 +197,16 @@ OTOOL64 = PACKAGE = cafe PACKAGE_BUGREPORT = Bug reports to: jan.chrin@psi.ch PACKAGE_NAME = CAFE -PACKAGE_STRING = CAFE 1.15.0 +PACKAGE_STRING = CAFE 1.15.1 PACKAGE_TARNAME = cafe -PACKAGE_URL = -PACKAGE_VERSION = 1.15.0 +PACKAGE_VERSION = 1.15.1 PATH_SEPARATOR = : RANLIB = ranlib -SED = /usr/bin/sed +SED = /bin/sed SET_MAKE = SHELL = /bin/sh STRIP = strip -VERSION = 1.15.0 +VERSION = 1.15.1 abs_builddir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/src abs_srcdir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/src abs_top_builddir = /afs/psi.ch/project/cafe/gitlab/CAFE/cpp @@ -327,8 +218,8 @@ ac_ct_DUMPBIN = am__include = include am__leading_dot = . am__quote = -am__tar = $${TAR-tar} chof - "$$tardir" -am__untar = $${TAR-tar} xf - +am__tar = ${AMTAR} chof - "$$tardir" +am__untar = ${AMTAR} xf - bindir = ${exec_prefix}/bin build = x86_64-unknown-linux-gnu build_alias = @@ -350,15 +241,15 @@ htmldir = ${docdir} includedir = ${prefix}/include infodir = ${datarootdir}/info install_sh = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/install-sh -libdir = /opt/gfa/cafe/cpp/cafe-1.15.0-py35-gcc-7.3.0/lib/RHEL7-x86_64 +libdir = /opt/gfa/cafe/cpp/cafe-1.15.1-epics3-py35-gcc-7.3.0/lib/SL6-x86_64 libexecdir = ${exec_prefix}/libexec localedir = ${datarootdir}/locale localstatedir = ${prefix}/var mandir = ${datarootdir}/man -mkdir_p = $(MKDIR_P) +mkdir_p = /bin/mkdir -p oldincludedir = /usr/include pdfdir = ${docdir} -prefix = /opt/gfa/cafe/cpp/cafe-1.15.0-py35-gcc-7.3.0 +prefix = /opt/gfa/cafe/cpp/cafe-1.15.1-epics3-py35-gcc-7.3.0 program_transform_name = s,x,x, psdir = ${docdir} sbindir = ${exec_prefix}/sbin @@ -378,7 +269,7 @@ lib_LTLIBRARIES = libcafe.la #2nd: age #3rd: revision #1.9.1 1.10.2 1.11.0 1.11.1 1.12.0 1.12.1 1.12.2 1.12.4 -libcafe_la_LDFLAGS = -version-info 16:0:15 +libcafe_la_LDFLAGS = -version-info 16:1:15 libcafe_la_SOURCES = cafe.cpp cafeCache.cpp cafeGroup.cpp \ cafeVectors.cpp cafeXML.cpp callbackHandlerCreate.cpp \ callbackHandlerMonitor.cpp conduit.cpp connect.cpp \ @@ -422,9 +313,9 @@ $(top_srcdir)/configure: $(am__configure_deps) $(ACLOCAL_M4): $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): - install-libLTLIBRARIES: $(lib_LTLIBRARIES) @$(NORMAL_INSTALL) + test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)" @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ list2=; for p in $$list; do \ if test -f $$p; then \ @@ -432,8 +323,6 @@ install-libLTLIBRARIES: $(lib_LTLIBRARIES) else :; fi; \ done; \ test -z "$$list2" || { \ - echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ - $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ } @@ -449,14 +338,12 @@ uninstall-libLTLIBRARIES: clean-libLTLIBRARIES: -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) - @list='$(lib_LTLIBRARIES)'; \ - locs=`for p in $$list; do echo $$p; done | \ - sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ - sort -u`; \ - test -z "$$locs" || { \ - echo rm -f $${locs}; \ - rm -f $${locs}; \ - } + @list='$(lib_LTLIBRARIES)'; for p in $$list; do \ + dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \ + test "$$dir" != "$$p" || dir=.; \ + echo "rm -f \"$${dir}/so_locations\""; \ + rm -f "$${dir}/so_locations"; \ + done bitshuffle/$(am__dirstamp): @$(MKDIR_P) bitshuffle @: > bitshuffle/$(am__dirstamp) @@ -469,14 +356,17 @@ bitshuffle/bitshuffle.lo: bitshuffle/$(am__dirstamp) \ bitshuffle/$(DEPDIR)/$(am__dirstamp) bitshuffle/iochain.lo: bitshuffle/$(am__dirstamp) \ bitshuffle/$(DEPDIR)/$(am__dirstamp) - -libcafe.la: $(libcafe_la_OBJECTS) $(libcafe_la_DEPENDENCIES) $(EXTRA_libcafe_la_DEPENDENCIES) - $(AM_V_CXXLD)$(libcafe_la_LINK) -rpath $(libdir) $(libcafe_la_OBJECTS) $(libcafe_la_LIBADD) $(LIBS) +libcafe.la: $(libcafe_la_OBJECTS) $(libcafe_la_DEPENDENCIES) + $(libcafe_la_LINK) -rpath $(libdir) $(libcafe_la_OBJECTS) $(libcafe_la_LIBADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) - -rm -f bitshuffle/*.$(OBJEXT) - -rm -f bitshuffle/*.lo + -rm -f bitshuffle/bitshuffle.$(OBJEXT) + -rm -f bitshuffle/bitshuffle.lo + -rm -f bitshuffle/bitshuffle_core.$(OBJEXT) + -rm -f bitshuffle/bitshuffle_core.lo + -rm -f bitshuffle/iochain.$(OBJEXT) + -rm -f bitshuffle/iochain.lo distclean-compile: -rm -f *.tab.c @@ -511,52 +401,52 @@ include bitshuffle/$(DEPDIR)/bitshuffle_core.Plo include bitshuffle/$(DEPDIR)/iochain.Plo .c.o: - $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ + depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ $(am__mv) $$depbase.Tpo $$depbase.Po -# $(AM_V_CC)source='$<' object='$@' libtool=no \ +# source='$<' object='$@' libtool=no \ # DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \ -# $(AM_V_CC_no)$(COMPILE) -c -o $@ $< +# $(COMPILE) -c -o $@ $< .c.obj: - $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ + depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ $(am__mv) $$depbase.Tpo $$depbase.Po -# $(AM_V_CC)source='$<' object='$@' libtool=no \ +# source='$<' object='$@' libtool=no \ # DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \ -# $(AM_V_CC_no)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` +# $(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .c.lo: - $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ + depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ $(am__mv) $$depbase.Tpo $$depbase.Plo -# $(AM_V_CC)source='$<' object='$@' libtool=yes \ +# source='$<' object='$@' libtool=yes \ # DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \ -# $(AM_V_CC_no)$(LTCOMPILE) -c -o $@ $< +# $(LTCOMPILE) -c -o $@ $< .cpp.o: - $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ + depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ $(am__mv) $$depbase.Tpo $$depbase.Po -# $(AM_V_CXX)source='$<' object='$@' libtool=no \ +# source='$<' object='$@' libtool=no \ # DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) \ -# $(AM_V_CXX_no)$(CXXCOMPILE) -c -o $@ $< +# $(CXXCOMPILE) -c -o $@ $< .cpp.obj: - $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ + depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ $(am__mv) $$depbase.Tpo $$depbase.Po -# $(AM_V_CXX)source='$<' object='$@' libtool=no \ +# source='$<' object='$@' libtool=no \ # DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) \ -# $(AM_V_CXX_no)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` +# $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .cpp.lo: - $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ + depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ $(am__mv) $$depbase.Tpo $$depbase.Plo -# $(AM_V_CXX)source='$<' object='$@' libtool=yes \ +# source='$<' object='$@' libtool=yes \ # DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) \ -# $(AM_V_CXX_no)$(LTCXXCOMPILE) -c -o $@ $< +# $(LTCXXCOMPILE) -c -o $@ $< mostlyclean-libtool: -rm -f *.lo @@ -565,15 +455,26 @@ clean-libtool: -rm -rf .libs _libs -rm -rf bitshuffle/.libs bitshuffle/_libs -ID: $(am__tagged_files) - $(am__define_uniq_tagged_files); mkid -fID $$unique -tags: tags-am -TAGS: tags +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS -tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) set x; \ here=`pwd`; \ - $(am__define_uniq_tagged_files); \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ shift; \ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ test -n "$$unique" || unique=$$empty_fix; \ @@ -585,11 +486,15 @@ tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) $$unique; \ fi; \ fi -ctags: ctags-am - -CTAGS: ctags -ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) - $(am__define_uniq_tagged_files); \ +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ test -z "$(CTAGS_ARGS)$$unique" \ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ $$unique @@ -598,21 +503,6 @@ GTAGS: here=`$(am__cd) $(top_builddir) && pwd` \ && $(am__cd) $(top_srcdir) \ && gtags -i $(GTAGS_ARGS) "$$here" -cscopelist: cscopelist-am - -cscopelist-am: $(am__tagged_files) - list='$(am__tagged_files)'; \ - case "$(srcdir)" in \ - [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ - *) sdir=$(subdir)/$(srcdir) ;; \ - esac; \ - for i in $$list; do \ - if test -f "$$i"; then \ - echo "$(subdir)/$$i"; \ - else \ - echo "$$sdir/$$i"; \ - fi; \ - done >> $(top_builddir)/cscope.files distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags @@ -664,15 +554,10 @@ install-am: all-am installcheck: installcheck-am install-strip: - if test -z '$(STRIP)'; then \ - $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ - install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ - install; \ - else \ - $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ - install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ - "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ - fi + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install mostlyclean-generic: clean-generic: @@ -759,19 +644,19 @@ uninstall-am: uninstall-libLTLIBRARIES .MAKE: install-am install-strip -.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ - clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \ - ctags-am distclean distclean-compile distclean-generic \ - distclean-libtool distclean-tags distdir dvi dvi-am html \ - html-am info info-am install install-am install-data \ - install-data-am install-dvi install-dvi-am install-exec \ - install-exec-am install-html install-html-am install-info \ - install-info-am install-libLTLIBRARIES install-man install-pdf \ - install-pdf-am install-ps install-ps-am install-strip \ - installcheck installcheck-am installdirs maintainer-clean \ +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libtool ctags distclean \ + distclean-compile distclean-generic distclean-libtool \ + distclean-tags distdir dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am \ + install-libLTLIBRARIES install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ maintainer-clean-generic mostlyclean mostlyclean-compile \ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ - tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES + tags uninstall uninstall-am uninstall-libLTLIBRARIES # Tell versions [3.59,3.63) of GNU make to not export all variables. diff --git a/src/makefile.am b/src/makefile.am index e71c338..530f024 100644 --- a/src/makefile.am +++ b/src/makefile.am @@ -12,7 +12,7 @@ lib_LTLIBRARIES = libcafe.la #2nd: age #3rd: revision #1.9.1 1.10.2 1.11.0 1.11.1 1.12.0 1.12.1 1.12.2 1.12.4 -libcafe_la_LDFLAGS = -version-info 16:0:15 +libcafe_la_LDFLAGS = -version-info 16:1:15 libcafe_la_SOURCES = cafe.cpp cafeCache.cpp cafeGroup.cpp cafeVectors.cpp cafeXML.cpp \ callbackHandlerCreate.cpp callbackHandlerMonitor.cpp conduit.cpp connect.cpp connectCallbacks.cpp \ diff --git a/src/methodCallbacks.cpp b/src/methodCallbacks.cpp index 625bad7..38f345b 100644 --- a/src/methodCallbacks.cpp +++ b/src/methodCallbacks.cpp @@ -123,7 +123,7 @@ void CALLBACK_CAFE::PyHandlerGet( struct event_handler_args args) if (it_handle != handle_index.end()) { - + ChannelRequestStatus channelRequestStatusGet=(*it_handle).getChannelRequestStatusGet(); channelRequestStatusGet.setCallbackKind(false, true); @@ -138,6 +138,7 @@ void CALLBACK_CAFE::PyHandlerGet( struct event_handler_args args) { cafeMutex.unlock(); } + (*it_handle).PyGetHandler(); } else