fixing python version. allowing versions to execute even if no detector connected or in shared memory (#990)

python/setup.py

@@ -10,7 +10,14 @@ import sys
 from setuptools import setup, find_packages
 from pybind11.setup_helpers import Pybind11Extension, build_ext
 
-__version__ = os.environ.get('GIT_DESCRIBE_TAG', 'developer')
+
+import subprocess
+def get_git_tag():
+    try:
+        return subprocess.check_output(['git', 'describe', '--tags', '--abbrev=0']).strip().decode('utf-8')
+    except subprocess.CalledProcessError:
+        return 'developer'
+__version__ = get_git_tag()
 
 
 def get_conda_path():

python/slsdet/__init__.py

@@ -28,3 +28,13 @@ scanParameters = _slsdet.scanParameters
 currentSrcParameters = _slsdet.currentSrcParameters
 DurationWrapper = _slsdet.DurationWrapper
 pedestalParameters = _slsdet.pedestalParameters
+
+
+import subprocess
+def get_git_tag():
+    try:
+        return subprocess.check_output(['git', 'describe', '--tags', '--abbrev=0']).strip().decode('utf-8')
+    except subprocess.CalledProcessError:
+        return 'developer'
+__version__ = get_git_tag()
+

python/slsdet/detector.py

@@ -1989,23 +1989,59 @@ class Detector(CppDetectorApi):
 
     @property
     def versions(self):
-        version_list = {'type': self.type,
-                'package': self.packageversion, 
-                'client': self.clientversion}
+        type = "Unknown"
+        firmware = "Unknown"
+        detectorserver = "Unknown"
+        kernel = "Unknown"
+        hardware = "Unknown"    
+        receiverversion = "Unknown"
+        eiger = False
+        firmware_febl = "Unknown"
+        firmware_febr = "Unknown"
+        firmware_beb = "Unknown"
+        receiver_in_shm = False
 
-        if self.type == detectorType.EIGER:
-            version_list ['firmware (Beb)'] = self.firmwareversion
-            version_list ['firmware(Febl)'] = self.getFrontEndFirmwareVersion(slsDetectorDefs.fpgaPosition.FRONT_LEFT)
-            version_list ['firmware (Febr)'] = self.getFrontEndFirmwareVersion(slsDetectorDefs.fpgaPosition.FRONT_RIGHT)
+        release = self.packageversion
+        client = self.clientversion
+
+        if self.nmod != 0:
+            # shared memory has detectors
+            type = self.type
+            eiger = (self.type == detectorType.EIGER)
+            receiver_in_shm = self.use_receiver
+            if receiver_in_shm:
+                # cannot connect to receiver
+                try:
+                    receiverversion = self.rx_version
+                except Exception as e:
+                    pass
+            # cannot connect to Detector
+            try:
+                firmware = self.firmwareversion
+                detectorserver = self.detectorserverversion
+                kernel = self.kernelversion
+                hardware = self.hardwareversion
+                if eiger:
+                    firmware_beb = self.firmwareversion
+                    firmware_febl = self.getFrontEndFirmwareVersion(slsDetectorDefs.fpgaPosition.FRONT_LEFT)
+                    firmware_febr = self.getFrontEndFirmwareVersion(slsDetectorDefs.fpgaPosition.FRONT_RIGHT)
+            except Exception as e:
+                pass
+
+        version_list = {'type': {type},
+                'package': {release}, 
+                'client': {client}}
+        if eiger:
+            version_list ['firmware (Beb)'] = {firmware_beb}
+            version_list ['firmware(Febl)'] = {firmware_febl}
+            version_list ['firmware (Febr)'] = {firmware_febr}
         else:
-            version_list ['firmware'] = self.firmwareversion
-
-        version_list ['detectorserver'] = self.detectorserverversion
-        version_list ['kernel'] = self.kernelversion
-        version_list ['hardware'] = self.hardwareversion
-
-        if self.use_receiver:
-            version_list ['receiver'] = self.rx_version
+            version_list ['firmware'] = {firmware}
+        version_list ['detectorserver'] = {detectorserver}
+        version_list ['kernel'] = kernel
+        version_list ['hardware'] = hardware
+        if receiver_in_shm:
+            version_list ['receiver'] = {receiverversion}
 
         return version_list
 

slsDetectorSoftware/src/CallerSpecial.cpp

@@ -260,39 +260,74 @@ std::string Caller::versions(int action) {
         if (!args.empty()) {
             WrongNumberOfParameters(0);
         }
-        bool eiger = (det->getDetectorType().squash() == defs::EIGER);
-        auto t = det->getFirmwareVersion(std::vector<int>{det_id});
-        os << "\nType            : " << OutString(det->getDetectorType())
-           << "\nRelease         : " << det->getPackageVersion() << std::hex
-           << "\nClient          : " << det->getClientVersion();
 
+        std::string vType = "Unknown";
+        std::string vFirmware = "Unknown";
+        std::string vServer = "Unknown";
+        std::string vKernel = "Unknown";
+        std::string vHardware = "Unknown";
+        bool eiger = false;
+        std::string vBebFirmware = "Unknown";
+        std::string vFeblFirmware = "Unknown";
+        std::string vFebrFirmware = "Unknown";
+        bool receiver = false;
+        std::string vReceiver = "Unknown";
+
+        std::string vRelease = det->getPackageVersion();
+        std::string vClient = det->getClientVersion();
+
+        if (det->size() != 0) {
+            // shared memory has detectors
+            vType = OutString(det->getDetectorType());
+            eiger = (det->getDetectorType().squash() == defs::EIGER);
+            receiver = det->getUseReceiverFlag().squash(false);
+            if (receiver) {
+                // cannot connect to receiver
+                try {
+                    vReceiver = OutString(
+                        det->getReceiverVersion(std::vector<int>{det_id}));
+                } catch (const std::exception &e) {
+                }
+            }
+            // cannot connect to Detector
+            try {
+                auto firmwareVersion =
+                    det->getFirmwareVersion(std::vector<int>{det_id});
+                vFirmware = OutStringHex(firmwareVersion);
+                vServer = OutString(
+                    det->getDetectorServerVersion(std::vector<int>{det_id}));
+                vKernel = OutString(
+                    det->getKernelVersion({std::vector<int>{det_id}}));
+                vHardware = OutString(
+                    det->getHardwareVersion(std::vector<int>{det_id}));
                 if (eiger) {
-            os << "\nFirmware (Beb)  : "
-               << OutString(det->getFirmwareVersion(std::vector<int>{det_id}));
-            os << "\nFirmware (Febl) : "
-               << OutString(det->getFrontEndFirmwareVersion(
+                    vBebFirmware = OutString(firmwareVersion);
+                    vFeblFirmware = OutString(det->getFrontEndFirmwareVersion(
                         defs::FRONT_LEFT, std::vector<int>{det_id}));
-            os << "\nFirmware (Febr) : "
-               << OutString(det->getFrontEndFirmwareVersion(
+                    vFebrFirmware = OutString(det->getFrontEndFirmwareVersion(
                         defs::FRONT_RIGHT, std::vector<int>{det_id}));
+                }
+            } catch (const std::exception &e) {
+            }
+        }
+
+        os << "\nType            : " << vType
+           << "\nRelease         : " << vRelease
+           << "\nClient          : " << vClient;
+        if (eiger) {
+            os << "\nFirmware (Beb)  : " << vBebFirmware
+               << "\nFirmware (Febl) : " << vFeblFirmware
+               << "\nFirmware (Febr) : " << vFebrFirmware;
         } else {
-            os << "\nFirmware        : "
-               << OutStringHex(
-                      det->getFirmwareVersion(std::vector<int>{det_id}));
-        }
-
-        os << "\nServer          : "
-           << OutString(det->getDetectorServerVersion(std::vector<int>{det_id}))
-           << "\nKernel          : "
-           << OutString(det->getKernelVersion({std::vector<int>{det_id}}))
-           << "\nHardware        : "
-           << OutString(det->getHardwareVersion(std::vector<int>{det_id}));
-
-        if (det->getUseReceiverFlag().squash(true)) {
-            os << "\nReceiver        : "
-               << OutString(det->getReceiverVersion(std::vector<int>{det_id}));
+            os << "\nFirmware        : " << vFirmware;
         }
+        os << "\nServer          : " << vServer
+           << "\nKernel          : " << vKernel
+           << "\nHardware        : " << vHardware;
+        if (receiver)
+            os << "\nReceiver        : " << vReceiver;
         os << std::dec << '\n';
+
     } else if (action == defs::PUT_ACTION) {
         throw RuntimeError("cannot put");
     } else {