addFilter ( self,  filter )

Attach a single filter to the end of the current filter chain.

addHook (
        self,
        hook,
        prepend=False,
        )

Add a new hook; optionally insert it rather than appending it.

areHooksEnabled ( self )

Return whether or not hooks are presently enabled.

assign (
        self,
        name,
        value,
        locals=None,
        )

Do a potentially complex (including tuple unpacking) assignment.

atExit ( self,  callable )

Register a function to be called at exit.

atomic (
        self,
        name,
        value,
        locals=None,
        )

Do an atomic assignment.

binary (
        self,
        file,
        name='<binary>',
        chunkSize=0,
        locals=None,
        )

Parse the entire contents of a file-like object, in chunks.

clause (
        self,
        catch,
        locals=None,
        )

Given the string representation of an except clause, turn it into a 2-tuple consisting of the class name, and either a variable name or None.

clearGlobals ( self )

Clear out the globals with a brand new dictionary.

clearHooks ( self )

Clear all hooks.

createDiversion ( self,  name )

Create a diversion (but do not divert to it) if it does not already exist.

declare (
        self,
        name,
        type,
        keywords=None,
        locals=None,
        )

Declare a resource.

defined (
        self,
        name,
        locals=None,
        )

Return a Boolean indicating whether or not the name is defined either in the locals or the globals.

deregister ( self,  hook )

Remove an already registered hook.

deregisterCallback ( self )

Remove any previously registered callback with this interpreter.

dictionary (
        self,
        code,
        locals=None,
        )

Given a string represent a keyword argument list, turn it into a dictionary.

disableHooks ( self )

Disable hooks.

enableHooks ( self )

Enable hooks.

escape (
        self,
        data,
        more='',
        )

Escape a string so that nonprintable characters are replaced with compatible EmPy expansions.

evaluate (
        self,
        expression,
        locals=None,
        )

Evaluate an expression.

execute (
        self,
        statements,
        locals=None,
        )

Execute a statement.

expand (
        self,
        data,
        locals=None,
        )

Do an explicit expansion on a subordinate stream.

fail (
        self,
        error,
        fatal=False,
        )

Handle an actual error that occurred.

file (
        self,
        file,
        name='<file>',
        locals=None,
        )

Parse the entire contents of a file-like object, line by line.

finalize ( self )

Execute any remaining final routines.

fixGlobals ( self )

Reset the globals, stamping in the pseudomodule.

flatten ( self,  keys=None )

Flatten the contents of the pseudo-module into the globals namespace.

functional (
        self,
        code,
        tokensList,
        locals=None,
        )

Handle a functional expression like @f{x}. tokensList is a list of list of tokens.

getAllDiversions ( self )

Get the names of all existing diversions.

getCallback ( self )

Get the callback registered with this interpreter, or None.

getCurrentDiversion ( self )

Get the name of the current diversion.

getFilter ( self )

Get the current filter.

getGlobals ( self )

Retrieve the globals.

getHooks ( self )

Get the current hooks.

getPrefix ( self )

Get the current prefix.

handle ( self,  meta )

Handle a MetaError.

identify ( self )

Identify the topmost context with a 2-tuple of the name and line number.

import_ (
        self,
        name,
        locals=None,
        )

Do an import.

include (
        self,
        filename,
        locals=None,
        )

Do an include pass on a file.

interact ( self )

Perform interaction.

invoke (
        self,
        _name,
        **keywords,
        )

Invoke the hook(s) associated with the hook name, should they exist.

invokeCallback ( self,  contents )

Invoke the callback.

invokeHook (
        self,
        _name,
        **keywords,
        )

Manually invoke a hook.

literal ( self,  text )

Process a string literal.

meta ( self,  exc=None )

Construct a MetaError for the interpreter's current state.

multi (
        self,
        names,
        values,
        locals=None,
        )

Do a (potentially recursive) assignment.

ok ( self )

Is the interpreter still active?

parse (
        self,
        scanner,
        locals=None,
        )

Parse and run as much from this scanner as possible.

playAllDiversions ( self )

Play all existing diversions and then purge them.

playDiversion ( self,  name )

Play the given diversion and then purge it.

popContext ( self )

Pop the top context.

process ( self,  commands )

Handle some main-level processing of metacommands.

purgeAllDiversions ( self )

Purge all existing diversions.

purgeDiversion ( self,  name )

Eliminate the given diversion.

pushContext (
        self,
        name='<unnamed>',
        line=0,
        )

Create a new context and push it.

quote ( self,  data )

Quote the given string so that if it were expanded it would evaluate to the original.

ready ( self )

Declare the interpreter ready for normal operations.

register (
        self,
        hook,
        prepend=False,
        )

Register the provided hook.

registerCallback ( self,  callback )

Register a custom markup callback with this interpreter.

removeHook ( self,  hook )

Remove a preexisting hook.

replayAllDiversions ( self )

Replay all existing diversions without purging them.

replayDiversion ( self,  name )

Replay the diversion without purging it.

resetFilter ( self )

Reset the filter so that it does no filtering.

restoreGlobals ( self,  destructive=True )

Restore the most recently saved copy of the globals.

retrieveDiversion ( self,  name )

Retrieve the diversion object associated with the name.

run (
        self,
        tokens,
        name='<run>',
        locals=None,
        )

Do an explicit expansion on a sequence of tokens.

safe (
        self,
        scanner,
        final=False,
        locals=None,
        )

Do a protected parse. Catch transient parse errors; if final is true, then make a final pass with a terminator, otherwise ignore the transient parse error (more data is pending).

saveGlobals ( self,  deep=True )

Save a copy of the globals off onto the history stack.

serialize (
        self,
        expression,
        locals=None,
        )

Do an expansion, involving evaluating an expression, then converting it to a string and writing that string to the output if the evaluation is not None.

setContextLine ( self,  line )

Set the name of the topmost context.

setContextName ( self,  name )

Set the name of the topmost context.

setFilter ( self,  filter )

Set the filter.

setFilterChain ( self,  filters )

Set the filter.

setGlobals ( self,  globals )

Set the globals to the specified dictionary.

setPrefix ( self,  prefix )

Set the prefix.

shutdown ( self )

Declare this interpreting session over; close the stream file object. This method is idempotent.

significate (
        self,
        key,
        value=None,
        locals=None,
        )

Declare a significator.

single (
        self,
        source,
        locals=None,
        )

Execute an expression or statement, just as if it were entered into the Python interactive interpreter.

startDiversion ( self,  name )

Start diverting to the given diversion name.

stopDiverting ( self )

Stop any diverting.

string (
        self,
        data,
        name='<string>',
        locals=None,
        )

Parse a string.

tokenize ( self,  name )

Take an lvalue string and return a name or a (possibly recursive) list of names.

unfixGlobals ( self )

Remove the pseudomodule (if present) from the globals.

updateGlobals ( self,  otherGlobals )

Merge another mapping object into this interpreter's globals.

wrap (
        self,
        callable,
        args,
        )

Wrap around an application of a callable and handle errors. Return whether no error occurred.