Inheritance diagram for python.pydraw.Draw_Cmd:

Collaboration diagram for python.pydraw.Draw_Cmd:

Public Member Functions
def	__init__ (self, s)

Public Attributes
	errstr

	excstr

	histspec

	tuple_o

	stmts

	sel

	exprs

	tuple

	lo

	hi

Private Member Functions
def	_tupleparse (self, s)

def	_parserange (self, tuple)

def	_mung_id (self, id)

def	_mung_index (self, s1, s2)

def	_mung_n (self, s1, s2)

def	_mung_loop (self, s1, s2)

def	_mung_expr_dollar (self, s)

def	_mung_expr_ids (self, s)

def	_mung_expr (self, s)

def	_make_func (self, payload, extargs='')

Private Attributes
	_iddict

	_limdict

	_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 610 of file pydraw.py.

Constructor & Destructor Documentation

◆ init()

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

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

Definition at line 639 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()

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

private

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 940 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()

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

private

Process $ constructions and id substitution in string S.

Returns the modified string.

Definition at line 931 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()

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

private

Process $ constructions in string S.

Returns the modified string.

Definition at line 869 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()

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

private

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 901 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()

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

private

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

Definition at line 771 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()

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

private

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 782 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()

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

private

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 826 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()

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

private

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 812 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()

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

private

Parse the range part of a draw string.

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

Definition at line 734 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()

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

private

Parse a draw string.  See above for more details.

Definition at line 659 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

python.pydraw.Draw_Cmd._iddict

private

Definition at line 645 of file pydraw.py.

◆ _limdict

python.pydraw.Draw_Cmd._limdict

private

Definition at line 646 of file pydraw.py.

◆ _loopdict

python.pydraw.Draw_Cmd._loopdict

private

Definition at line 647 of file pydraw.py.

◆ errstr

python.pydraw.Draw_Cmd.errstr

Definition at line 643 of file pydraw.py.

◆ excstr

python.pydraw.Draw_Cmd.excstr

Definition at line 654 of file pydraw.py.

◆ exprs

python.pydraw.Draw_Cmd.exprs

Definition at line 707 of file pydraw.py.

◆ hi

python.pydraw.Draw_Cmd.hi

Definition at line 767 of file pydraw.py.

◆ histspec

python.pydraw.Draw_Cmd.histspec

Definition at line 669 of file pydraw.py.

◆ lo

python.pydraw.Draw_Cmd.lo

Definition at line 766 of file pydraw.py.

◆ sel

python.pydraw.Draw_Cmd.sel

Definition at line 705 of file pydraw.py.

◆ stmts

python.pydraw.Draw_Cmd.stmts

Definition at line 698 of file pydraw.py.

◆ tuple

python.pydraw.Draw_Cmd.tuple

Definition at line 765 of file pydraw.py.

◆ tuple_o

python.pydraw.Draw_Cmd.tuple_o

Definition at line 690 of file pydraw.py.

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

pydraw.py

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _make_func()

◆ _mung_expr()

◆ _mung_expr_dollar()

◆ _mung_expr_ids()

◆ _mung_id()

◆ _mung_index()

◆ _mung_loop()

◆ _mung_n()

◆ _parserange()

◆ _tupleparse()

Member Data Documentation

◆ _iddict

◆ _limdict

◆ _loopdict

◆ errstr

◆ excstr

◆ exprs

◆ hi

◆ histspec

◆ lo

◆ sel

◆ stmts

◆ tuple

◆ tuple_o

◆ init()