6.5.1 Context Objects

class Context([load] )

Instantiate a new context.

If the load  argument is set to true, the context will load all of the base macros defined in plasT_eX. This includes all of the macros used in the standard T_eX and L^aT_eX distributions.

contexts

stack of all macro and category code collections currently in the document being processed. The item at index 0 include the global macro set and default category codes.

counters

a dictionary of counters.

currentlabel

the object that is given the label when a \label macro is invoked.

isMathMode

boolean that specifies if we are currently in T_eX’s math mode or not.

labels

a dictionary of labels and the objects that they refer to.

addGlobal(key, value )

add a macro value  with name key  to the global namespace.

addLocal(key, value )

add a macro value  with name key  to the current namespace.

append([context] )

same as push()

catcode(char, code )

set the category code for a character in the current scope. char  is the character that will have its category code changed. code  is the T_eX category code (0-15) to change it to.

chardef(name, num )

create a new T_eX chardef like \chardef.

name  is the name of the command to create.

num  is the character number to use.

__getitem__(key )

look through the stack of macros and return the one with the name key . The return value is an instance of the requested macro, not a reference to the macro class. This method allows you to use Python’s dictionary syntax to retrieve the item from the context as shown below.

tex.context['section']

importMacros(context )

import macros from another context into the global namespace. The argument, context , must be a dictionary of macros.

label(label )

set the given label to the currently labelable object. An object can only have one label associated with it.

let(dest, source )

create a new T_eX let like \let.

dest  is the command sequence to create.

source  is the token to set the command sequence equivalent to.

Example

c.let('bgroup', BeginGroup('{'))

loadBaseMacros( )

imports all of the base macros defined by plasT_eX. This includes all of the macros specified by the T_eX and L^aT_eX systems.

loadLanguage(language, document )

loads a language package to configure names such as \figurename, \tablename, etc. See Section 6.5.2 for more information.

language  is a string containing the name of the language file to load.

document  is the document object being processed.

loadINIPackage(inifile )

load an INI formatted package file (see section 4.3 for more information).

loadPackage(tex, file, [options] )

loads a L^aT_eX package.

tex  is the T_eX processor to use in parsing the package content

file  is the name of the package to load

options  is a dictionary containing the options to pass to the package. This generally comes from the optional argument on a \usepackage or \documentclass macro.

The package being loaded by this method can be one of three type: 1) a native L^aT_eX package, 2) a Python package, or 3) an INI formatted file. The Python version of the package is searched for first. If it is found, it is loaded and an INI version of the package is also loaded if it exists. If there is no Python version, the true L^aT_eX version of the package is loaded. If there is an INI version of the package in the same directory as the L^aT_eX version, that file is loaded also.

newcommand(name[, nargs[, definition[, opt]]] )

create a new L^aT_eX command like \newcommand.

name  is the name of the macro to create.

nargs  is the number of arguments including optional arguments.

definition  is a string containing the macro definition.

opt  is a string containing the default optional value.

Examples

c.newcommand('bold', 1, r'\\textbf{#1}')
c.newcommand('foo', 2, r'{\\bf #1#2}', opt='myprefix')

newcount(name[, initial] )

create a new count like \newcount.

newcounter(name, [resetby, initial, format] )

create a new counter like \newcounter.

name  is the name of the counter to create.

resetby  is the counter that, when incremented, will reset the new counter.

initial  is the initial value for the counter.

format  is the printed format of the counter.

In addition to creating a new counter macro, another macro corresponding to the \thename  is created which prints the value of the counter just like in L^aT_eX.

newdef(name[, args[, definition[, local]]] )

create a new T_eX definition like \def.

name  is the name of the definition to create.

args  is a string containing the T_eX argument profile.

definition  is a string containing the macro code to expand when the definition is invoked.

local  is a boolean that specifies that the definition should only exist in the local scope. The default value is true.

Examples

c.newdef('bold', '#1', '{\\bf #1}')
c.newdef('put', '(#1,#2)#3', '\\dostuff{#1}{#2}{#3}')

newdimen(name[, initial] )

create a new dimen like \newdimen.

newenvironment(name[, nargs[, definition[, opt]]] )

create a new L^aT_eX environment like \newenvironment. This works exactly like the newcommand() method, except that the definition  argument is a two element tuple where the first element is a string containing the macro content to expand at the \begin, and the second element is the macro content to expand at the \end.

Example

c.newenvironment('mylist', 0, (r'\\begin{itemize}', r'\\end{itemize}'))

newif(name[, initial] )

create a new if like \newif. This also creates macros corresponding to \name true and \name false.

newmuskip(name[, initial] )

create a new muskip like \newmuskip.

newskip(name[, initial] )

create a new skip like \newskip.

packages

a dictionary of L^aT_eX packages. The keys are the names of the packages. The values are dictionaries containing the options that were specified when the package was loaded.

pop([obj] )

pop the top scope off of the stack. If obj  is specified, continue to pop scopes off of the context stack until the scope that was originally added by obj  is found.

push([context] )

add a new scope to the stack. If a macro instance context  is specified, the new scope’s namespace is given by that object.

ref(obj, label )

set up a reference for resolution.

obj  is the macro object that is doing the referencing.

label  is the label of the node that obj  is looking for.

If the item that obj  is looking for has already been labeled, the idref attribute of obj  is set to the abject. Otherwise, the reference is stored away to be resolved later.

setVerbatimCatcodes( )

set the current set of category codes to the set used for the verbatim environment.

whichCode(char )

return the character code that char  belongs to. The category codes are the same codes used by T_eX and are defined in the Token class.