In This Package:

__init__.py

Go to the documentation of this file.

"""  
DybDbi python package provides access to most Dbi functionality,  
with generation of classes based on .spec files and wrapping of the 
python classes for easier usage,  enabling access to model objects via::
 
   from DybDbi import GCalibPmtSpec
   from DybDbi import *


Example of introspecting the specification::

   sk = GCalibPmtSpec.SpecKeys().aslist()    # list of row names
   sk
     ['PmtId',
      'Describ',
      'Status',
     ...

   sl = GCalibPmtSpec.SpecList().aslod()    # list of row maps ... list-of-dict 
   sl
     [{'code2db': '',
       'codetype': 'int',
       'dbtype': 'int(11)',
       'description': '',
       'legacy': 'PMTID',
       'memb': 'm_pmtId',
       'name': 'PmtId'},
      ...

   sm = GCalibPmtSpec.SpecMap().asdod()     # map of row maps, keyed by name    dict-of-dict
   sm
         {'AfterPulseProb': {'code2db': '',
                             'codetype': 'double',
                             'dbtype': 'float',
                             'description': 'Probability of afterpulsing',
                             'legacy': 'PMTAFTERPULSE',
                             'memb': 'm_afterPulseProb',
                             'name': 'AfterPulseProb'},
       ...

   sm['TimeOffset']['description']    # access any aspect of spec "matrix" directly by name
        'Relative transit time offset'


   sk = cls.SpecKeys().aslist()
   sm = cls.SpecMap().asdod()
   for k in sk:
       print sm[k]



"""
import os, pprint, inspect, logging

class NullHandler(logging.Handler):
    def emit(self, record):
        pass
h = NullHandler()
log = logging.getLogger("DybDbi")
log.addHandler(h)


## enum/function only "classes" like Dbi/SimFlag/Site/... must appear after the "real" classes that use them 
__all__ = """
Detector DetectorSensor
ServiceMode Context Site DetectorId SimFlag TimeStamp ContextRange
DbiSqlValPacket DbiValRecSet DbiTableProxyRegistry DbiValidityRec DbiSqlContext DbiCascader DbiConnection DbiStatement DbiCache DbiTableProxy Dbi
DybDbi DbiCtx Ctx 
""".strip().split()

## kickstarting ROOT before GaudiPython allows gbl.cout, gbl.stringstream to work, used in test_10
from ROOT import TObject,TList,TMap

## make TMap and TList palatable from python ... this is not general: restricted to string keys and more
TMap.__getitem__ = lambda self,k:self.GetValue(k)
TMap.asdict = lambda self:dict([(str(k),self.GetValue(k)) for k in self])
TList.aslist = lambda self:list([str(k) for k in self])
TList.aslod = lambda self:list([k.asdict() for k in self])   ## as list of dict 
TMap.asdod = lambda self:dict([(str(k),self.GetValue(k).asdict()) for k in self])  ## as dict of dict


  
from GaudiPython import gbl
_getattr = lambda n:(n,getattr(gbl,n,None) or getattr(gbl,"DayaBay::%s" % n) )
clss = map(_getattr,__all__)
locals().update( clss )                    ## Dbi and Context related classes 

## instances 
DybDbi.Instance()           ## instanciates gDbi, does not hit DB until registry is accessed
gDbi = gbl.gDbi
__all__ += "gDbi".split()

## generated DbiTableRow subclasses  
import genDbi
dtrs = inspect.getmembers(genDbi,lambda o:inspect.isclass(o) and o.__name__[0] == 'G')
locals().update( dtrs  )
GNAMES = map( lambda _:_[0] , dtrs )  
__all__ += GNAMES + ["GNAMES"]

## skips must be defined before wrapping generates the repr and adds properties
DbiCascader.__skip__ = "Connection DbName DbNo Status StatusAsString URL TableDbNo".split()
DbiValidityRec.__skip__ = "Owner Index Row RowByIndex TableProxy".split()
DbiTableProxy.__skip__ = "Cascader DBProxy MetaData MetaValid RowName TableName".split()
DbiTableProxyRegistry.__skip__ = "TableProxy".split()

