mucalcopy.py

Go to the documentation of this file.

"""
Muon Calibration scraping specialization 
"""
import os, logging,time
log = logging.getLogger(__name__)
from datetime import datetime

from base import Regime, Scraper, Target, Faker, DCS, SourceContext
from dcs import LCR,NSF


class MuCalCopy(Regime):
    """
    Regime frontend class with simple prescribed interface, 
    takes the cfg argument into this dict and no args in call.
    This allows the frontend to be entirely generic.
    """

    srcs    = property( lambda self:MuCalCopySource( DCS(self['source']) ))
    scraper = property( lambda self:MuCalCopyScraper(self.srcs, self.target, self ))
    faker   = property( lambda self:MuCalCopyFaker(self.srcs,self ))



class MuCalCopySource(list):
    def __init__(self, srcdb):    
        """
        :param srcdb: source DB instance of :py:class:`Scraper.base.DCS` 

        List of source SA classes that map tables/joins in srcdb 
        """
        dtn = SourceContext(name="DBNS_MUCAL_IWS",table="DBNS_MUCAL",ksite="kDayaBay",ksubsite="kIWS")
        self.append( srcdb.kls(dtn) )
        dtn = SourceContext(name="DBNS_MUCAL_OWS",table="DBNS_MUCAL",ksite="kDayaBay",ksubsite="kOWS")
        self.append( srcdb.kls(dtn) )        
        dtn = SourceContext(name="LANS_MUCAL_IWS",table="LANS_MUCAL",ksite="kLingAo",ksubsite="kIWS")
        self.append( srcdb.kls(dtn) )
        dtn = SourceContext(name="LANS_MUCAL_OWS",table="LANS_MUCAL",ksite="kLingAo",ksubsite="kOWS")
        self.append( srcdb.kls(dtn) )
        dtn = SourceContext(name="FARS_MUCAL_IWS",table="FARS_MUCAL",ksite="kFar",ksubsite="kIWS")
        self.append( srcdb.kls(dtn) )
        dtn = SourceContext(name="FARS_MUCAL_OWS",table="FARS_MUCAL",ksite="kFar",ksubsite="kOWS")
        self.append( srcdb.kls(dtn) )        
        
class MuCalCopyScraper(Scraper):
    lcr_matcher = LCR()
    nsf_matcher = NSF()

    def __call__(self):
        """
        Spin the scrape infinite loop, sleeping at each pass.
        Within each pass loop over source vectors and check for propagate readyiness 

        Local copy to pick up local copy of output writer
        """
        i,w = 0,0
        while i<self.maxiter or self.maxiter==0:
            i += 1
            log.debug("i %s " % i )
            for sv in self:
                proceed = sv()  
                if not proceed:
                    continue 

                wrt = self.writer( sv ) 
                #log.debug("wrt %r " % wrt )

                for td in self.propagate( sv ):           ## iterate over "yield" supplier of target dicts   
                    log.debug("td %r " % td )
                    tdi = self.target.instance(**td)      ## may fail with type errors
                    log.debug("tdi %r " % tdi )
                    wrt.Write(tdi)                        ## RuntimeError basic_string::_S_construct NULL not valid (C++ exception) here

                if wrt.Close():                           ## hits target DB here
                    log.debug("write %s succeeded %s " % ( w, sv) )
                    timeend = wrt.ctx.contextrange.timeend     ## UTC TimeStamp
                    sv.tcursor = timeend.UTCtoNaiveLocalDatetime + self.interval
                    self.tunesleep(w) 
                    w += 1
                else:
                    log.fatal("writing failed %s " %  sv )
                    assert 0
            self.handle_signal()
            time.sleep(self.sleep.seconds) ## uncomfortable with common sleep here ... 
        pass


    def changed(self, sv  ):
        """
        Always copy new entries, but only IWS/OWS for IWS/OWS valididy
        """
        inststr= str(sv[-1])
        for k,v in sv[-1].asdict.items():
            if k == 'IOW_CAL_LED_ID':
                ledid=v
        checkpool = int((ledid - 10000*int(ledid/10000))/1000)
        if ((checkpool == 0) and (inststr.find("OWS") > 0)):
            return True
        elif ((checkpool != 0) and (inststr.find("IWS") > 0)):
            return True
        else:
            return False

    def propagate(self, sv ):
        """
        Copy values directly from sourcevector
        """

        for k,v in sv[-1].asdict.items():
            if k == 'IOW_CAL_LED_ID':
                ledid=v
            if k == 'IOW_CAL_LED_ID_Voltage':
                voltage=v
            if k == 'IOW_CAL_LED_ID_Frequency':
                frequency=v
            if k == 'IOW_CAL_Channel_ID':
                chanid=v
            if k == 'IOW_CAL_ErrorCode':
                error=v
        d = dict(LedId=ledid,Voltage=voltage,Frequency=frequency,ChannelId=chanid,ErrorCode=error)
        yield d

    def seed(self, sc):
        """
        Used for seeding target DB when testing into empty tables

        :param sc: source class, potentially different seeds will be needed 
                   for each source that feeds into a single target
        """
        return dict(LedId=1,Voltage=0.0,Frequency=0.0,ChannelId=1,ErrorCode=0)

    def writer(self, sv , localstart=None, localend=None ):
        """
        Prepare DybDbi writer for target class, with contextrange/subsite appropriate for the source instance

        Local copy for writing MuCal table - want the validity to be based on the LED
        start and stop times from the DCS table

        :param sv:  source vector instance that contains instances of an SA mapped class
        :param localstart: default of `None` corresponds to `sv[0].date_time`
        :param localend: default of `None` corresponds to `sv[-1].date_time`
        """

        for k,v in sv[-1].asdict.items():
            if k == 'IOW_CAL_LED_ID_timestamp_begin':
                start=v
            if k == 'IOW_CAL_LED_ID_timestamp_end':
                end=v

        return Target._wrt( sv[0].__class__ , self.target.kls , start, end ) 

class MuCalCopyFaker(Faker):
    """
    Creates fake instances and inserts them into sourcedb   
    """
    lcr_matcher = LCR()   
    def fake(self, inst, id , dt ):
        """
        Invoked from base class call method, 
        set attributes of source instance to form a fake 

        :param inst: source instance
        :param id: id to assign to the instance instance
        """
        fakefn=lambda (l,c,r),qty:l*100 + c*10 + r if qty == "voltage" else 1 
        for k,v in inst.asdict.items():
            if k in 'id P_id'.split():
                 setattr( inst, k, id )
            elif k in 'date_time P_date_time'.split():
                 setattr( inst, k, dt )
            else:
                qty,kk = ('pw',k[2:]) if k.startswith('P_') else ('voltage',k)
                lcr = self.lcr_matcher(kk)    
                setattr( inst , k, fakefn( lcr, qty) )


if __name__ == '__main__':
    pass