In This Package:

mapper.py

Go to the documentation of this file.

class Mapper(dict):
    """
    Establish the mapping between sets of fields (such as csv fields) and dbi attributes, usage::
 
        ckf = ['status', '_srcline', 'afterPulse', 'sigmaSpe', 'pmtID', 'efficiency', 'darkRate', '_hasblank', 'prePulse', 'speLow', 'timeOffset', 'timeSpread', 'speHigh', 'description']
        mpr = Mapper( GCalibPmtSpec, ckf , afterPulse="AfterPulseProb", sigmaSpe="SigmaSpeHigh", prePulse="PrePulseProb", description="Describ" )
        print mpr

    If a mapping cannot be made, an exception is thrown that reports the partial mapping constructed.

    The automapping performed is dumb by design, only case insensitively identical names are
    auto mapped. Other differences between csv field names and dbi attributes must be manually provided
    in the keyword arguments.

    The string codetype from the spec is promoted into the corresponding python type, to enable
    conversion of the csv dict (comprised of all strings) into a dbi dict with appropriate types
    for the values.   

    """
    def __init__(self, cls, csv_fields, **kwargs ):
        self.cls = cls

        self.csv_fields = filter(lambda _:not _.startswith("_"), csv_fields)       ## remove names beginning "_" 
        self.dbi_attrs = map(str, cls.SpecKeys().aslist() )   ## avoid the TObjString   
        
        self.automap()
        self.update(kwargs)

        self.dbi2csv = dict([(kdbi,kcsv) for kcsv,kdbi in self.items() ])   ## reverse mapping
        
        sk = cls.SpecKeys().aslist()
        sm = cls.SpecMap().asdod()

        if not self.is_valid():
            raise Exception("insufficient info to contruct mapper, partial mapping: %r ",self)

        def cast( typ ):
           if typ == "int":
               return int
           elif typ == "float" or typ == "double":
               return float
           else:
               return str

        self.csv2type = dict([(self.dbi2csv[k],cast(sm[k]['codetype'])) for k in sk ])
 
    def is_valid(self):
        return len(self.miss) == 0 

    def smry(self):
        print repr(self)
        print self

    def automap(self):
        """
        Basic auto mapping, using case insensitive comparison 
        and yielding case sensitive mapping from csv fields to dbi attributes

        The index of the csv fieldname in the dbi attribute list is 
        found with case insensitive string comparison 

        """
        allcaps = lambda _:_.upper()
        for ck in self.csv_fields:
           try:
               idx = map(allcaps, self.dbi_attrs).index( allcaps(ck) )
           except ValueError:
               idx = -1
           if idx > -1: 
               self[ck] = self.dbi_attrs[idx]     
           else:
               self[ck] = None

    miss = property(lambda self:filter( lambda _:self[_]==None, self ))

    def convert_csv2dbi(self, dcsv):
        """
        Translate dict with csv fieldnames into dict with dbi attr names
        and appropiate types for insertion into the DBI Row cls instance 
        """
        return dict([(self[k], self.csv2type[k](dcsv[k]) ) for k in filter( lambda _:not _.startswith("_"), dcsv) ])

    def __call__(self, dcsv):
        return self.convert_csv2dbi(dcsv)

    def __str__(self):
         return "\n".join( ["  csv fields\n   %r " % self.csv_fields , 
                            "    dbi atts\n   %r " % self.dbi_attrs  , 
                            "     csv2dbi\n   %r " % self  ,
                            "     missing\n   %r " % self.miss ])

    def __repr__(self):
         return ",".join(["%s=%s " % (k,v) for k,v in self.items()])



if __name__ == '__main__':
    pass

---