python.pydraw.Draw_Cmd Class Reference

Inheritance diagram for python.pydraw.Draw_Cmd:

Collaboration diagram for python.pydraw.Draw_Cmd:

Public Member Functions
	__init__ (self, s)

Public Attributes
str	errstr = None
	excstr = traceback.format_exc()
list	histspec
	tuple_o = eval (self.tuple, _globals)
list	stmts = _split_outer (s, '@')
	expr_orig
	sel_orig
	sel = self._mung_expr (self.sel_orig)
list	exprs
	tuple = tuple
	lo = lo
	hi = hi

Protected Member Functions
	_tupleparse (self, s)
	_parserange (self, tuple)
	_mung_id (self, id)
	_mung_index (self, s1, s2)
	_mung_n (self, s1, s2)
	_mung_loop (self, s1, s2)
	_mung_expr_dollar (self, s)
	_mung_expr_ids (self, s)
	_mung_expr (self, s)
	_make_func (self, payload, extargs='')

Protected Attributes
dict	_iddict = {}
dict	_limdict = {}
dict	_loopdict = {}

Detailed Description

Holds information used to implement a draw/scan/loop command.

Pass the draw string to the constructor.  See the file-level comments
for details on the syntax of this.  This will define the
following attributes:

  errstr -   If set to a string, there was an error.
             Should be None if everything's ok.
  tuple -    The name of the tuple object.
  tuple_o -  Tuple object.
  lo -       The lower bound for row iteration.
  hi -       The upper bound for row iteration.
  stmts -    List of additional statements.
  exprs -    List of draw expressions.
  sel -      Selection expression or None.
  sel_orig - Untransformed selection expression or None.
  expr_orig- Untransformed plotting expression.
  histspec - The text following `;', split into space-separated words.

Other attributes:
  _iddict -  Map from loop identifiers (`foo' in `foo$i')
             to temp variables used to reference
             them in the loop function.
  _limdict - Map from loop identifiers (`foo' in `foo$2')
             to the largest explicit index seen.
  _loopdict - Map of loop dummy variable names to _Loopvar instances.

Definition at line 604 of file pydraw.py.

Constructor & Destructor Documentation

__init__()

python.pydraw.Draw_Cmd.__init__	(		self,
			s )

Initialize from a draw string.  See above for more details.

Definition at line 633 of file pydraw.py.

    def __init__ (self, s):
        """Initialize from a draw string.  See above for more details."""
 
        # Assume no error.
        self.errstr = None
 
        self._iddict = {}
        self._limdict = {}
        self._loopdict = {}
 
        try:
            self._tupleparse (s)
        except Exception as e:
            import traceback
            self.errstr = str(e)
            self.excstr = traceback.format_exc()
        return
 
 
 

Member Function Documentation

_make_func()

python.pydraw.Draw_Cmd._make_func ( self, payload, extargs = '' )

protected

Create the text for the function to process this query.

PAYLOAD is the payload expression to plug in.
EXTARGS is an additional string to add to the end of the
function's argument list (to set default values, for example).
Returns the function definition as a string.

Definition at line 934 of file pydraw.py.

    def _make_func (self, payload, extargs = ''):
        """Create the text for the function to process this query.
 
        PAYLOAD is the payload expression to plug in.
        EXTARGS is an additional string to add to the end of the
        function's argument list (to set default values, for example).
        Returns the function definition as a string.
        """
 
        sel = self.sel
        if self._limdict:
            limsel = ' and '.join (["len(%s)>=%d" % (self._iddict[p[0]], p[1])
                                    for p in self._limdict.items()])
            if not sel:
                sel = limsel
            else:
                sel = limsel + " and (" + sel + ")"
 
        ftext = "def _loopfunc(_i, %s%s):\n" % (_evtvar, extargs)
        for (id1, id2) in sorted(self._iddict.items()):
            ftext += "  %s = %s.%s\n" % (id2, _evtvar, id1)
        indent = 2
 
        for (i,l) in sorted(self._loopdict.items()):
            ids = sorted(l.get_ids())
            assert (not not ids)
            if len(ids) == 1:
                vars = l.itname (ids[0])
                lists = self._iddict[ids[0]]
            else:
                vars = "(" + ','.join([l.itname (id) for id in ids]) + ")"
                lists = ("zip(" + ','.join([self._iddict[id] for id in ids])
                         + ")")
            if l.explicit:
                vars = "(%s,%s)" % (l.dumname(), vars)
                lists = "enumerate(%s)" % lists
            ftext += ' '*indent + "for %s in %s:\n" % (vars, lists)
            indent += 2
 
        for s in self.stmts:
            ftext += ' '*indent + s + '\n'
 
        if sel and sel != '1':
            ftext += ' '*indent + "if (%s):\n" % sel
            indent += 2
 
        ftext += ' '*indent + "%s\n" % payload
 
        if _debug:
            print (ftext)
        
        return ftext
 
 

_mung_expr()

python.pydraw.Draw_Cmd._mung_expr ( self, s )

protected

Process $ constructions and id substitution in string S.

Returns the modified string.

Definition at line 925 of file pydraw.py.

    def _mung_expr (self, s):
        """Process $ constructions and id substitution in string S.
 
        Returns the modified string.
        """
        s = self._mung_expr_dollar (s)
        return self._mung_expr_ids (s)
 
    

_mung_expr_dollar()

python.pydraw.Draw_Cmd._mung_expr_dollar ( self, s )

protected

Process $ constructions in string S.

Returns the modified string.

Definition at line 863 of file pydraw.py.

    def _mung_expr_dollar (self, s):
        """Process $ constructions in string S.
 
        Returns the modified string.
        """
        if not s:
            return s
        pos = 0
        while 1:
            (s1, s2) = _find_outer (s[pos:], '$', True)
            if s2 is None:
                break
            snew = None
            if len(s2) > 0:
                if s2[0] in string.digits:
                    snew = self._mung_index (s1, s2)
                elif (s2[0] == 'n' and
                      (not (len(s1) > 0 and s1[-1] in _idchars) or
                       s1.endswith (' and') or
                       s1.endswith (' or') or
                       s1.endswith ('not'))):
                    snew = self._mung_n (s1, s2)
                elif s2[0] in string.ascii_letters:
                    snew = self._mung_loop (s1, s2)
            s = s[:pos]
            if snew is None:
                snew = s1 + '$' + s2
                pos = pos + len(s1)+1
            s = s + snew
        return s
 
 

_mung_expr_ids()

python.pydraw.Draw_Cmd._mung_expr_ids ( self, s )

protected

Perform id substitution in S.

For identifiers in S that are attributes of our tuple,
replace them with references to the tuple attribute
(using _mung_id).

Returns the modified string.

Definition at line 895 of file pydraw.py.

    def _mung_expr_ids (self, s):
        """Perform id substitution in S.
 
        For identifiers in S that are attributes of our tuple,
        replace them with references to the tuple attribute
        (using _mung_id).
 
        Returns the modified string.
        """
        if not s:
            return s
 
        tlist = tokenize.generate_tokens (StringIO(s).readline)
        out = []
        afterDot = False
        for tnum, val, a, b, c in tlist:
            if tnum == token.NAME and not afterDot:
                if hasattr (self.tuple_o, val):
                    val = self._mung_id (val)
                    #val = _evtvar + '.' + val
            out.append ((tnum, val))
            # Don't mung names after a period.  We may have attributes
            # with the same names as variables in the tuple.
            if tnum == token.OP and val == '.':
                afterDot = True
            else:
                afterDot = False
        return _untokenize (out)
 
 

_mung_id()

python.pydraw.Draw_Cmd._mung_id ( self, id )

protected

Given a loop identifier (`foo' in `foo$i'), return the identifier
used to reference it in loop functions.

Definition at line 765 of file pydraw.py.

    def _mung_id (self, id):
        """Given a loop identifier (`foo' in `foo$i'), return the identifier
        used to reference it in loop functions.
        """
        out = self._iddict.get (id)
        if not out:
            out = '_e_' + id
            self._iddict[id] = out
        return out
 
 

_mung_index()

python.pydraw.Draw_Cmd._mung_index ( self, s1, s2 )

protected

Handle an explicit index reference; i.e., `foo$2'.

S1 and S2 are pieces of the string before and after the `$'.
Returns the modified string.

Definition at line 776 of file pydraw.py.

    def _mung_index (self, s1, s2):
        """Handle an explicit index reference; i.e., `foo$2'.
 
        S1 and S2 are pieces of the string before and after the `$'.
        Returns the modified string.
        """
        pos2 = 0
        while pos2 < len(s2) and s2[pos2] in string.digits:
            pos2 += 1
        if pos2 == 0:
            self.errstr = "Bad index"
            return ''
        i = int (s2[:pos2])
        if i < 1:
            self.errstr = "Bad index"
            return ''
        s = ("[%d]" % (i-1)) + s2[pos2:]
        pos2 = len(s1)-1
        while pos2 >= 0 and s1[pos2] in _idchars:
            pos2 -= 1
        pos2 += 1
        if pos2 == len(s1):
            self.errstr = "Bad index"
            return ''
        id = s1[pos2:]
        s = s1[:pos2] + self._mung_id (id) + s
        self._limdict[id] = max (i, self._limdict.get(id, 0))
        return s
 
 

_mung_loop()

python.pydraw.Draw_Cmd._mung_loop ( self, s1, s2 )

protected

Handle use of a dummy loop variable, such as foo$i.

S1 and S2 are pieces of the string before and after the `$'.
Returns the modified string.

Definition at line 820 of file pydraw.py.

    def _mung_loop (self, s1, s2):
        """Handle use of a dummy loop variable, such as foo$i.
 
        S1 and S2 are pieces of the string before and after the `$'.
        Returns the modified string.
        """
 
        # Scan after the $ to find the dummy variable.
        pos2 = 0
        while pos2 < len(s2) and s2[pos2] in _idchars:
            pos2 += 1
        if pos2 == 0:
            self.errstr = "Bad loop var"
            return ''
        loopvar =  s2[:pos2]
 
        # Look it up.  Make a new _Loopvar object if it's not in the map.
        ll = self._loopdict.get (loopvar)
        if not ll:
            ll = _Loopvar(loopvar)
            self._loopdict[loopvar] = ll
 
        # Is the $ after an identifier?
        if len(s1) > 0 and s1[-1] in _idchars:
            # Yes --- find the identifier.
            pos3 = len(s1)-1
            while pos3 >= 0 and s1[pos3] in _idchars:
                pos3 -= 1
            pos3 += 1
            assert (len(s1) - pos3 >= 1)
            id = s1[pos3:]
 
            # Replace with the iterator.
            s = s1[:pos3] + ll.add_id(id) + s2[pos2:]
            self._mung_id (id)
        else:
            # Explicit use of the dummy.
            # Replace with the dummy name and note that it was used explicitly.
            s = s1 + ("%s" % ll.dumname()) + s2[pos2:]
            ll.explicit = 1
        return s
 
 

_mung_n()

python.pydraw.Draw_Cmd._mung_n ( self, s1, s2 )

protected

Handle a length reference; i.e., `$nfoo'.

S1 and S2 are pieces of the string before and after the `$'.
Returns the modified string.

Definition at line 806 of file pydraw.py.

    def _mung_n (self, s1, s2):
        """Handle a length reference; i.e., `$nfoo'.
 
        S1 and S2 are pieces of the string before and after the `$'.
        Returns the modified string.
        """
        pos2 = 1
        while pos2 < len(s2) and s2[pos2] in _idchars:
            pos2 += 1
        id = s2[1:pos2]
        s = s1 + (" len(%s)" % self._mung_id(id)) + s2[pos2:]
        return s
 
 

_parserange()

python.pydraw.Draw_Cmd._parserange ( self, tuple )

protected

Parse the range part of a draw string.

See above for more details.
Fills self.tuple, self.lo, self.hi.

Definition at line 728 of file pydraw.py.

    def _parserange (self, tuple):
        """Parse the range part of a draw string.
 
        See above for more details.
        Fills self.tuple, self.lo, self.hi.
        """
        lo = 0
        hi = sys.maxsize
        (tuple, tail) = _find_outer (tuple, '[')
        if tail:
            g = copy.copy (_globals)
 
            pos = tail.find (':')
            pos2 = tail.find (']')
            if pos2 < 0:
                    pos2 = len (tail) #pragma: NO COVER
            if pos < 0:
                slo = tail[:pos2].strip()
                if len (slo) > 0:
                    lo = int (eval (slo, g))
                hi = lo + 1
            else:
                slo = tail[:pos].strip()
                if len (slo) > 0:
                    lo = int (eval (slo, g))
                shi = tail[pos+1:pos2].strip()
                if len (shi) > 0:
                    hi = int (eval (shi, g))
 
        if tuple[0] == '(' and tuple[-1] == ')':
            tuple = tuple[1:-1].strip()
        self.tuple = tuple
        self.lo = lo
        self.hi = hi
        return
 
 

_tupleparse()

python.pydraw.Draw_Cmd._tupleparse ( self, s )

protected

Parse a draw string.  See above for more details.

Definition at line 653 of file pydraw.py.

    def _tupleparse (self, s):
        """Parse a draw string.  See above for more details."""
 
        # Split off the histspec.
        (s, self.histspec) = _find_outer (s, ';')
 
        # ??? Don't split at spaces in delimiters.
        # _find_outer doesn't really work for this since it operates
        # on the tokenized string, in which whitespace doesn't appear.
        if self.histspec is None:
            self.histspec = []
        else:
            self.histspec = self.histspec.split ()
 
        # Gotta have something.
        s = s.strip()
        if not s:
            self.errstr = "Empty draw string."
            return
 
        # Split off the tuple part --- before the first period.
        (tuple, s) = _find_outer (s, '.')
        if not s:
            self.errstr = "Missing period in tuple specification."
            return
 
        # Handle a range specification on the sample.
        self._parserange (tuple)
 
        # Try to find the sample.
        try:
            self.tuple_o = eval (self.tuple, _globals)
        except NameError:
            self.tuple_o = None
        if not self.tuple_o:
            self.errstr = "Can't find sample " + self.tuple
            return
 
        # Look for additional statements.
        self.stmts = _split_outer (s, '@')
        s = self.stmts[-1]
        del self.stmts[-1]
        self.stmts = [self._mung_expr(x) for x in self.stmts]
 
        # Split off the selection.
        (self.expr_orig, self.sel_orig) = _find_outer (s, "if")
        self.sel = self._mung_expr (self.sel_orig)
 
        self.exprs = [self._mung_expr(x) for x in
                      _split_outer (self.expr_orig, ':')]
 
        # Check the interface of the sample.  If it doesn't have
        # the loop interface but has the root tree interface,
        # use a wrapper.
        if hasattr (self.tuple_o, 'loop'):
            # Ok --- has the loop interface.
            pass
        elif (hasattr (self.tuple_o, 'GetEntry') and
              hasattr (self.tuple_o, 'GetEntries')):
            # Has the TTree interface.  Use a wrapper.
            self.tuple_o = TreeLoopWrapper (self.tuple_o)
        elif (hasattr (self.tuple_o, 'size') and
              hasattr (self.tuple_o, 'seekEvent')):           #pragma: NO COVER
            # Has the appmgr interface.  Use a wrapper.
            self.tuple_o = AthenaLoopWrapper (self.tuple_o)   #pragma: NO COVER
        else:
            # An error --- complain.
            self.errstr = ("Sample " + self.tuple +
                           " doesn't have a correct interface.")
            return
 
        return
 
 
 

Member Data Documentation

_iddict

dict python.pydraw.Draw_Cmd._iddict = {}

protected

Definition at line 639 of file pydraw.py.

_limdict

dict python.pydraw.Draw_Cmd._limdict = {}

protected

Definition at line 640 of file pydraw.py.

_loopdict

dict python.pydraw.Draw_Cmd._loopdict = {}

protected

Definition at line 641 of file pydraw.py.

errstr

str python.pydraw.Draw_Cmd.errstr = None

Definition at line 637 of file pydraw.py.

excstr

python.pydraw.Draw_Cmd.excstr = traceback.format_exc()

Definition at line 648 of file pydraw.py.

expr_orig

python.pydraw.Draw_Cmd.expr_orig

Definition at line 698 of file pydraw.py.

exprs

list python.pydraw.Draw_Cmd.exprs

Initial value:

=  [self._mung_expr(x) for x in
                      _split_outer (self.expr_orig, ':')]

Definition at line 701 of file pydraw.py.

hi

python.pydraw.Draw_Cmd.hi = hi

Definition at line 761 of file pydraw.py.

histspec

list python.pydraw.Draw_Cmd.histspec

Definition at line 657 of file pydraw.py.

lo

python.pydraw.Draw_Cmd.lo = lo

Definition at line 760 of file pydraw.py.

sel

python.pydraw.Draw_Cmd.sel = self._mung_expr (self.sel_orig)

Definition at line 699 of file pydraw.py.

sel_orig

python.pydraw.Draw_Cmd.sel_orig

Definition at line 698 of file pydraw.py.

stmts

list python.pydraw.Draw_Cmd.stmts = _split_outer (s, '@')

Definition at line 692 of file pydraw.py.

tuple

python.pydraw.Draw_Cmd.tuple = tuple

Definition at line 759 of file pydraw.py.

tuple_o

python.pydraw.Draw_Cmd.tuple_o = eval (self.tuple, _globals)

Definition at line 684 of file pydraw.py.

---

The documentation for this class was generated from the following file:

• pydraw.py