def _py_init_ClassIDSvc(): import cppyy # IClassIDSvc bindings from dictionary _load_dict("libAthenaPythonDict") # make sure the global C++ namespace has been created gbl = cppyy.makeNamespace('') # noqa: F841 # load the AthenaInternal::getClid helper method cppyy.makeNamespace('AthenaInternal') # Really make sure that dictionaries are loaded. # Needed this with 20.7.X-VAL. cppyy.gbl.AthenaInternal.ROOT6_AthenaPython_WorkAround_Dummy # retrieve the IClassIDSvc class global IClassIDSvc IClassIDSvc = cppyy.gbl.IClassIDSvc _missing_clids = { 'DataHistory': 83814411, 83814411: 'DataHistory', } # re-use the python-based clid generator # (faster than calling back into C++ via Reflex bindings) from CLIDComps.clidGenerator import clidGenerator IClassIDSvc._clidgen = clidGenerator(db=None) # add pythonized methods @memoize def _clid(self, name): # handle special cases where CLID has been registered with a typedef try: name = _clid_typename_aliases[name] except KeyError: pass try: return _missing_clids[name] except KeyError: pass return self._clidgen.getClidFromName(name) IClassIDSvc.clid = _clid del _clid @memoize def _typename(self, clid): # handle special cases of missing clids try: return _missing_clids[clid] except KeyError: pass return self._clidgen.getNameFromClid(clid) IClassIDSvc.typename = _typename del _typename return IClassIDSvc
def test2GenClids( self ): """Testing clidGenerator with no clid.db""" # get rid of expected error message sys.stdout = open("dummyIgnore.txt", 'w') self.cgen = clidGenerator("NOTTHERE.db") sys.stdout = sys.__stdout__ os.remove("dummyIgnore.txt"); self.assertEqual( 245732527, self.cgen.genClidFromName("DataObject") ) self.assertEqual( 205083834, self.cgen.genClidFromName("Data<Foo23_45___Bar_, dsfl__>") )
def gen_typeregistry_dso(oname=_dflt_typereg_fname): '''inspect all the accessible reflex types and get their rootmap-naming. also associate the clid if available. ''' import CLIDComps.clidGenerator as _c cliddb = _c.clidGenerator(db=None) del _c import PyUtils.path as _p oname = _p.path(oname) del _p import PyUtils.Logging as _L msg = _L.logging.getLogger('typereg-dso') msg.setLevel(_L.logging.INFO) #msg.setLevel(_L.logging.VERBOSE) #MN del _L msg.info("installing registry in [%s]...", oname) # FIXME: should use the Cxx one... #reg = DsoDb() reg = PyDsoDb() cls_names = reg.db.keys() import cppyy _load_lib = cppyy.loadDict # if int(cppyy.get_version().split('.')[0]) < 6: if hasattr(cppyy, 'hasCintex'): # load reflex for ROOT ver<6 msg.debug("::: loading reflex") _load_lib('libReflexRflx.so') rflx = cppyy.makeNamespace('Reflex') if not rflx: rflx = cppyy.makeNamespace('ROOT::Reflex') rflx = rflx.Type assert (rflx) def _load_dict(libname, retry=10): msg.debug("::: loading [%s]...", libname) try: return _load_lib(libname) except ( Exception, SystemError, ), err: msg.warning("**error** %s", err) return
def gen_typeregistry_dso(oname=_dflt_typereg_fname): '''inspect all the accessible reflex types and get their rootmap-naming. also associate the clid if available. ''' import CLIDComps.clidGenerator as _c cliddb = _c.clidGenerator(db=None) del _c import PyUtils.path as _p oname = _p.path(oname) del _p import PyUtils.Logging as _L msg = _L.logging.getLogger('typereg-dso') #msg.setLevel(_L.logging.INFO) msg.setLevel(_L.logging.VERBOSE) del _L msg.info("installing registry in [%s]...", oname) # FIXME: should use the Cxx one... #reg = DsoDb() reg = PyDsoDb() cls_names = reg.db.keys() msg.debug("::: loading reflex") import PyCintex PyCintex.Cintex.Enable() PyCintex.loadDict('libReflexRflx.so') rflx = PyCintex.makeNamespace('Reflex') if not rflx: rflx = PyCintex.makeNamespace('ROOT::Reflex') rflx = rflx.Type assert(rflx) import PyCintex _load_lib = PyCintex.loadDict def _load_dict(libname,retry=10): msg.debug("::: loading [%s]...", libname) try: return _load_lib(libname) except (Exception,SystemError,), err: msg.warning("**error** %s", err) return
def _extract_fields_esi(value): result = {} result['eventTypes'] = [] for eventType in value.m_eventTypes: result['eventTypes'].append(_convert_value(eventType)) result['numberOfEvents'] = value.m_numberOfEvents result['runNumbers'] = list(value.m_runNumbers) result['lumiBlockNumbers'] = list(value.m_lumiBlockNumbers) result['processingTags'] = list(value.m_processingTags) result['itemList'] = [] # Get the class name in the repository with CLID <clid> from CLIDComps.clidGenerator import clidGenerator cgen = clidGenerator("") for clid, sgkey in value.m_itemList: result['itemList'].append((cgen.getNameFromClid(clid), sgkey)) return result
Python script that creates C++ .h/.cxx files that contain the container and object class representing the structure of a database folder. """ import argparse import os.path import string import sys import uuid from CLIDComps.clidGenerator import clidGenerator from PyCool import cool, coral _dbSvc = cool.DatabaseSvcFactory.databaseService() _cliddb = clidGenerator("") _container_header = """// -*- C++ -*- #ifndef TRIGT1CALOCALIBCONDITIONS_${CONTAINERNAME}_H #define TRIGT1CALOCALIBCONDITIONS_${CONTAINERNAME}_H #include <map> #include <string> #include <vector> #include "AthenaKernel/CLASS_DEF.h" #include "GaudiKernel/DataObject.h" #include "TrigT1CaloCalibConditions/AbstractL1CaloPersistentCondition.h" #include "TrigT1CaloCalibConditions/L1CaloCoolChannelId.h" class CondAttrListCollection; class ${ObjectName};
cppyy.gbl.AthenaInternal.ROOT6_AthenaPython_WorkAround_Dummy _getClid = cppyy.gbl.AthenaInternal.getClid # retrieve the IClassIDSvc class global IClassIDSvc IClassIDSvc = cppyy.gbl.IClassIDSvc _missing_clids = { 'DataHistory': 83814411L, 83814411L: 'DataHistory', } # re-use the python-based clid generator # (faster than calling back into C++ via Reflex bindings) from CLIDComps.clidGenerator import clidGenerator IClassIDSvc._clidgen = clidGenerator(db=None) # add pythonized methods @memoize def _clid(self, name): # handle special cases where CLID has been registered with a typedef try: name = _clid_typename_aliases[name] except KeyError: pass try: return _missing_clids[name] except KeyError: pass return self._clidgen.getClidFromName(name)
def test1ClidDB(self): """Testing clidGenerator with Gaudi_clid.db""" self.cgen = clidGenerator("Gaudi_clid.db") self.assertEqual(1, self.cgen.genClidFromName("DataObject")) self.assertEqual("DataObject", self.cgen.getNameFromClid(1))
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration from __future__ import print_function import cppyy from CLIDComps.clidGenerator import clidGenerator clidg = clidGenerator("") from ROOT import HLT stringSerializer = cppyy.gbl.StringSerializer() class hltResult(HLT.HLTResult): def __init__(self): super(hltResult, self).__init__() self.as_int_v = cppyy.gbl.std.vector('unsigned int')() def load(self, rob): self.nav_payload = [] data = list(rob.rod_data()) self.as_int_v.clear() self.as_int_v.reserve(len(data)) [self.as_int_v.push_back(i) for i in data] if self.deserialize(self.as_int_v) is False: raise Exception('deserialization of the HLT result failed') self.__unpack_navigation() def __unpack_navigation(self): nav_data = list(self.getNavigationResult()) if len(nav_data) <= 1:
if doEDM: from TriggerJobOpts.TriggerEDM import EDMDetails for item in EDMDetails.keys(): pers = EDMDetails[item]['persistent'] objects.append(pers) for pers in objects: SIG.inspect(pers) print fulllist = SIG.classlist print fulllist print '*******************************' from CLIDComps.clidGenerator import clidGenerator cgen = clidGenerator("") types_new = 0 types_exist = 0 types_bad = 0 fulllist = list(set(fulllist)) for item in fulllist: if doxAODonly and not 'xAOD' in item: continue # current issues seen because of missing xAOD libs not being loaded print "Trying to fill item", item, "to root file" c_clid = cgen.genClidFromName(item) c_typeinfo = cgen.getTidFromClid(c_clid) print "CLID", c_clid print "TypeInfo", c_typeinfo try: cls = ROOT.gROOT.GetClass(item)
def setDefaults(cls, handle): ## continue, only if it is our Configurable if not isinstance(handle, ThinningSvc): return from AthenaCommon.AlgSequence import AlgSequence ## get a handle on the ToolSvc from AthenaCommon.AppMgr import ToolSvc as toolSvc from AthenaCommon.AppMgr import ServiceMgr as svcMgr from AthenaCommon.Logging import logging msg = logging.getLogger(handle.name()) from CLIDComps.clidGenerator import clidGenerator cliddb = clidGenerator(db=None) def _clid_from_string(s): """return the clid (integer) from a string (which can either contain the integer or the clid-name associated with it.) """ try: clid = int(s) except ValueError: clid = cliddb.getClidFromName(s) if clid is None or clid == 'None': msg.warning('could not infer clid-name for: "%s"', s) clid = None return clid from PyUtils.Decorators import memoize @memoize def _retrieve_items_from_input(): items = [] from AthenaCommon.AppMgr import ServiceMgr as svcMgr import PyUtils.PoolFile as _pf # only inspect the first input file # that should be enough as we don't really support varying schema # shapes anymore (as ROOT doesn't) items = _pf.extract_items(svcMgr.EventSelector.InputCollections[0]) input_items = [] for item in items: clid = _clid_from_string(item[0]) if clid is None: msg.warning('could not infer clid for: "%s"', item[0]) clid = item[0] # put back the original string, then. input_items.append([clid, item[1]]) return input_items def _doScheduleTool(outStream, streamNames): outStreamName = outStream.name() return outStreamName in streamNames def _build_proxy_list(outStream): """helper to access the 'ForceRead' and 'TakeItemsFromInput' properties of the output stream to build a list of pairs (clid,key) the thinning tool will forcingly read during the pre-execute step. """ from collections import defaultdict proxies = defaultdict(list) props = outStream.properties() from_input = outStream.properties()['TakeItemsFromInput'] if from_input == outStream.propertyNoValue: from_input = outStream.getDefaultProperty('TakeItemsFromInput') ## fetch the items to be written out itemlist = outStream.properties()['ItemList'][:] for item in itemlist: clid_or_name, sg_key = item.split('#') clid_or_name = clid_or_name.strip() sg_key = sg_key.strip() clid_or_name = _clid_from_string(clid_or_name) if clid_or_name is None: msg.warning('could not infer clid for: "%s"', item) else: if len(sg_key) == 0: msg.warning('invalid key for item: "%s"', item) else: proxies[clid_or_name].append(sg_key) if from_input: input_items = _retrieve_items_from_input() for clid, sg_key in input_items: proxies[clid].append(sg_key) d = proxies proxies = [] for clid, sg_keys in d.iteritems(): sg_keys = list(set(sg_keys)) proxies.extend([[str(clid), sg_key] for sg_key in sg_keys]) return proxies # filter out duplicates streams = [o for o in set(handle.Streams[:])] ## list of streams we know we will apply thinning on outstreams = [] ## connect @c ThinningOutputTool into the HelperTools slot AthenaOutputStream = CfgMgr.AthenaOutputStream ## first loop over TopAlg (as output stream can be located ## into that sequence) for o in AlgSequence("TopAlg"): if (isinstance(o, AthenaOutputStream) and hasattr(o, 'HelperTools') and _doScheduleTool(o, streams)): outstreams.append(o) pass ## then loop over OutStream sequence if AlgSequence.configurables.has_key('Streams'): for o in AlgSequence("Streams"): if (isinstance(o, AthenaOutputStream) and hasattr(o, 'HelperTools') and _doScheduleTool(o, streams)): outstreams.append(o) pass ## set the streams we found setattr(handle, 'Streams', [o.name() for o in outstreams]) if len(outstreams) <= 0: handle.Streams = [] msg.warning("No output stream will be thinned !") msg.warning("Check your jobOptions configuration") msg.warning("...performing hara-kiri...") delattr(svcMgr, handle.name()) del handle return _lvl = handle.properties()['OutputLevel'] if _lvl == handle.propertyNoValue: _lvl = handle.getDefaultProperty('OutputLevel') pass ## get and install the ThinningOutputTool configurable from AthenaServicesConf import ThinningOutputTool toolName = "ThinningTool_%s" % handle.name() tool = ThinningOutputTool(toolName, OutputLevel=_lvl, ThinningSvc=handle) tool.Proxies = [] for o in outstreams: tool.Proxies += _build_proxy_list(o) o.HelperTools.insert(0, tool) ## XXX FIXME XXX ## see https://savannah.cern.ch/bugs/index.php?40823 o.HelperTools += [] # just to work-around bug #40823 ## return
#!/usr/bin/env python # Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration from AthenaCommon.Logging import logging log = logging.getLogger('testEDM') from TriggerEDM import (TriggerL2List, TriggerEFList, TriggerResultsList, TriggerResultsRun1List, TriggerLvl1List, TriggerIDTruth, TriggerHLTList) from TriggerEDMRun2 import EDMDetails from CLIDComps.clidGenerator import clidGenerator cgen = clidGenerator("", False) def isCLIDDefined(typename): c = cgen.genClidFromName(typename) pkg = cgen.getPackageFromClid(c) return bool(pkg) def main(): import re serializable_names = [] serializable_names_no_label = [] TriggerList = TriggerL2List + TriggerEFList + TriggerResultsList + TriggerResultsRun1List + TriggerLvl1List + TriggerIDTruth + TriggerHLTList for TriggerSerializable in TriggerList: #print TriggerSerializable serializable_name = TriggerSerializable[0] serializable_name_no_label = re.sub(r"\#.*", "", serializable_name) if '#' not in serializable_name: log.error("ERROR, no label for " + serializable_name)
cppyy.gbl.AthenaInternal.ROOT6_AthenaPython_WorkAround_Dummy _getClid = cppyy.gbl.AthenaInternal.getClid # retrieve the IClassIDSvc class global IClassIDSvc IClassIDSvc = cppyy.gbl.IClassIDSvc _missing_clids = { 'DataHistory' : 83814411L, 83814411L : 'DataHistory', } # re-use the python-based clid generator # (faster than calling back into C++ via Reflex bindings) from CLIDComps.clidGenerator import clidGenerator IClassIDSvc._clidgen = clidGenerator(db=None) # add pythonized methods @memoize def _clid (self, name): # handle special cases where CLID has been registered with a typedef try: name = _clid_typename_aliases[name] except KeyError: pass try: return _missing_clids[name] except KeyError: pass return self._clidgen.getClidFromName(name) IClassIDSvc.clid = _clid del _clid @memoize