/search.css" rel="stylesheet" type="text/css"/> /search.js">
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

Public Member Functions | Public Attributes | Properties | Private Member Functions
DybPython::tab::Tab Class Reference

List of all members.

Public Member Functions

def __init__
def q
def column
def vdistinct
def fields
def qminmaxavg
def mma
def dropzero
def vld
def vpayloadless
def vorder
def vctxsql
def vctx
def dbictx_directive
def vlast
def vtimes
def vseqnos
def actual_ctxs
def looped_ctxs
def save
def tscan
def vscan
def fullscan

Public Attributes

 name
 db

Properties

 exists = property(lambda self:self.db.has_table(self.name), doc="True if DBI payload table exists")
 path = property(lambda self:"%s.txt" % self.name)
 kls = property( _kls )

Private Member Functions

def _qminmaxavg
def _kls

Detailed Description

Marriage of raw DB access via MySQL-python and DybDbi access 

Definition at line 95 of file tab.py.


Constructor & Destructor Documentation

def DybPython::tab::Tab::__init__ (   self,
  name,
  db 
)
:param name: name of DBI payload table
:param db:  :py:class:`DybPython.DB` instance

Definition at line 99 of file tab.py.

00100                                   :
00101         """
00102         :param name: name of DBI payload table
00103         :param db:  :py:class:`DybPython.DB` instance
00104         """
00105         self.name = name
        self.db   = db

Member Function Documentation

def DybPython::tab::Tab::q (   self,
  sql 
)

Definition at line 106 of file tab.py.

00107                     :
        return self.db( sql % {'tab':self.name} )
def DybPython::tab::Tab::column (   self,
  n,
  sql 
)

Definition at line 108 of file tab.py.

00109                             :
        return [d[n] for d in self.db( sql % {'tab':self.name} )]
def DybPython::tab::Tab::vdistinct (   self,
  n 
)

Definition at line 110 of file tab.py.

00111                            :
00112         return self.column(n, "select distinct("+n+") from %(tab)sVld")

def DybPython::tab::Tab::fields (   self,
  skips = [] 
)
Return list of fields in the this table, excluding the skipped fields.

Definition at line 113 of file tab.py.

00114                               :
00115         """
00116         Return list of fields in the this table, excluding the skipped fields.
00117         """ 
00118         return [_['Field'] for _ in self.db("describe %s" % self.name  ) if _['Field'] not in skips ]

