Changes needed for LCG 106 (backward compatible with LCG 105)

• Improve test_iovs to work with latest pytest (effective cherry-pick of !4931 (merged))
• Fix test of StatEntity use in Python to avoid implicit conversion from bool to float (not working with the latest cppyy)
• Change types used in ODIN to avoid a problem with cppyy (inside ROOT) not understanding unsigned long long

Event/DAQEvent/include/Event/ODIN.h

 /*****************************************************************************\
-* (c) Copyright 2000-2019 CERN for the benefit of the LHCb Collaboration      *
+* (c) Copyright 2000-2025 CERN for the benefit of the LHCb Collaboration      *
 *                                                                             *
 * This software is distributed under the terms of the GNU General Public      *
 * Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".   *
@@ -14,6 +14,7 @@
 #include "Event/RawBank.h"
 #include "GaudiKernel/DataObject.h"
 #include "GaudiKernel/Time.h"
+#include <cstdint>
 #include <ostream>
 
 // Forward declarations
@@ -184,52 +185,52 @@ namespace LHCb {
     bool isFlagging() const;
 
     /// Retrieve const  Run number
-    unsigned int runNumber() const;
+    std::uint32_t runNumber() const;
 
     /// Update  Run number
-    void setRunNumber( unsigned int value );
+    void setRunNumber( std::uint32_t value );
 
     /// Retrieve const  Event type
-    unsigned int eventType() const;
+    std::uint32_t eventType() const;
 
     /// Update  Event type
-    void setEventType( unsigned int value );
+    void setEventType( std::uint32_t value );
 
     /// Retrieve const  Orbit ID
-    unsigned int orbitNumber() const;
+    std::uint32_t orbitNumber() const;
 
     /// Update  Orbit ID
-    void setOrbitNumber( unsigned int value );
+    void setOrbitNumber( std::uint32_t value );
 
     /// Retrieve const  L0 Event ID
-    unsigned long long eventNumber() const;
+    std::uint64_t eventNumber() const;
 
     /// Update  L0 Event ID
-    void setEventNumber( unsigned long long value );
+    void setEventNumber( std::uint64_t value );
 
     /// Retrieve const  GPS Time (microseconds)
-    unsigned long long gpsTime() const;
+    std::uint64_t gpsTime() const;
 
     /// Update  GPS Time (microseconds)
-    void setGpsTime( unsigned long long value );
+    void setGpsTime( std::uint64_t value );
 
     /// Retrieve const  Detector Status
-    unsigned long long detectorStatus() const;
+    std::uint64_t detectorStatus() const;
 
     /// Update  Detector Status
-    void setDetectorStatus( unsigned long long value );
+    void setDetectorStatus( std::uint64_t value );
 
     /// Retrieve const  Error Bits
-    unsigned int errorBits() const;
+    std::uint32_t errorBits() const;
 
     /// Update  Error Bits
-    void setErrorBits( unsigned int value );
+    void setErrorBits( std::uint32_t value );
 
     /// Retrieve const  Bunch ID
-    unsigned int bunchId() const;
+    std::uint32_t bunchId() const;
 
     /// Update  Bunch ID
-    void setBunchId( unsigned int value );
+    void setBunchId( std::uint32_t value );
 
     /// Retrieve const  Trigger Type @see enum LHCb::ODIN::TriggerType
     const TriggerType& triggerType() const;
@@ -256,35 +257,35 @@ namespace LHCb {
     void setBunchCrossingType( const BXTypes& value );
 
     /// Retrieve const  Bunch Current
-    unsigned int bunchCurrent() const;
+    std::uint32_t bunchCurrent() const;
 
     /// Update  Bunch Current
-    void setBunchCurrent( unsigned int value );
+    void setBunchCurrent( std::uint32_t value );
 
     /// Retrieve const  Version of the ODIN bank
-    unsigned int version() const;
+    std::uint32_t version() const;
 
     /// Update  Version of the ODIN bank
-    void setVersion( unsigned int value );
+    void setVersion( std::uint32_t value );
 
     /// Retrieve const  Calibration Step Number
-    unsigned int calibrationStep() const;
+    std::uint32_t calibrationStep() const;
 
     /// Update  Calibration Step Number
-    void setCalibrationStep( unsigned int value );
+    void setCalibrationStep( std::uint32_t value );
 
     /// Retrieve const  Requested Trigger Configuration Key. The key actually used is in
     /// LHCb::HltDecReports::configuredTCK
-    unsigned int triggerConfigurationKey() const;
+    std::uint32_t triggerConfigurationKey() const;
 
     /// Update  Requested Trigger Configuration Key. The key actually used is in LHCb::HltDecReports::configuredTCK
-    void setTriggerConfigurationKey( unsigned int value );
+    void setTriggerConfigurationKey( std::uint32_t value );
 
     /// Retrieve const  TAE (Time Alignment Event) window size
-    unsigned int timeAlignmentEventWindow() const;
+    std::uint32_t timeAlignmentEventWindow() const;
 
     /// Update  TAE (Time Alignment Event) window size
-    void setTimeAlignmentEventWindow( unsigned int value );
+    void setTimeAlignmentEventWindow( std::uint32_t value );
 
     /// Retrieve const  Calibration Type (@see enum LHCb::ODIN::CalibrationTypes). Meaningful only if bank version >= 5.
     const CalibrationTypes& calibrationType() const;
@@ -296,25 +297,25 @@ namespace LHCb {
 
   protected:
   private:
-    unsigned int       m_runNumber;      ///< Run number
-    unsigned int       m_eventType;      ///< Event type
-    unsigned int       m_orbitNumber;    ///< Orbit ID
-    unsigned long long m_eventNumber;    ///< L0 Event ID
-    unsigned long long m_gpsTime;        ///< GPS Time (microseconds)
-    unsigned long long m_detectorStatus; ///< Detector Status
-    unsigned int       m_errorBits;      ///< Error Bits
-    unsigned int       m_bunchId;        ///< Bunch ID
-    TriggerType        m_triggerType;    ///< Trigger Type @see enum LHCb::ODIN::TriggerType
-    ReadoutTypes m_readoutType; ///< Readout Type (@see enum LHCb::ODIN::ReadoutTypes). Meaningful only if bank version
-                                ///< < 5.
-    bool         m_forceBit;    ///< Force Bit
-    BXTypes      m_bunchCrossingType;            ///< Bunch Crossing Type (BXType, @see enum LHCb::ODIN::BXTypes)
-    unsigned int m_bunchCurrent;                 ///< Bunch Current
-    unsigned int m_version;                      ///< Version of the ODIN bank
-    unsigned int m_calibrationStep;              ///< Calibration Step Number
-    unsigned int m_triggerConfigurationKey;      ///< Requested Trigger Configuration Key. The key actually used is in
+    std::uint32_t m_runNumber;      ///< Run number
+    std::uint32_t m_eventType;      ///< Event type
+    std::uint32_t m_orbitNumber;    ///< Orbit ID
+    std::uint64_t m_eventNumber;    ///< L0 Event ID
+    std::uint64_t m_gpsTime;        ///< GPS Time (microseconds)
+    std::uint64_t m_detectorStatus; ///< Detector Status
+    std::uint32_t m_errorBits;      ///< Error Bits
+    std::uint32_t m_bunchId;        ///< Bunch ID
+    TriggerType   m_triggerType;    ///< Trigger Type @see enum LHCb::ODIN::TriggerType
+    ReadoutTypes  m_readoutType; ///< Readout Type (@see enum LHCb::ODIN::ReadoutTypes). Meaningful only if bank version
+                                 ///< < 5.
+    bool          m_forceBit;    ///< Force Bit
+    BXTypes       m_bunchCrossingType;           ///< Bunch Crossing Type (BXType, @see enum LHCb::ODIN::BXTypes)
+    std::uint32_t m_bunchCurrent;                ///< Bunch Current
+    std::uint32_t m_version;                     ///< Version of the ODIN bank
+    std::uint32_t m_calibrationStep;             ///< Calibration Step Number
+    std::uint32_t m_triggerConfigurationKey;     ///< Requested Trigger Configuration Key. The key actually used is in
                                                  ///< LHCb::HltDecReports::configuredTCK
-    unsigned int     m_timeAlignmentEventWindow; ///< TAE (Time Alignment Event) window size
+    std::uint32_t    m_timeAlignmentEventWindow; ///< TAE (Time Alignment Event) window size
     CalibrationTypes m_calibrationType; ///< Calibration Type (@see enum LHCb::ODIN::CalibrationTypes). Meaningful only
                                         ///< if bank version >= 5.
 
@@ -604,37 +605,37 @@ inline std::ostream& LHCb::ODIN::fillStream( std::ostream& s ) const {
   return s;
 }
 
-inline unsigned int LHCb::ODIN::runNumber() const { return m_runNumber; }
+inline std::uint32_t LHCb::ODIN::runNumber() const { return m_runNumber; }
 
-inline void LHCb::ODIN::setRunNumber( unsigned int value ) { m_runNumber = value; }
+inline void LHCb::ODIN::setRunNumber( std::uint32_t value ) { m_runNumber = value; }
 
-inline unsigned int LHCb::ODIN::eventType() const { return m_eventType; }
+inline std::uint32_t LHCb::ODIN::eventType() const { return m_eventType; }
 
-inline void LHCb::ODIN::setEventType( unsigned int value ) { m_eventType = value; }
+inline void LHCb::ODIN::setEventType( std::uint32_t value ) { m_eventType = value; }
 
-inline unsigned int LHCb::ODIN::orbitNumber() const { return m_orbitNumber; }
+inline std::uint32_t LHCb::ODIN::orbitNumber() const { return m_orbitNumber; }
 
-inline void LHCb::ODIN::setOrbitNumber( unsigned int value ) { m_orbitNumber = value; }
+inline void LHCb::ODIN::setOrbitNumber( std::uint32_t value ) { m_orbitNumber = value; }
 
-inline unsigned long long LHCb::ODIN::eventNumber() const { return m_eventNumber; }
+inline std::uint64_t LHCb::ODIN::eventNumber() const { return m_eventNumber; }
 
-inline void LHCb::ODIN::setEventNumber( unsigned long long value ) { m_eventNumber = value; }
+inline void LHCb::ODIN::setEventNumber( std::uint64_t value ) { m_eventNumber = value; }
 
-inline unsigned long long LHCb::ODIN::gpsTime() const { return m_gpsTime; }
+inline std::uint64_t LHCb::ODIN::gpsTime() const { return m_gpsTime; }
 
-inline void LHCb::ODIN::setGpsTime( unsigned long long value ) { m_gpsTime = value; }
+inline void LHCb::ODIN::setGpsTime( std::uint64_t value ) { m_gpsTime = value; }
 
-inline unsigned long long LHCb::ODIN::detectorStatus() const { return m_detectorStatus; }
+inline std::uint64_t LHCb::ODIN::detectorStatus() const { return m_detectorStatus; }
 
-inline void LHCb::ODIN::setDetectorStatus( unsigned long long value ) { m_detectorStatus = value; }
+inline void LHCb::ODIN::setDetectorStatus( std::uint64_t value ) { m_detectorStatus = value; }
 
-inline unsigned int LHCb::ODIN::errorBits() const { return m_errorBits; }
+inline std::uint32_t LHCb::ODIN::errorBits() const { return m_errorBits; }
 
-inline void LHCb::ODIN::setErrorBits( unsigned int value ) { m_errorBits = value; }
+inline void LHCb::ODIN::setErrorBits( std::uint32_t value ) { m_errorBits = value; }
 
-inline unsigned int LHCb::ODIN::bunchId() const { return m_bunchId; }
+inline std::uint32_t LHCb::ODIN::bunchId() const { return m_bunchId; }
 
-inline void LHCb::ODIN::setBunchId( unsigned int value ) { m_bunchId = value; }
+inline void LHCb::ODIN::setBunchId( std::uint32_t value ) { m_bunchId = value; }
 
 inline const LHCb::ODIN::TriggerType& LHCb::ODIN::triggerType() const { return m_triggerType; }
 
@@ -652,25 +653,25 @@ inline const LHCb::ODIN::BXTypes& LHCb::ODIN::bunchCrossingType() const { return
 
 inline void LHCb::ODIN::setBunchCrossingType( const BXTypes& value ) { m_bunchCrossingType = value; }
 
-inline unsigned int LHCb::ODIN::bunchCurrent() const { return m_bunchCurrent; }
+inline std::uint32_t LHCb::ODIN::bunchCurrent() const { return m_bunchCurrent; }
 
-inline void LHCb::ODIN::setBunchCurrent( unsigned int value ) { m_bunchCurrent = value; }
+inline void LHCb::ODIN::setBunchCurrent( std::uint32_t value ) { m_bunchCurrent = value; }
 
-inline unsigned int LHCb::ODIN::version() const { return m_version; }
+inline std::uint32_t LHCb::ODIN::version() const { return m_version; }
 
-inline void LHCb::ODIN::setVersion( unsigned int value ) { m_version = value; }
+inline void LHCb::ODIN::setVersion( std::uint32_t value ) { m_version = value; }
 
-inline unsigned int LHCb::ODIN::calibrationStep() const { return m_calibrationStep; }
+inline std::uint32_t LHCb::ODIN::calibrationStep() const { return m_calibrationStep; }
 
-inline void LHCb::ODIN::setCalibrationStep( unsigned int value ) { m_calibrationStep = value; }
+inline void LHCb::ODIN::setCalibrationStep( std::uint32_t value ) { m_calibrationStep = value; }
 
-inline unsigned int LHCb::ODIN::triggerConfigurationKey() const { return m_triggerConfigurationKey; }
+inline std::uint32_t LHCb::ODIN::triggerConfigurationKey() const { return m_triggerConfigurationKey; }
 
-inline void LHCb::ODIN::setTriggerConfigurationKey( unsigned int value ) { m_triggerConfigurationKey = value; }
+inline void LHCb::ODIN::setTriggerConfigurationKey( std::uint32_t value ) { m_triggerConfigurationKey = value; }
 
-inline unsigned int LHCb::ODIN::timeAlignmentEventWindow() const { return m_timeAlignmentEventWindow; }
+inline std::uint32_t LHCb::ODIN::timeAlignmentEventWindow() const { return m_timeAlignmentEventWindow; }
 
-inline void LHCb::ODIN::setTimeAlignmentEventWindow( unsigned int value ) { m_timeAlignmentEventWindow = value; }
+inline void LHCb::ODIN::setTimeAlignmentEventWindow( std::uint32_t value ) { m_timeAlignmentEventWindow = value; }
 
 inline const LHCb::ODIN::CalibrationTypes& LHCb::ODIN::calibrationType() const { return m_calibrationType; }