python.Include.Include Class Reference

Inheritance diagram for python.Include.Include:

Collaboration diagram for python.Include.Include:

Public Member Functions
def	__init__ (self, show=True, collect=1, clean=False)
def	setShowIncludes (self, show)
def	setCollect (self, collect)
def	setClean (self, clean)
def	__call__ (self, fn, *args, **kw)
def	block (self, fn)
def	unblock (self, fn)

Public Attributes
	msg

Static Public Attributes
int	fid = 0

Private Member Functions
def	_doTrace (self, fn)
def	_trace_include (self, frame, event, arg)
def	_oneline (self, fid, lineno, detail, buf)

Private Attributes
	_show
	_once
	_fcurrent
	_workspace
	_collect

Detailed Description

Definition at line 75 of file Include.py.

Constructor & Destructor Documentation

__init__()

def python.Include.Include.__init__	(		self,
			show = True,
			collect = 1,
			clean = False
	)

Definition at line 78 of file Include.py.

   def __init__( self, show = True, collect = 1, clean = False ):
      self._show = show
      self._once = []
      self._fcurrent = ''
      self.msg = Logging.logging.getLogger( 'Athena' )
 
      if clean:
         self._workspace = {}
      else:
         import __main__
         self._workspace = __main__.__dict__
 
      if collect:
         self._collect = 1
         

Member Function Documentation

__call__()

def python.Include.Include.__call__	(		self,
			fn,
		*	args,
		**	kw
	)

Include <fn> in the current scope by executing it globally.

Definition at line 111 of file Include.py.

   def __call__( self, fn, *args, **kw ):
      """Include <fn> in the current scope by executing it globally."""
 
    # some basic sanity check first  
      if isinstance(fn, str) and len(fn) == 0:
         raise IncludeError("can not 'include' empty filenames")
      
    # don't include file if not allowed (has to be exact match in py code)
      if fn in self._once:
         self.msg.debug( 'file "%s" is blocked; not included', fn )
         return
 
    # locate the file
      name = FindFile( os.path.expanduser( os.path.expandvars( fn ) ), optionsPath, os.R_OK )
      if not name:
         name = FindFile( os.path.basename( fn ), optionsPath, os.R_OK )
         if name:
            self.msg.warning( 'using %s instead of %s', name, fn )
         else:
            raise IncludeError( 'include file %s can not be found' % fn )
 
      self.msg.debug( 'located %s as %s', fn, name )
 
    # print if 'show' is set to non-null
      show = self._show
      if 'show' in kw:
         show = kw[ 'show' ]
 
    # notify of start of file inclusion
      if show:
         self.msg.info( 'including file "%s" with ID %d', fn, self.fid )
      else:
         self.msg.info( 'including file "%s"', fn )
      self._fcurrent = name
 
    # actual inclusion
      if show and self._doTrace( name ):
       # traced
         _filecache[ name ] = open( name, 'r' ).readlines()
         _linecache[ name ] = 0, self.fid
         self.fid += 1
 
         from past.builtins import execfile
         sys.settrace( self._trace_include )
         execfile( name, self._workspace, self._workspace )
         sys.settrace( sys._getframe(0).f_trace )
 
       # finish file printout
         ncur, fid = _linecache[ name ]
         buf  = _filecache[ name ]
         for i in range( ncur, len(buf) ):
            self._oneline( fid, i, silentMarker, buf )
 
         del _filecache[ name ]
         del _linecache[ name ]
 
         self.msg.info( 'end of "%s"', fn )
 
      else:
       # non-traced
         #execfile( name, self._workspace, self._workspace )
         exec(compile(open(name).read(), name, 'exec'), self._workspace, self._workspace)
         
 
      if hasattr( self, '_collect' ):
         if not self._collect % 10:
            import gc
            gc.collect()
         else:
            self._collect += 1
 

_doTrace()

def python.Include.Include._doTrace (   self,   fn  )

private

Definition at line 196 of file Include.py.

   def _doTrace( self, fn ):
    # Tracing into non-included files is controlled with two variables:
    # excludeTracePattern and includeTracePattern. The former goes first,
    # the latter can override any excluded results.
 
      if fn in _notrcache:
         return False
 
      doTrace = True
      for tracePattern in excludeTracePattern:
         if fnmatch.fnmatch( fn, tracePattern ):
            doTrace = False
            break
 
      if not doTrace:
         for tracePattern in includeTracePattern:
            if fnmatch.fnmatch( fn, tracePattern ):
               doTrace = True
               break
 
      if not doTrace:
         _notrcache[ fn ] = 1
 
      return doTrace
 

_oneline()

def python.Include.Include._oneline (   self,   fid,   lineno,   detail,   buf  )

private