def DybPython::tab::Tab::_qminmaxavg (   self,
  skips = ('SEQNO',,
  group_by = 'SEQNO' 
) [private]
Return SQL query string that provides min, max and avg values of each field within `group_by` groups 

Definition at line 119 of file tab.py.

00120                                                               :
00121         """
00122         Return SQL query string that provides min, max and avg values of each field within `group_by` groups 
00123         """
00124         fields = self.fields(skips=skips) 
00125         mma = lambda f:"min(%(f)s) as mi%(f)s, max(%(f)s) as mx%(f)s, avg(%(f)s) as av%(f)s" % dict(f=f)
00126         sel = ",".join(map(mma,fields))
00127         return "select %(group_by)s,%(sel)s from %(tab)s group by %(group_by)s" % dict(tab=self.name, group_by=group_by, sel=sel)

def DybPython::tab::Tab::qminmaxavg (   self)

Definition at line 128 of file tab.py.

00129                          :
00130         return self.db( self._qminmaxavg() )

def DybPython::tab::Tab::mma (   self)
Return a string rst table showing min/max/avg values grouped by SEQNO.
When the docs virtual python is used, a valid rst table is returned otherwise
a pale imitation table is provided.

Note that min/max/avg are consolidated into a single cell to avoid overlarge tables

Definition at line 131 of file tab.py.

00132                  :
00133         """
00134         Return a string rst table showing min/max/avg values grouped by SEQNO.
00135         When the docs virtual python is used, a valid rst table is returned otherwise
00136         a pale imitation table is provided.
00137 
00138         Note that min/max/avg are consolidated into a single cell to avoid overlarge tables
00139         """
00140         flds = self.fields(skips=('SEQNO',))
00141         from DybPython.vlut import TabularData
00142         td = TabularData()
00143         for e in self.qminmaxavg():
00144             d = dict(SEQNO=e['SEQNO'])
00145             for f in flds:
00146                 d[f] = "%s %s %s" % ( e['mi'+f], e['mx'+f], e['av'+f ] )
00147             td.append(d)
00148         return td.as_rst( ['SEQNO'] + flds )
00149 

def DybPython::tab::Tab::dropzero (   self)
DROPs the DBI payload and validity tables and sets the LASTUSEDSEQNO in LOCALSEQNO table to zero.
Only works when the DBCONF section name and actual database name starts with 'tmp_' 

Definition at line 150 of file tab.py.

00151                       :
00152         """
00153         DROPs the DBI payload and validity tables and sets the LASTUSEDSEQNO in LOCALSEQNO table to zero.
00154         Only works when the DBCONF section name and actual database name starts with 'tmp_' 
00155         """
00156         tab = self.name
00157         dbname = self.db.dbc['database']
00158         if dbname.startswith('tmp_') and self.db.sect.startswith('tmp_'):
00159             log.info("dropping DBI table pair for %(tab)s and zeroing LOCALSEQNO.LASTUSEDSEQNO "  % locals() ) 
00160             self.db("drop table if exists %(tab)s, %(tab)sVld" % locals() )
00161             self.db("update LOCALSEQNO set LASTUSEDSEQNO=0 where TABLENAME='%(tab)s'" % locals() )
00162         else:
00163             raise Exception("dropzero only permitted when DBCONF section name and actual database name starts with tmp_ %(tab)s" % locals() ) 

def DybPython::tab::Tab::vld (   self,
  seqnos 
)

Definition at line 164 of file tab.py.

00165                           :
00166         seqs = "(%s)" % seqnos[0] if len(seqnos)==1 else str(tuple(seqnos))
00167         return self.q("select * from %(tab)sVld where SEQNO in " + seqs ) 

def DybPython::tab::Tab::vpayloadless (   self)
Return validity entries with no corresponding payload

There are legitimate reasons to go payloadless, however it is also a likely outcome of
some error conditions when writing to the DB.

Definition at line 168 of file tab.py.

00169                           :
00170         """
00171         Return validity entries with no corresponding payload
00172 
00173         There are legitimate reasons to go payloadless, however it is also a likely outcome of
00174         some error conditions when writing to the DB.
00175         """
00176         tab = self.name
00177         return self.q("select * from  %(tab)sVld where SEQNO not in (select distinct(SEQNO) from %(tab)s) order by SEQNO " % locals() )

def DybPython::tab::Tab::vorder (   self)

Definition at line 178 of file tab.py.

00179                     :
00180          return 'SEQNO TIMESTART TIMEEND SITEMASK SIMMASK SUBSITE TASK AGGREGATENO VERSIONDATE INSERTDATE'.split()

def DybPython::tab::Tab::vctxsql (   self,
  ctx 
)
Provide context SQL query excluding time requirement for interactive mysql querying.  Usage::

     tab = db.tab('Demo')
     actx = tab.actual_ctxs()
     sql = tab.vctxsql(actx[0])
> 'select * from DemoVld where SiteMask & 127 and SimMask & 1 and  Task = 0 and SubSite = 0 order by VERSIONDATE desc'

Definition at line 181 of file tab.py.

00182                           :
00183          """
00184          Provide context SQL query excluding time requirement for interactive mysql querying.  Usage::
00185 
00186               tab = db.tab('Demo')
00187               actx = tab.actual_ctxs()
00188               sql = tab.vctxsql(actx[0])
00189                   > 'select * from DemoVld where SiteMask & 127 and SimMask & 1 and  Task = 0 and SubSite = 0 order by VERSIONDATE desc'
00190 
00191          """
00192          d = dict(tab=self.name)
00193          d.update(ctx)
00194          return "select * from %(tab)sVld where SiteMask & %(site)s and SimMask & %(simflag)s and  Task = %(task)s and SubSite = %(subsite)s order by VERSIONDATE desc" % d 

def DybPython::tab::Tab::vctx (   self,
  ctx 
)

Definition at line 195 of file tab.py.

00196                        :
00197         return self.db( self.vctxsql( ctx)) 

def DybPython::tab::Tab::dbictx_directive (   self,
  ctx 
)
Provides rst source like::

  select * from Demo ... 
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  .. dbictx:: tmp_offline_db Demo
       :site:
       :simflag:
       :task:
       :subsite:

Which directs Sphinx to perform a faux-DBI context query when the documentation is built and present the result
as a table within the docs.

Definition at line 198 of file tab.py.

00199                                     :
00200         """
00201         Provides rst source like::
00202 
00203           select * from Demo ... 
00204           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
00205 
00206           .. dbictx:: tmp_offline_db Demo
00207                :site:
00208                :simflag:
00209                :task:
00210                :subsite:
00211 
00212         Which directs Sphinx to perform a faux-DBI context query when the documentation is built and present the result
00213         as a table within the docs.
00214 
00215         """
00216         vl += rst_title(str(self.vctxsql(ctx)))
00217         vl += '.. dbictx:: %(dbconf)s %(tn)s\n   :site: %(site)s\n   :simflag: %(simflag)s\n   :task: %(task)s\n   :subsite: %(subsite)s\n' % dict(ctx, dbconf=self.db.sect ,tn=self.name)
00218         return vl

def DybPython::tab::Tab::vlast (   self,
  n,
  orderlimit = "order by SEQNO desc limit 1" 
)
:param n: name of row in validity table, eg `INSERTDATE`
:param orderlimit: SQL ordering and limit clause 

Definition at line 219 of file tab.py.

00220                                                                   :
00221         """
00222         :param n: name of row in validity table, eg `INSERTDATE`
00223         :param orderlimit: SQL ordering and limit clause 
00224         """
00225         vals = self.column(n, "select `"+n+"` from %(tab)sVld " + orderlimit )
00226         return vals[0] if len(vals) == 1 else None

def DybPython::tab::Tab::vtimes (   self)

Definition at line 227 of file tab.py.

00228                     :
00229         return sorted(list(set( self.vdistinct("TIMESTART") + self.vdistinct("TIMEEND") )))

def DybPython::tab::Tab::vseqnos (   self,
  seqnos,
  kwa 
)
Returns string presentation of a list of SEQNO in a DBI validity table

:param seqnos:  one or more SEQNO 

Usage::

In [6]: p tab.vseqnos(10,1)
+-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+
| SEQNO | TIMESTART           | TIMEEND             | SITEMASK | SIMMASK | SUBSITE | TASK | AGGREGATENO | VERSIONDATE         | INSERTDATE          |
+-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+
|     1 | 2010-01-01 01:00:00 | 2038-01-19 03:14:07 |      127 |       1 |       0 |    0 |          -1 | 2010-01-01 01:00:00 | 2011-08-22 12:14:21 | 
|    10 | 2010-01-01 04:00:00 | 2038-01-19 03:14:07 |      127 |       1 |       0 |    0 |          -1 | 2010-01-01 04:02:00 | 2011-08-22 12:14:30 | 
+-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+

Definition at line 230 of file tab.py.

00231                                      :
00232         """
00233         Returns string presentation of a list of SEQNO in a DBI validity table
00234 
00235         :param seqnos:  one or more SEQNO 
00236 
00237         Usage::
00238 
00239                 In [6]: p tab.vseqnos(10,1)
00240                 +-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+
00241                 | SEQNO | TIMESTART           | TIMEEND             | SITEMASK | SIMMASK | SUBSITE | TASK | AGGREGATENO | VERSIONDATE         | INSERTDATE          |
00242                 +-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+
00243                 |     1 | 2010-01-01 01:00:00 | 2038-01-19 03:14:07 |      127 |       1 |       0 |    0 |          -1 | 2010-01-01 01:00:00 | 2011-08-22 12:14:21 | 
00244                 |    10 | 2010-01-01 04:00:00 | 2038-01-19 03:14:07 |      127 |       1 |       0 |    0 |          -1 | 2010-01-01 04:02:00 | 2011-08-22 12:14:30 | 
00245                 +-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+
00246 
00247         """
00248         raw = kwa.pop('raw',False)
00249         if raw:
00250             seqtuple = "(%s)" % seqnos[0] if len(seqnos)==1 else str(tuple(seqnos))
00251             return self.db.mysql("select * from %(tab)sVld where SEQNO in %(seqtuple)s" % {'tab':self.name,'seqtuple':seqtuple} , opts="-t" )
00252         else:
00253             return self.vld(*seqnos)      
00254 
00255 

def DybPython::tab::Tab::actual_ctxs (   self)
Provide list of distinct context dicts actually present in the Vld table,
ordered by the string representation.

Masks and specials kAnyTask = -1, kAnySubSite = -1 are not yet handled differently 

:return: list of dicts such as ``dict(site=127,simflag=1,subsite=1,task=0, aggno=-1)`` covering all contexts in  Vld table

Definition at line 256 of file tab.py.

00257                          :
00258         """
00259         Provide list of distinct context dicts actually present in the Vld table,
00260         ordered by the string representation.
00261 
00262         Masks and specials kAnyTask = -1, kAnySubSite = -1 are not yet handled differently 
00263         
00264         :return: list of dicts such as ``dict(site=127,simflag=1,subsite=1,task=0, aggno=-1)`` covering all contexts in  Vld table
00265 
00266         """
00267         actual = []
00268         for e in self.q("select * from %(tab)sVld"):
00269             ctx = ctxdict(task=int(e['TASK']),simflag=int(e['SIMMASK']),site=int(e['SITEMASK']),subsite=int(e['SUBSITE']),aggno=int(e['AGGREGATENO']))
00270             actual.append(ctx)
00271         return sorted(list(set(actual)),cmp=lambda a,b:cmp(str(a),str(b)))   

def DybPython::tab::Tab::looped_ctxs (   self)
Looped context dicts based on distinct values of the components.

:return: list of dicts such as ``dict(site=127,simflag=1,subsite=1,task=0, aggno=-1)`` covering all relevant contexts suggested by Vld table

::
+-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+
| SEQNO | TIMESTART           | TIMEEND             | SITEMASK | SIMMASK | SUBSITE | TASK | AGGREGATENO | VERSIONDATE         | INSERTDATE          |
+-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+

Definition at line 272 of file tab.py.

00273                          :
00274         """
00275         Looped context dicts based on distinct values of the components.
00276 
00277         :return: list of dicts such as ``dict(site=127,simflag=1,subsite=1,task=0, aggno=-1)`` covering all relevant contexts suggested by Vld table
00278 
00279         ::
00280                 +-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+
00281                 | SEQNO | TIMESTART           | TIMEEND             | SITEMASK | SIMMASK | SUBSITE | TASK | AGGREGATENO | VERSIONDATE         | INSERTDATE          |
00282                 +-------+---------------------+---------------------+----------+---------+---------+------+-------------+---------------------+---------------------+
00283 
00284         """
00285         sites    = self.vdistinct("SITEMASK")  
00286         simflags = self.vdistinct("SIMMASK")  
00287         subsites = self.vdistinct("SUBSITE")  
00288         tasks    = self.vdistinct("TASK")  
00289         aggnos   = self.vdistinct("AGGREGATENO")  
00290         
00291         l = [] 
00292         for task in map(int,tasks):
00293             for simflag in map(int,simflags):  
00294                 for site in map(int,sites):
00295                     for subsite in map(int,subsites):
00296                         for aggno in map(int,aggnos):
00297                             l.append(ctxdict(task=task,simflag=simflag,site=site,subsite=subsite,aggno=aggno))
00298         return l
00299 

def DybPython::tab::Tab::save (   self,
  smth,
  dir = None 
)
:param smth: some string related to the table to be written

Definition at line 303 of file tab.py.

00304                                    :
00305         """
00306         :param smth: some string related to the table to be written
00307         """
00308         path = os.path.join(dir, self.path) if dir else self.path
00309         f = open( path , "w")
00310         f.write( smth )
00311         f.close()
       
def DybPython::tab::Tab::_kls (   self) [private]

Definition at line 312 of file tab.py.

00313                   :
00314         import DybDbi
        return getattr( DybDbi , 'G' + self.name )  
def DybPython::tab::Tab::tscan (   self,
  times,
  ctx,
  opts 
)
:param times: list of datetimes at which to perform DBI queries 
:param ctx: DybDbi ctx kwargs, excluding `timestamp` 
:param opts: dict of extra options

:return lod: list-of-dicts representing winning SEQNO vs T

Also for each time an extra FindSeqNoWithVersionDate query is done 
in order to explicity show where the ambiguous rot sets in on the VLUT.  
The excludingSeqno is used to avoid finding itself

BUT FindSeqNoWithVersionDate will return 0 if it finds more than 1 ...
maybe need to allow to pass a string


When using the default timeGate the view of collisions seen by FindSeqNoWithVersionDate
should correspond to the standard DBI view 


Definition at line 318 of file tab.py.

00319                                      :
00320         """
00321         :param times: list of datetimes at which to perform DBI queries 
00322         :param ctx: DybDbi ctx kwargs, excluding `timestamp` 
00323         :param opts: dict of extra options
00324 
00325         :return lod: list-of-dicts representing winning SEQNO vs T
00326 
00327         Also for each time an extra FindSeqNoWithVersionDate query is done 
00328         in order to explicity show where the ambiguous rot sets in on the VLUT.  
00329         The excludingSeqno is used to avoid finding itself
00330 
00331         BUT FindSeqNoWithVersionDate will return 0 if it finds more than 1 ...
00332         maybe need to allow to pass a string
00333 
00334 
00335         When using the default timeGate the view of collisions seen by FindSeqNoWithVersionDate
00336         should correspond to the standard DBI view 
00337 
00338 
00339         """
00340         kls = self.kls
00341         tsc = []
00342 
00343         dbno = 0         
00344         uniqueVersionDateSiteMask = 0 
00345         uniqueVersionDateSimMask = 0   ## 0 means use the vrec ones
00346         useTimeGate = 0                ## 0 means NO, 1 use default, >15 use value as non-standard gate 
00347 
00348         ordering = opts.get("ordering",None) 
00349 
00350         for t in times:
00351             ts = t_(t)
00352             log.debug("tscan t %s ts %s ordering %s " % ( t, ts.AsString("s"), ordering ) )
00353             kls.Cache().Purge()
00354 
00355             with DebugValidityOrdering(kls,ordering):
00356 
00357                 r = kls.Rpt().Clone()
00358                 r.ctx( timestamp=ts, **ctx )
00359                 n = len(r)
00360 
00361                 nvr = r.key.numvrecs
00362                 seq = r.key.seqnolist
00363                 dig = r.digest             ## untested with aggregates 
00364 
00365                 log.debug("payload count %s  nvr %s seq %s dig %s  " % (n, nvr,seq,dig ) )
00366                 
00367                 d = dict(t=t,n=n,dig=dig)
00368 
00369                 ##  aggregate Table queries yield r.vrec.seqno all over the shop depending on extra ordering, but it appears not to matter 
00370                 ## ... to allow VLUT comparisons to work for aggregate tables exposed the `key.seqnolist`  
00371                 ##
00372                 if nvr > 1:     ## aggregate query       
00373                     seq = r.key.seqnolist
00374                     d.update( rvs=seq ) 
00375                     ## unclear how to do collision test in aggregate case
00376                 else:
00377                     #assert r.vrec.seqno == r.key.seqnolist, (r.vrec.seqno , r.key.seqnolist )
00378                     rvs = r.vrec.seqno   
00379                     rvs_versiondate = r.vrec.versiondate  
00380                     excludingSeqno = rvs
00381                     count = True
00382                     ncollision = proxy.FindSeqNoWithVersionDate( rvs_versiondate , r.vrec , dbno ,uniqueVersionDateSiteMask, uniqueVersionDateSimMask, excludingSeqno, useTimeGate, count )
00383                     if ncollision==1:
00384                         count = False
00385                         collision = proxy.FindSeqNoWithVersionDate( rvs_versiondate , r.vrec , dbno ,uniqueVersionDateSiteMask, uniqueVersionDateSimMask, excludingSeqno, useTimeGate, count )
00386                     else:
00387                         collision = -1 
00388                     pass
00389                     d.update( rvs=rvs,collision=collision,ncollision=ncollision) 
00390                     pass
00391                 tsc.append( d )
00392 
00393         return tsc 

def DybPython::tab::Tab::vscan (   self,
  digest = False,
  timestart = False 
)
Technical check ``(SEQNO vs SEQNO)`` 
Uses genDbi class for the table to perform DBI query for all SEQNO
:return lod: list-of-dicts 

Formerly was doing ``rvs = r.vrec.seqno if n>0 else 0`` but 
``n=0`` will be OK once orphans are allowed again

Definition at line 394 of file tab.py.

00395                                                   :
00396         """
00397         Technical check ``(SEQNO vs SEQNO)`` 
00398         Uses genDbi class for the table to perform DBI query for all SEQNO
00399         :return lod: list-of-dicts 
00400 
00401         Formerly was doing ``rvs = r.vrec.seqno if n>0 else 0`` but 
00402         ``n=0`` will be OK once orphans are allowed again
00403 
00404         """
00405         kls = self.kls
00406         r = kls.Rpt()
00407         vsc = []
00408         for e in self.db("select * from %(tab)sVld order by SEQNO asc" % {'tab':self.name} ):
00409             ts = t_( e['TIMESTART'] )
00410             r.ctx( timestamp=ts, site=e['SITEMASK'], simflag=e['SIMMASK'], subsite=e['SUBSITE'], task=e['TASK'] )
00411             n = len(r)
00412             rvs = r.vrec.seqno 
00413             d = dict(seqno=e['SEQNO'], rvs=rvs, n=n )
00414             if digest:
00415                 d['digest'] = r.digest 
00416             if timestart:
00417                 d['timestart'] = e['TIMESTART'] 
00418             vsc.append( d )
00419         return vsc
00420 

def DybPython::tab::Tab::fullscan (   self,
  ctx,
  opts 
)
Performs SEQNO vs T scans for full history of a table,
via rollbacks to all distinct INSERTDATES (+1s)        

NB raw DB selects are blind to the rollback 

:param ctx: DybDbi ctx kwargs, excluding `timestamp`       
:param opts: dict with any extra variations

:return dld: INSERTDATE keyed dict-of-list-of-dicts 

Definition at line 421 of file tab.py.

00422                                   :
00423         """
00424         Performs SEQNO vs T scans for full history of a table,
00425         via rollbacks to all distinct INSERTDATES (+1s)        
00426 
00427         NB raw DB selects are blind to the rollback 
00428 
00429         :param ctx: DybDbi ctx kwargs, excluding `timestamp`       
00430         :param opts: dict with any extra variations
00431 
00432         :return dld: INSERTDATE keyed dict-of-list-of-dicts 
00433         """ 
00434         times = self.vtimes()     ## raw DB select is blind to the DBI rollback
00435         times = times[:-1]        ## kludgy exclusion of EOT
00436         fscan = {}
00437 
00438         insertdate_aligned = opts['_aligned'] 
00439         insertdates_ = sorted(self.vdistinct("INSERTDATE")) 
00440         if insertdate_aligned: 
00441             insertdates = zip(insertdates_,insertdates_)
00442         else:
00443             insertdates =  zip(["latest"],[insertdates_[-1]])
00444 
00445         for insertlabel,insertdate in insertdates:
00446             with Rollback(insertdate):
00447                 tsc = self.tscan(times,  ctx, opts )
00448                 log.debug("fullscan %s" % pformat(tsc))
00449                 fscan[insertlabel] = tsc
00450         return fscan    
00451 


Member Data Documentation

Definition at line 102 of file tab.py.

Definition at line 102 of file tab.py.


Property Documentation

DybPython::tab::Tab::exists = property(lambda self:self.db.has_table(self.name), doc="True if DBI payload table exists") [static]

Definition at line 300 of file tab.py.

DybPython::tab::Tab::path = property(lambda self:"%s.txt" % self.name) [static]

Definition at line 302 of file tab.py.

DybPython::tab::Tab::kls = property( _kls ) [static]

Definition at line 315 of file tab.py.


The documentation for this class was generated from the following file:
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

Generated on Fri May 16 2014 09:55:41 for DybPython by doxygen 1.7.4