pmthv.py

Go to the documentation of this file.

"""
PMT HV scraping specialization 
"""
import os, logging
log = logging.getLogger(__name__)

from datetime import datetime, timedelta

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



class PmtHv(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:PmtHvSource( DCS(self['source']) ))
    scraper = property( lambda self:PmtHvScraper(self.srcs, self.target, self ))
    faker   = property( lambda self:PmtHvFaker(self.srcs,self ))



class PmtHvSource(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 
        Accommodates a table naming irregularity HVPw rather than HV_Pw
        """
        dtn = SourceContext(table="DBNS_AD1_HV_Vmon:DBNS_AD1_HV_Pw",ksite="kDayaBay",ksubsite="kAD1", attjoin='id', pfxjoin='P_' )  
        self.append( srcdb.kls(dtn) )
        dtn = SourceContext(table="DBNS_AD2_HV_Vmon:DBNS_AD1_HV_Pw",ksite="kDayaBay",ksubsite="kAD2", attjoin='id', pfxjoin='P_' )  
        self.append( srcdb.kls(dtn) )
        dtn = SourceContext(table="LANS_AD3_HV_Vmon:LANS_AD3_HV_Pw",ksite="kLingAo",ksubsite="kAD1", attjoin='id', pfxjoin='P_' )  
        self.append( srcdb.kls(dtn) )
        dtn = SourceContext(table="FARS_AD4_HV_Vmon:FARS_AD4_HV_Pw",ksite="kFar",ksubsite="kAD1", attjoin='id', pfxjoin='P_' )  
        self.append( srcdb.kls(dtn) )
        dtn = SourceContext(table="FARS_AD5_HV_Vmon:FARS_AD5_HV_Pw",ksite="kFar",ksubsite="kAD2", attjoin='id', pfxjoin='P_' )  
        self.append( srcdb.kls(dtn) )
        dtn = SourceContext(table="FARS_AD6_HV_Vmon:FARS_AD6_HV_Pw",ksite="kFar",ksubsite="kAD3", attjoin='id', pfxjoin='P_' )  
        self.append( srcdb.kls(dtn) )


class PmtHvScraper(Scraper):
    lcr_matcher = LCR()   

    def changed(self, sv  ):
        """
        :param sv: source vector instance :py:class:`Scraper.base.sourcevector.SourceVector` 

        Decide if sufficient change to propagate based on differences between the first and last elements of `SourceVector` instance argument
        """
        p = self._lcrdict( sv[0] )
        c = self._lcrdict( sv[-1] )
        for lcr in sorted(p.keys()):
            pv = p[lcr]
            cv = c[lcr]
            if abs(pv['pw']-cv['pw']) > 0:
                return True
            if abs(pv['voltage']-cv['voltage']) > self.threshold:
                return True
        return False

    def propagate(self, sv ):
        """
        :param sv: source vector instance :py:class:`Scraper.base.sourcevector.SourceVector` 

        Yield write ready DybDbi target dicts to base class, note that a single source vector
        instance is yielding multiple target dicts. The keys of the target dict must match
        the specified attributes of the ``DybDbi`` target class. 

        Here the output is based entirely on the last element of the source vector. A smarter
        implementation might average the first and last to smooth variations.
        The python ``yield`` command makes it possible to iterate over a what is returned by 
        a function/method.

        """
        dd = self._lcrdict(sv[-1])
        n = 0
        for (l,c,r),v in sorted(dd.items()):
            d = dict(Ladder=l,Column=c,Ring=r,Voltage=float(v['voltage']),Pw=v['pw'])
            n += 1
            yield d 
        log.debug("yielded %s target dicts for  %s " % ( n, sv ))


    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(Ladder=1,Column=1,Ring=1,Voltage=0,Pw=0)


    def _lcrdict(self, inst):
        """
        :param inst:  SQLAlchemy source instance

        Examines source instance, extracting ladder,col,ring and values and collecting into a dict.
        Note the source is an instance of an SQLAlchmemy dynamic class that maps to the join of 
        two tables.

        This method is not not fulfilling any particular interface, it is just a helper to the 
        other methods, and thus avoids duplication. 
        """ 
        dd = {}
        for k,v in inst.asdict.items():
            if k in 'P_id id date_time P_date_time'.split():
                continue 
            qty,kk = ('pw',k[2:]) if k.startswith('P_') else ('voltage',k)
            lcr = self.lcr_matcher(kk)  
            if dd.has_key(lcr):
                dd[lcr].update({qty:v})
            else:
                dd[lcr] = {qty:v}
        return dd


class PmtHvFaker(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():
                 pass
                 #setattr( inst, k, id )   ## not setting the id leads to AUTO_INCREMENT kicking in which can avoid integrity errors from duplicate keys 
            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