adlid.py

Go to the documentation of this file.

"""
"""
import os, logging
import random
from datetime import datetime, timedelta
from pprint import pformat

from base import Regime, Averager, Faker, DCS, SourceContext

log = logging.getLogger(__name__)

class AdLid(Regime):
    """
    Regime frontend class with simple prescribed interface, 
    takes the cfg argument into this dict and no args in call 
    ... allowing the frontend to be entirely generic
    """
    srcs     = property( lambda self:AdLidSource( DCS(self['source']) ))
    averager = property( lambda self:AdLidAverager(self.srcs, self.target, self ))
    faker    = property( lambda self:AdLidFaker(self.srcs,self ))


class AdPhysLogical(dict):
    """
    Placeholder dict until physical to logical via DB lookup is worked out 
    """
    def __call__(self, physad ):
        assert physad in self 
        return self[physad] 
 

class AdLidSource(list):
    """
    A list of SQLAlchemy dynamic classes 
    """
    def __init__(self, srcdb ):
        """Coordinates of source table/joins"""

        apl = AdPhysLogical(             ## place holder for testing, accurate as of Nov 30, 2011. 
                  AD1=("kDayaBay","kAD1"), 
                  AD2=("kDayaBay","kAD2"), 
                  AD3=("kLingAo" ,"kAD1"), 
                  AD4=("kFar"    ,"kAD1"), 
                  AD5=("kFar"    ,"kAD2"), 
                  AD6=("kFar"    ,"kAD3"), 
                  AD7=("kSAB"    ,"kAD1"), 
                  AD8=("kSAB"    ,"kAD2"), 
             )

        physads =  ("AD1","AD2","AD3","AD4","AD5","AD6","AD7","AD8",)
        #physads =  ("AD1",)
        for physad in physads:
            ksite, ksubsite = apl( physad )
            dtn = SourceContext(table="%s_LidSensor" % physad , ksite=ksite , ksubsite=ksubsite ) 
            self.append( srcdb.kls(dtn) )


class AdLidAverager(Averager):
    """
    Specialization of generic averager for AD Lid Sensor tables
    """
    def changed(self, sv  ):
        return False   

    def propagate(self, sv ):
        """
        yields one or more target dicts ready for writing to target DB

        NB Averager performs group_by queries within time bins 
        that can yield no results 

        """
        aggl=sv[-1].aggd
        assert type(aggl) == list , "expect list when using aggregate_group_by %r " % aggl
        if len(aggl) == 0:
            log.debug("empty query tcursor %s " % repr(sv.tcursor) ) 
        for aggd in aggl:
            if aggd['NSamples']==0:
                log.warn("AdLidAverager NSamples zero, yielding dummy ")
                yield self._dummy_dict()
            else:    
                yield aggd

    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

        """
        kls = self.target.kls               ## the genDbi target  class
        keys = kls.SpecKeys().aslist()
        return dict(zip(keys,map(lambda _:0, keys)))    ## state dict with all values 0
    
    def _dummy_dict(self, v=-1):
        """
        target dict with all values `v`
        """
        kls = self.target.kls             
        keys = kls.SpecKeys().aslist()
        return dict(zip(keys,map(lambda _:v, keys))) 
 

class AdLidFaker(Faker):
    def fake(self, inst, id , dt=None ):
        """
        Invoked from base class, sets source instance attributes to form a fake 

        :param inst: source instance
        :param id: id to assign to the instance 

        Note that **not** setting the `id` attribute allows AUTOINCREMENT to kick in and
        can avoid SQLAlchemy IntegrityError from duplicate keys. 

        """
        if dt==None:
            dt = datetime.now()
        for k,v in inst.asdict.items():
            if k == 'id':
                pass  
                #setattr( inst, k, id )   
            elif k == 'date_time':
                setattr( inst, k, dt )
            else:
                if k.startswith('Ultrasonic'):
                    setattr( inst, k, random.gauss(2000, 5) )
                elif k.startswith('Capacitance'):
                    setattr( inst, k, random.gauss(200, 10) )
                elif k.startswith('Temp_'):
                    setattr( inst, k, random.gauss(22.7, 0.1) )
                elif k.startswith('Tilt'):
                    setattr( inst, k, random.gauss(0, 0.1) )
                else:
                    setattr( inst, k, 0 );   


if __name__ == '__main__':
    pass

    from base.parser import Parser
    cfg = Parser.config("adlid_averager")
    reg = cfg.regcls
    irg = reg(cfg)
    print irg.srcs    
    assert len(irg.srcs) > 0, "no source classes "