Definition at line 284 of file Include.py.

   def _oneline( self, fid, lineno, detail, buf ):
      print (marker, fidMarker % fid, lineMarker % lineno, detail,)
 
      try:
 
       # simple eol case
         if not buf or not buf[ lineno ]:
            print()
            return
 
       # in general, an interpreter "line" may be longer than a file line
         line = buf[ lineno ].rstrip()
         while line and ( line[-1] == '(' or line[-1] == '\\' ):
          # this line appears to have a continuation ...
            try:
             # output traced line
               print (line)
 
             # output continued line
               lineno += 1
               print (marker, fidMarker % fid, lineMarker % lineno, detail,)
               line = buf[ lineno ].rstrip()
            except IndexError:
             # shouldn't happen; but must mean that the diagnosis above is
             # wrong and that there is no continuation, keep silent
               break
 
         print (line)
 
      except IndexError:
         log.warning( 'index (%d) out of range while scanning include file %d', lineno, fid )
 
 
# use this for backward compatibility

_trace_include()

def python.Include.Include._trace_include (   self,   frame,   event,   arg  )

private

Definition at line 222 of file Include.py.

   def _trace_include( self, frame, event, arg ):
      fn  = frame.f_code.co_filename
      if fn.find ('importlib._bootstrap') >= 0:
         return self._trace_include
 
      if not os.path.exists( fn ):
         fn = FindFile( basename2( fn ), sys.path, os.R_OK )
 
      if not ( fn and self._doTrace( fn ) ):
         return self._trace_include
 
      if fn not in _filecache:
       # wait until importing of the module is done to minimize pollution
         f = frame.f_back
         while f is not None:
            try:
               if 'import' in _filecache[ f.f_code.co_filename ][ f.f_lineno ]:
                  return self._trace_include
            except Exception:
               pass
            f = f.f_back
         del f
 
       # import is done, and we're back, accept this file from this point on
         _filecache[ fn ] = open( fn, 'r' ).readlines() or '\n'
         _linecache[ fn ] = sys.maxsize, self.fid
         self.fid += 1
 
      lno = frame.f_lineno
      aln = lno - 1 > 0 and lno - 1 or 0
 
      ncur, fid = _linecache[ fn ]
      buf = _filecache[ fn ]
 
      if self._fcurrent != fn:
         self.msg.info( 'continued trace of "%s"', basename2( fn ) )
         self._fcurrent = fn
 
      if event == 'line':
         for i in range( ncur, aln ):
            self._oneline( fid, i, silentMarker, buf )
 
         if ncur <= aln:
            self._oneline( fid, aln, activeMarker, buf )
         elif 0 <= aln:
            self._oneline( fid, aln, tracedMarker, buf )
 
         if ncur < lno:
            _linecache[ fn ] = lno, fid
 
      elif event == 'call':
         if lno < ncur:
            self._oneline( fid, aln, callMarker, buf )
 
      elif event == 'return':
         if lno < ncur:
            fln = frame.f_code.co_firstlineno - 1
            self._oneline( fid, fln, returnMarker, None )
 
      return self._trace_include
 

block()

def python.Include.Include.block	(		self,
			fn
	)

Disallow the given filename(s) from being included again.

Definition at line 182 of file Include.py.

   def block( self, fn ):
      """Disallow the given filename(s) from being included again."""
 
      if type(fn) is list:
         self._once += fn
      else:
         self._once.append( fn )
 

setClean()

def python.Include.Include.setClean	(		self,
			clean
	)

Definition at line 102 of file Include.py.

   def setClean( self, clean ):
      import __main__
      if clean:
         if self._workspace is __main__.__dict__:
            self._workspace = {}
            self._workspace.update( __main__.__dict__ )
      else:
         self._workspace = __main__.__dict__
 

setCollect()

def python.Include.Include.setCollect	(		self,
			collect
	)

Definition at line 96 of file Include.py.

   def setCollect( self, collect ):
      if collect and not hasattr( self, '_collect' ):
         self._collect = 1
      elif not collect and hasattr( self, '_collect' ):
         del self._collect
 

setShowIncludes()

def python.Include.Include.setShowIncludes	(		self,
			show
	)

Definition at line 93 of file Include.py.

   def setShowIncludes( self, show ):
      self._show = show
 

unblock()

def python.Include.Include.unblock	(		self,
			fn
	)

Re-allow the given filename from being included.

Definition at line 190 of file Include.py.

   def unblock( self, fn ):
      """Re-allow the given filename from being included."""
 
      self._once.remove( fn )
 

Member Data Documentation

_collect

python.Include.Include._collect

private

Definition at line 91 of file Include.py.

_fcurrent

python.Include.Include._fcurrent

private

Definition at line 81 of file Include.py.

_once

python.Include.Include._once

private

Definition at line 80 of file Include.py.

_show

python.Include.Include._show

private

Definition at line 79 of file Include.py.

_workspace

python.Include.Include._workspace

private

Definition at line 85 of file Include.py.

fid

int python.Include.Include.fid = 0

static

Definition at line 76 of file Include.py.

msg

python.Include.Include.msg

Definition at line 82 of file Include.py.

---

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

• Include.py