## special handling of some attributes used in the generated repr 
attfn = dict(
     UpdateMask=lambda obj:("UpdateMask",Ctx.StringFromMask( obj.GetUpdateMask() )),
           Mask=lambda obj:("Mask", Ctx.StringFromMask( obj.GetMask() )),
        SimMask=lambda obj:("SimMask",SimFlag.StringFromMask( obj.GetSimMask() )),
       SiteMask=lambda obj:("SiteMask",Site.StringFromMask( obj.GetSiteMask() )),
  )


## publish the CSV tools 
from csvrw import CSV, Source
from mapper import Mapper


## wrap Dbi classes with property accessors and repr 
from wrap import Wrap
for n,cls in clss:
    #print n
    Wrap.wrap(cls, attfn)

## wrap DbiTableRow subclasses and associated templated classes
for n,dtr in dtrs: 
    #print n
    dtr.__skip__ = "Owner Index Row RowByIndex".split()
    if hasattr( dtr, 'Docstring' ):
        dtr.__doc__ = dtr.Docstring
    Wrap.wrap( dtr )
    Wrap.wrap( getattr(gbl, "DbiRpt<%s>" % n ) )
    Wrap.wrap( getattr(gbl, "DbiWrt<%s>" % n ) )
    
def DbiCascader__getitem__(self, i ):
    l = self.GetNumDb()
    if -1 < i < l:
        return self.GetConnection(i)
    raise IndexError("out of range for index %d" % i )  
DbiCascader.__getitem__ = DbiCascader__getitem__
DbiCascader.__len__ = DbiCascader.GetNumDb

def DbiCascader__repr__(self):
    smry = "DbiCascader numdb %s authorisingdbno %s (1st with GLOBALSEQNO) " % ( self.GetNumDb(), self.GetAuthorisingDbNo() ) 
    return "\n".join([smry] + [ "%-10s %s " % ( self.GetStatusAsString(i), repr(con)) for i,con in enumerate(self) ])
DbiCascader.__repr__ = DbiCascader__repr__
            
def DbiCascader__check(self):
    for i,con in enumerate(self):
        n = con.numconnectedstatements
        assert n == 0 , ( n, i, con )
DbiCascader.check = DbiCascader__check

def DbiConnection__repr__(self):
    return  " %-20s #%d %-10s %-10s %s " % ( self.GetDbName(), self.GetNumConnectedStatements(), ("not-tmp","tmp")[self.IsTemporary()] , ("open","closed")[self.IsClosed()] , self.GetUrl() ) 
DbiConnection.__repr__ = DbiConnection__repr__

def DbiStatement__del__(self):
    print "DbiStatement__del__ committing hari-kari "
    self.IsA().Destructor(self)  ## hari-kari   http://wlav.web.cern.ch/wlav/pyroot/memory.html
DbiStatement.__del__ = DbiStatement__del__


def DbiCtx__repr__(self):
    """
    Special handling of the DbiCtx repr so that only properties 
    that have been set (as recorded in the "mask" property ) are shown  
    """
    getters = Wrap(DbiCtx).getters 
    prps = [ (g,getattr(self,'Get%s'%g)()) for g in getters if getattr( Ctx,'k%s'%g , 0) & self.mask > 0 or getattr( Ctx,'k%s'%g , 0) == 0 ] 
    return pprint.pformat( dict( prps ) ,indent=4)
DbiCtx.__repr__ = DbiCtx__repr__

def DbiCtx__call__( self, *args , **kwa ):
    """
    Shorthand context attribute setting in kwa style
    """
    for arg in args:
        self.Update(arg)
    for k,v in kwa.items():
        setattr( self, k, v )
    return self
DbiCtx.__call__ = DbiCtx__call__


def DybDbi__comment( self, *args , **kwa ):
    """ 
    Cheap trick to scribble on the mysql command list ... in order to see the order of things::

         gDbi.comment("hello","world")

    """
    dbno = kwa.pop('dbno', 0)
    comment = "\n".join(map(lambda l:"# %s"%l, args))
    log.info( comment )
    self.cascader[dbno].CreatePreparedStatement( comment )
    pass
DybDbi.comment = DybDbi__comment






