In This Package:

wrap.py

Go to the documentation of this file.

import pprint, types

def RPT__del__(self):
    self.Delete()

def RPT__getitem__( self, i ):
    l = self.__len__()
    if isinstance( i , types.SliceType ):
        start, stop, step = i.start or 0, i.stop or l , i.step or 1
        if start < 0 and start >= -l:
            start += l
        if stop < 0 and stop >= -l:
            stop += l
        return [self.__getitem__(ii) for ii in range(start, stop, step )]
    elif isinstance( i , int ):
        if not(-l <= i < l):
            raise IndexError("out of range for index %d" % i )  
        if i < 0:
            i += l  
        return self.GetRow(i)
    else:
        raise TypeError("indexing expects a slice or integer ")

def RPT(cls):
    """
    Application of function RPT to DbiRpt<T> classes 
    provides instances of that class with a list-like 
    interface supporting access by index and slice,
    indices can be negative to provide access to the end.::
                
     
          r[0]      first
          r[-1]     last
                    
          r[0:9]    first 10  
          r[-3:]    last 3   


          r[0:2000:500]  
          r[-10:-1:2]    2-step thru the last 10 

          for x in r[2540:]:
              print x

          for x in r[-10:]:
              print x 

    THOUGHTS :
    * no need for generator implementation for large result set as already all in memory anyhow

    """
    cls.__len__ = cls.GetNumRows
    cls.__getitem__ = RPT__getitem__
    cls.__del__ = RPT__del__
    cls.__skip__ = "Row RowByIndex".split()
    cls.vrec = property( cls.GetValidityRec )
 



def _create(cls, *args, **kwargs):
    """
    Provide pythonic instance creation classmethod::

        i = GCalibPmtSpec.Create( DarkRate=100. , ... ) 

    doc from func
    """
    instance = cls(*args)
    for k,v in kwargs.items():
        Set = getattr(cls,'Set%s'%k, None)
        if Set:
            Set( instance, v )   
        else:
            raise Exception("no such attribute %s", v )    
    return instance


class Wrap(object):
    """
    Control center for application of generic class manipulations based on the names of 
    methods in contained kls. The manipulations do not require the classes to be imported into this scope.

    Wrapping is applied to:

    * all `genDbi` generated `DbiTableRow` subclasses and corresponding templated `DbiRpt` and `DbiWrt` (readers and writers)
    * a selection of other Dbi classes that are useful interactively 


    """
    def wrap(cls, kls, attfn={}):
        w = Wrap(kls,attfn)
        return w()
    wrap = classmethod(wrap) 

    def __init__(self, kls, attfn={} ):
        self.kls = kls
        self.attfn = attfn
    
    getters = property( lambda self:[g[3:] for g in dir(self.kls) if g.startswith('Get') and len(g)>3 ] )
    setters = property( lambda self:[s[3:] for s in dir(self.kls) if s.startswith('Set') and len(s)>3 ] )
    getset = property( lambda self:list(set(self.getters).intersection(set(self.setters))))
    onlyget = property( lambda self:list(set(self.getters).difference(set(self.setters))))
    skips = property( lambda self:getattr( self.kls, '__skip__',() ))
    isrpt = property( lambda self:self.kls.__name__.startswith("DbiRpt") )
    isdtr = property( lambda self:self.kls.__name__.startswith("G") )

    def get_attfn( self, m ):
        """Returns function than when applied to an object returns (m,obj.Get<m>() ) where m is the attribute name  """
        return self.attfn.get(m, lambda obj:(m,getattr(obj,'Get%s'%m)()) )
    attrs = property( lambda self:[g for g in self.getters if g not in self.skips]) 
    attfs = property(lambda self:map(lambda m:self.get_attfn(m),self.attrs))      ## list of lambda funcs that return (name,val) pairs when applied

  
    def __call__(self):
        self.define_properties()
        self.define__repr__()
        self.define_listlike()
        if self.isdtr:
            self.define_create()
            self.define_asdict()
            self.define_update()
            self.define_keys()
            self.define_csv()
        return self 

    def define_listlike( self):
        if self.isrpt:
            RPT(self.kls)           
    define_listlike.__doc__ = RPT.__doc__

    def define_properties( self ):
        """
        Define properties corresponding to Get* and Set* methods 
        in the contained kls, providing attribute style access and setting ::

                 g = i.x
                 i.x = s
   
        NB "getters" which take arguments GetWithArg(Int_t naughty) have to be skipped via::

                 cls.__skip__ = ("WithArg",)

        """
        for m in filter(lambda m:m not in self.skips,self.getset):
            setattr( self.kls, m.lower() , property( getattr(self.kls, 'Get%s' % m ), getattr( self.kls, 'Set%s' % m ) ) ) 
        for m in filter(lambda m:m not in self.skips,self.onlyget):
            setattr( self.kls, m.lower() , property( getattr(self.kls, 'Get%s' % m )  ) ) 
 
    def make__repr__(self):
        """
        Provide a default `__repr__` function that presents the attribute names and values as a dict 
        """
        def __repr__(iself):
            return "\n".join([ iself.__class__.__name__, "%s" % pprint.pformat( dict( [attf(iself) for attf in self.attfs ]) , indent=4) ])
        return __repr__

    def define__repr__( self ): 
        """
        Assign default repr ... override later if desired 
        """
        if hasattr(self.kls,'AsString'):
            self.kls.__repr__ = getattr(self.kls, 'AsString')
        else:
            self.kls.__repr__ = self.make__repr__()  
 
    def define_create( self):
        self.kls.Create = classmethod(_create)
    define_create.__doc__ = _create.__doc__

    def define_update( self):
        """
        Provide dict like updating for DbiTableRow subclasses, eg::

              from DybDbi import GCalibPmtSpec
              r = GCalibPmtSpec.Rpt()
              z = r[0]
              print z.asdict        
              print z.keys             
              z.update( Status=10 ) 

        """
        def _update(iself, **kwargs):
            for k,v in kwargs.items():
                Set = getattr(self.kls,'Set%s'%k, None)
                if Set:
                    Set( iself, v )   
                else:
                    raise AttributeError("no such attribute %s" % k )    
        self.kls.update = _update

    def define_keys( self):
        def _keys(iself):
            return filter(lambda m:m not in self.skips,self.getset)
        setattr( self.kls, 'keys' , property( _keys ) )

    def define_asdict( self):
        def _asdict(iself):
            d = {}
            for m in filter(lambda m:m not in self.skips,self.getset):
                d[m] = getattr( self.kls, 'Get%s' % m )(iself)                 
            return d
        setattr( self.kls, 'asdict' , property( _asdict ) )


    def define_csv(self):
        """
        Provide csv manipulations as classmethods on the Row classes
        """
        import csv_tools 
        self.kls.csv_check = classmethod( csv_tools.csv_check )
        self.kls.csv_import = classmethod( csv_tools.csv_import )
        self.kls.csv_export = classmethod( csv_tools.csv_export )
        self.kls.csv_compare = classmethod( csv_tools.csv_compare )



if __name__=='__main__':
     from dummy import Dummy
     wd = Wrap(Dummy)()

     d = Dummy()
     print d.state()
     print d
     d.a = "hello a set via property "
     d.b = "hello b set via property "
     print d 

---