vlut.py

Go to the documentation of this file.

import os, logging
from rst import TabularData, rst_title
from scan import Scan
from datetime import datetime


__all__ = ('Scan', 'Vlut', )
log = logging.getLogger(__name__)


class Vlut(list):
    def special_compare( cls,  avs, bvs , nominalspec=None ): 
        """
        :param avs: `VlutSpec` instance
        :param bvs: `VlutSpec` instance
        :param nominalspec:  a naming `VlutSpec` instance

        Special case comparisons such as cross comparing different dbconf AND
        different option variations. 
        """
        spec = nominalspec if nominalspec else [avs,bvs] 
        asc = Scan.get_or_create( avs )
        bsc = Scan.get_or_create( bvs )

        csc = Scan.compare_( asc , bsc ) 
        cvl = Vlut.create( csc , spec=spec )
        cvl.write()   
        return cvl
    special_compare = classmethod( special_compare ) 

    def get_or_create( cls, vs  ):
        scan = Scan.get_or_create( vs )
        vlut = Vlut.create( scan, spec=vs )
        vlut.write()
        return vlut
    get_or_create = classmethod( get_or_create ) 

    def create( cls , scan , fn=lambda _:_['rvs'], spec=None ): 
        """
        Create validity look up table from a dbiscan  
        """ 

        if not scan:
           log.fatal("undefined scan " ) 
           raise Exception("Vlut.create undefined scan") 

        vlut = cls()
        alltimes = []
        allseqno = []
        ambipairs = []

        def insertdates_only(ik):
            """
            Skip the _stat dict but cannot just pluck datetimes 
            as in disparate comparison case labels are used inplace of insertdates
            """
            if type(ik) == datetime:
                return True
            if ik.startswith('_'):
                return False
            return True

        iks = sorted(filter(insertdates_only,scan.keys()))
        log.debug("Vlut.create %s " % iks )

        # rollback outer loop
        for insertdate in iks: 
            lod = scan[insertdate]                 # list-of-dict with the TIMESTART results
            t   = map(lambda d:d['t'],   lod )
            rvs = map(lambda d:d['rvs'], lod )

            alltimes.extend(t)                     
            allseqno.extend(rvs)
            
            # converts lod into tabular data row dict  
            thead = ["insertdate"] + map(str,t)
            tbody = [ insertdate ] + map(fn,lod )    
            vlut.append(dict(zip(thead,tbody)))
            pass

        alltimes = sorted(list(set(alltimes)))
        vlut.alltimes = alltimes
        vlut.allseqno = sorted(list(set(allseqno))) 
        vlut.order = ["insertdate"] + map(str,alltimes)
        vlut.ambipairs = ambipairs
        vlut.spec = spec
        vlut.scan = scan
        vlut.meta = vlut._meta()
        return vlut
    create = classmethod( create )

    def __init__(self):
        list.__init__(self)

    stat = property(lambda self:self.scan.get('_stat',{}))
    ndif = property(lambda self:self.stat.get('ndif',-1))

    def _meta(self):
        meta = dict()
        meta['insertdates'] = len(self)
        meta['timestarts']  = len(self.order)
        meta['ndif']        = self.ndif
        return meta

    def __str__(self):
       td = TabularData(self)           ## tabulates a list of dicts with each row corresponding to each dict
       return td.as_rst(cols=self.order)   

    def extras(self, _vs=None ):
        if not _vs:_vs = self.spec
        vl = ""
        for pair in self.ambipairs:
            vl += rst_title(str(pair))
            vl += ".. dbivld:: %s %s %s\n\n" % ( _vs.dbconf , _vs['tn'] , ",".join(map(str,pair)) )
        vl += rst_title(str(self.allseqno))  
        vl += ".. dbivld:: %s %s %s\n\n" % ( _vs.dbconf , _vs['tn'], ",".join(map(str,self.allseqno)) )
        return vl

    def write(self, _vs=None):
        if not _vs:
            _vs = self.spec
        vs = _vs.copy(category='vlut')
        titl = vs.title_()
        mtitl = " ".join("%s:%s" % kv for kv in filter(lambda kv:not kv[0].startswith("_"),self.meta.items()) )
        titl += " ``%s``" % mtitl
        path = vs.path 
        if os.path.exists(path) and not vs.force: 
            log.debug("skip prexisting %s " % path )
        else:
            log.info("writing %s " % path )
            with open(path,"w") as fp:
                fp.write(rst_title(titl))  
                fp.write(str(self))
                if not vs.plain:  
                    fp.write(self.extras(vs))
        return path


if __name__ == '__main__':
    pass    
    logging.basicConfig(level=logging.INFO)
    from vlutspec import VlutSpec
    vs = VlutSpec( dbconf="tmp_offline_db".split() , tn="HardwareID" , ctx=dict(aggno=-1, simflag=2, site=1, subsite=2, task=0 ), opts=dict(_rescan=True,_force=True) )
    vlut = vs.make_vlut()
    log.info("vlut..\n%s\n" % vlut  )