## Detector subclass attributes with known representations, needed as do not follow Get/Set convention ... 
detector_reps = dict( 
   detName=lambda x:x.detName(),
   site=lambda x:Site.AsString(x.site()) , 
   detectorId=lambda x:DetectorId.AsString(x.detectorId()),  
   sensorId=lambda x:x.sensorId(),
   ring=lambda x:x.ring(),
   column=lambda x:x.column(),
   wallNumber=lambda x:x.wallNumber(),
   wallSpot=lambda x:x.wallSpot(),
   panelRow=lambda x:x.panelRow(),
   layer=lambda x:x.layer(),
   strip=lambda x:x.strip(),
)
DetectorSensor.__repr__ = lambda self:pprint.pformat(dict([(n,detector_reps[n](self) ) for n in dir(DetectorSensor) if n in detector_reps ]), indent=4 )    


from TimeStampExt import *


## reluctant to hive-off due to gDbi
from nose.tools import make_decorator
from datetime import datetime


from DybPython import DBConf, DBCas

class Level(int):
    """

         ===============   =========================================
           OutputLevel 
         ===============   =========================================
          WARNING (110)      quiet enough for overview of errors 
          INFO (100)         normal
          DEBUG (50)         quite a few errors to chase
         ===============   =========================================
    """
    levels = dict( VERBOSE=1, DEBUG3=60, DEBUG2=70, DEBUG1=80, MONITOR=90, INFO=100, WARNING=110, ERROR=130, FATAL=140, NEVER=99999 )
    def From(cls, s):
        """Converts level names to DBI OutputLevel enum integers, or vv """
        if isinstance( s, basestring):
            val = cls.levels.get( s.upper() , None)
            assert val , "level %s is not recogized %s " % ( s, repr(cls.levels) )  
            return Level(val)            
        elif isinstance( s, int ):
            return Level(s)
        else:
            return None
    From = classmethod(From)
    def __repr__(self):
        return "Level %s " % ( int(self) )   

def LOG(level="INFO"):
    """
    By wrapping a test function with this decorator,
    the logging level is changed to the chosen level 
    while the test is running.
    """
    level = Level.From(level)
    def _decorate(func):
        def _wrapper(*args, **kargs):
            gDbi.comment("entering %s " % func.__name__ , "")
            ol = gDbi.GetOutputLevel()
            gDbi.SetOutputLevel(level)
            func(*args, **kargs)
            gDbi.SetOutputLevel(ol)
            gDbi.comment("exiting %s " % func.__name__ , "")
        _wrapper = make_decorator(func)(_wrapper)
        return _wrapper
    return _decorate

def MYSQLDUMP(level="INFO", opt=" --extended-insert=0 --skip-comments " , cfdir=None, reference=False ):
    """
    By wrapping a test function with this decorator,
    the database is mysqldumped after the test has run 
   
    The output dumps are saved in a directory created at path  
    based on the names of test module and function
    """
    level = Level.From(level)
    def _decorate(func):
        def _wrapper(*args, **kargs):
            print "MYSQLDUMP for func %s  " % ( func.__name__ )
            ol = gDbi.GetOutputLevel()
            gDbi.SetOutputLevel(level)
            func(*args, **kargs)
            gDbi.SetOutputLevel(ol)
            dir = os.path.join( os.getcwd(), "tests", func.__module__ , func.__name__ ) 
            DBCas.Dump( dir=dir, opt=opt , cfdir=cfdir, reference=reference )
        _wrapper = make_decorator(func)(_wrapper)
        return _wrapper
    return _decorate


def POST(level="WARNING"):
    """
    By wrapping a test function with this decorator, some 
    post test checks are performed on the cascade

    Distributing usage of this throughout the a collection of 
    nosetests is useful when searching for which test is messing something up.  
    """ 
    level = Level.From(level)
    def _decorate(func):
        def _wrapper(*args, **kargs):
            print "POST for func %s  " % ( func.__name__ )
            ol = gDbi.outputlevel
            gDbi.outputlevel = level
            func(*args, **kargs)
            gDbi.cascader.check()
            gDbi.outputlevel = ol
        _wrapper = make_decorator(func)(_wrapper)
        return _wrapper
    return _decorate




__all__ += "LOG MYSQLDUMP POST".split()

---