In This Package:

__init__.py

Go to the documentation of this file.

from ccsv import ccsv_parse
import os

class Tab(list):
    """
        :class:`DybDbiPre.Tab` instances are created by the parsing of :file:`.spec` files (:dybgaudi:`Database/DybDbi/spec`).
        Instances contain a list of dicts corresponding to each payload row in the DBI table together
        with a metadata dictionary for class level information.
           
        To test the parsing of a :file:`.spec` file, use for example::
        
              cat $DYBDBIROOT/spec/GSimPmtSpec.spec | python $DYBDBIPREROOT/python/DybDbiPre/__init__.py
        
        The instances are available in the django context used to fill templates
        :dybgaudi:`Database/DybDbi/templates` used in the generation of:
        
          #. DbiTableRow subclasses allowing DBI to interact with the table
          #. Documentation presenting the DBI tables in :file:`.tex` and wiki formats 
          #. SQL scripts for table creation :file:`.sql` 
        
        The meanings of the quantities in the :file:`.spec` are ultimately determined by their usage
        in the templates, however some guideline definitions are listed below:

        .. rubric:: row level quantities

        name
            column name as used in C++ getter and setter methods
        dbtype
            MySQL column type name used in table description, such as `double` or `int(10) unsigned`
        codetype 
            type used in generated C++ code, eg `DayaBay::FeeChannelId`
        legacy 
            name of the column in database table
        description
            short definition of the meaning of the column      
        code2db
            C++ converter function used to translate a value in code into a value stored in the DB, eg `.fullPackedData()` 
        memb
            name of the column data member in the C++ table row class, **WARNING, CURRENTLY NOT IN USE**         


        .. rubric:: class/table level properties

        meta
            a token that identifies the key, value pairs on the line as metadata rather than a table row 
        table
            name of the payload Database table, eg `CalibFeeSpec`
        class 
            name of the generated DbiTableRow class, follow convention of naming with a **G** prefix eg `GCalibFeeSpec`
        CanL2Cache
            set to `kFALSE`, L2 caching is for debugging only 
        legacy
            name of prior table when migrations are performed, **WARNING, CURRENTLY NOT IN USE**, set to table name             
        rctx
            default read context represented by a comma delimited string, see :dybgaudi:`Database/DybDbi/src/DbiCtx.cxx`  
        wctx
            default write context range represented by a comma delimited string, see :dybgaudi:`Database/DybDbi/src/DbiCtx.cxx` 


        .. rubric:: usage in templates

        The class level and row level quantities are used in django templates with expressions of the form::
             
            {{ t.meta.table }}   

            {% for r in t %}`{{ r.name }}` {{ r.dbtype }} default NULL COMMENT '{{ r.description }}',

  
    """
    def __init__(self):
        self.meta = {}

    def __repr__(self):
        return "\n".join([repr(self.meta),list.__repr__(self)])

    def _extras(self):
        """
        Extras property dict is updated into the context providing handy shortcuts  
        """ 
        verbose = int(os.environ.get('VERBOSE', 0 ))
        debug = verbose > 0
        return dict(cls=self.meta.get('class','ErrorNoClass'),kls=self.meta.get('legacy','ErrorNoLegacy'),f=self.meta.get('prefix','m_'),debug=debug)
    extras = property( _extras , doc=_extras.__doc__ )

    def _docstring(self):
        return self.docs.split("\n")
    docstring = property( _docstring ) 

    def __call__(self, d ):
        """
        If fields in the :file:`.spec` file include a "meta" key then the  
        fieldname(ie key),value pairs are included into the meta dictionary  
        """ 
        if d.has_key('meta'):
            self.meta.update(d)
        else:
            self.append(d)


class Enum(list):
   def __init__(self, *args ):
       list.__init__( self, *args ) 
       self.extras = dict( cls="Ctx", template_object_name="l" ) 

"""
   Parsers provides interface required by FillTmpl 
   ... a callable class that returns list of dicts like object
"""
class Parser:
    def __call__(self, src ):
        t = Tab() 
        p = ccsv_parse( src.read() )
        for d in p:
            t(d)
        t.docs = p.docs if hasattr(p,'docs') else ""
        #print "docs:", t.docs
        #print "docstring:", t.docstring
        return t 

class EnumParser:
    def __call__(self, src ):
        return Enum( map(lambda x:x.strip(), src.readlines() ) )


if __name__=='__main__':
    import sys
    arg = len(sys.argv) > 1 and sys.argv[1] or None

    if arg == "enum":
        print EnumParser()(sys.stdin)
    else:
        print Parser()(sys.stdin)

---