def __init__(self, data, gobble):

self.delims, self.code = data.split('#\n', 1)

self.family, self.session, self.restart, self.instance, self.command, self.context, self.args_run, self.args_prettyprint, self.input_file, self.line = self.delims.split('#')

self.instance_int = int(self.instance)

self.line_int = int(self.line)

self.key_run = self.family + '#' + self.session + '#' + self.restart

self.key_typeset = self.key_run + '#' + self.instance

self.hashable_delims_run = self.key_typeset + '#' + self.command + '#' + self.context + '#' + self.args_run

self.hashable_delims_typeset = self.key_typeset + '#' + self.command + '#' + self.context + '#' + self.args_run

if len(self.command) > 1:

self.is_inline = False

# Environments start on the next line

self.line_int += 1

self.line = str(self.line_int)

else:

self.is_inline = True

self.is_extfile = True if self.session.startswith('EXT:') else False

if self.is_extfile:

self.extfile = os.path.expanduser(os.path.normcase(self.session.replace('EXT:', '', 1)))

self.key_typeset = self.key_typeset.replace('EXT:', '')

self.is_cc = True if self.family.startswith('CC:') else False

self.is_pyg = True if self.family.startswith('PYG') else False

self.is_verb = True if self.restart.endswith('verb') else False

if self.is_cc:

self.instance += 'CC'

self.cc_type, self.cc_pos = self.family.split(':')[1:]

if self.is_verb or self.is_pyg or self.is_cc:

self.is_cons = False

else:

self.is_cons = engine_dict[self.family].console

self.is_code = False if self.is_verb or self.is_pyg or self.is_cc or self.is_cons else True

if self.command in ('c', 'code') or (self.command == 'i' and not self.is_cons):

self.is_typeset = False

else:

self.is_typeset = True

if gobble == 'auto':

self.code = textwrap.dedent(self.code)

'''

# Create a command line argument parser

parser = argparse.ArgumentParser()

parser.add_argument('TEXNAME',

help='LaTeX file, with or without .tex extension')

parser.add_argument('--version', action='version',

version='PythonTeX {0}'.format(data['version']))

parser.add_argument('--encoding', default='UTF-8',

help='encoding for all text files (see codecs module for encodings)')

parser.add_argument('--error-exit-code', default='true',

choices=('true', 'false'),

help='return exit code of 1 if there are errors (not desirable with some TeX editors and workflows)')

group_run = parser.add_mutually_exclusive_group()

group_run.add_argument('--runall', nargs='?', default='false',

const='true', choices=('true', 'false'),

help='run ALL code; equivalent to package option')

group_run.add_argument('--rerun', default='errors',

choices=('never', 'modified', 'errors', 'warnings', 'always'),

help='set conditions for rerunning code; equivalent to package option')

parser.add_argument('--hashdependencies', nargs='?', default='false',

const='true', choices=('true', 'false'),

help='hash dependencies (such as external data) to check for modification, rather than using mtime; equivalent to package option')

parser.add_argument('-j', '--jobs', metavar='N', default=None, type=int,

help='Allow N jobs at once; defaults to cpu_count().')

parser.add_argument('-v', '--verbose', default=False, action='store_true',

help='verbose output')

parser.add_argument('--interpreter', default=None, help='set a custom interpreter; argument should be in the form "<interpreter>:<command>, <interp>:<cmd>, ..." where <interpreter> is "python", "ruby", etc., and <command> is the command for invoking the interpreter; argument may also be in the form of a Python dictionary')

group_debug = parser.add_mutually_exclusive_group()

group_debug.add_argument('--debug', nargs='?', default=None,

const='default',

metavar='<family>:<session>:<restart>',

help='Run the specified session (or default session) with the default debugger, if available. If there is only one session, it need not be specified. If the session name is unambiguous, it is sufficient. The full <family>:<session>:<restart> (for example, py:default:default) is only needed when the session name alone would be ambiguous.')

group_debug.add_argument('--interactive', nargs='?', default=None,

const='default',

metavar='<family>:<session>:<restart>',

help='Run the specified session (or default session) in interactive mode. If there is only one session, it need not be specified. If the session name is unambiguous, it is sufficient. The full <family>:<session>:<restart> (for example, py:default:default) is only needed when the session name alone would be ambiguous.')

args = parser.parse_args()

# Store the parsed argv in data and temp_data

data['encoding'] = args.encoding

if args.error_exit_code == 'true':

temp_data['error_exit_code'] = True

else:

temp_data['error_exit_code'] = False

# runall can be mapped onto rerun, so both are stored under rerun

if args.runall == 'true':

temp_data['rerun'] = 'always'

else:

temp_data['rerun'] = args.rerun

# hashdependencies need only be in temp_data, since changing it would

# change hashes (hashes of mtime vs. file contents)

if args.hashdependencies == 'true':

temp_data['hashdependencies'] = True

else:

temp_data['hashdependencies'] = False

if args.jobs is None:

try:

jobs = multiprocessing.cpu_count()

except NotImplementedError:

jobs = 1

temp_data['jobs'] = jobs

else:

temp_data['jobs'] = args.jobs

temp_data['verbose'] = args.verbose

temp_data['debug'] = args.debug

temp_data['interactive'] = args.interactive

# Update interpreter_dict based on interpreter

set_python_interpreter = False

if args.interpreter is not None:

interp_list = args.interpreter.lstrip('{').rstrip('}').split(',')

for interp in interp_list:

if interp:

try:

k, v = interp.split(':', 1)

k = k.strip(' \'"')

v = v.strip(' \'"')

interpreter_dict[k] = v

if k == 'python':

set_python_interpreter = True

except:

print('Invalid --interpreter argument')

return sys.exit(2)

# If the Python interpreter wasn't set, then try to set an appropriate

# default value, based on how PythonTeX was launched (pythontex.py,

# pythontex2.py, or pythontex3.py).

if not set_python_interpreter:

if temp_data['python'] == 2:

if platform.system() == 'Windows':

try:

subprocess.check_output(['py', '--version'])

interpreter_dict['python'] = 'py -2'

except:

msg = '''

'''.format(temp_data['python'])

print(textwrap.dedent(msg[1:]))

return sys.exit(2)

else:

interpreter_dict['python'] = 'python2'

elif temp_data['python'] == 3:

if platform.system() == 'Windows':

try:

subprocess.check_output(['py', '--version'])

interpreter_dict['python'] = 'py -3'

except:

msg = '''

'''.format(temp_data['python'])

print(textwrap.dedent(msg[1:]))

return sys.exit(2)

else:

interpreter_dict['python'] = 'python3'

if args.TEXNAME is not None:

# Determine if we a dealing with just a filename, or a name plus

# path. If there's a path, we need to make the document directory

# the current working directory.

dir, raw_jobname = os.path.split(args.TEXNAME)

dir = os.path.expanduser(os.path.normcase(dir))

if dir:

os.chdir(dir)

sys.path.append(dir)

# If necessary, strip off an extension to find the raw jobname that

# corresponds to the .pytxcode.

if not os.path.exists(raw_jobname + '.pytxcode'):

raw_jobname = raw_jobname.rsplit('.', 1)[0]

if not os.path.exists(raw_jobname + '.pytxcode'):

print('* PythonTeX error')

print(' Code file ' + raw_jobname + '.pytxcode does not exist.')

print(' Run LaTeX to create it.')

return sys.exit(1)

# We need a "sanitized" version of the jobname, with spaces and

# asterisks replaced with hyphens. This is done to avoid TeX issues

# with spaces in file names, paralleling the approach taken in

# pythontex.sty. From now on, we will use the sanitized version every

# time we create a file that contains the jobname string. The raw

# version will only be used in reference to pre-existing files created

# on the TeX side, such as the .pytxcode file.

jobname = raw_jobname.replace(' ', '-').replace('"', '').replace('*', '-')

# Store the results in data

data['raw_jobname'] = raw_jobname

data['jobname'] = jobname

# We need to check to make sure that the "sanitized" jobname doesn't

# lead to a collision with a file that already has that name, so that

# two files attempt to use the same PythonTeX folder.

#

# If <jobname>.<ext> and <raw_jobname>.<ext> both exist, where <ext>

# is a common LaTeX extension, we exit. We operate under the

# assumption that there should be only a single file <jobname> in the

# document root directory that has a common LaTeX extension. That

# could be false, but if so, the user probably has worse things to

# worry about than a potential PythonTeX output collision.

# If <jobname>* and <raw_jobname>* both exist, we issue a warning but

# attempt to proceed.

if jobname != raw_jobname:

resolved = False

for ext in ('.tex', '.ltx', '.dtx'):

if os.path.isfile(raw_jobname + ext):

if os.path.isfile(jobname + ext):

print('* PythonTeX error')

print(' Directory naming collision between the following files:')

print(' ' + raw_jobname + ext)

print(' ' + jobname + ext)

return sys.exit(1)

else:

resolved = True

break

if not resolved:

ls = os.listdir('.')

for file in ls:

if file.startswith(jobname):

print('* PythonTeX warning')

print(' Potential directory naming collision between the following names:')

print(' ' + raw_jobname)

print(' ' + jobname + '*')

print(' Attempting to proceed.')

temp_data['warnings'] += 1

'''

# Bring in the .pytxcode file as a single string

raw_jobname = data['raw_jobname']

encoding = data['encoding']

# The error checking here is a little redundant

if os.path.isfile(raw_jobname + '.pytxcode'):

f = open(raw_jobname + '.pytxcode', 'r', encoding=encoding)

pytxcode = f.read()

f.close()

else:

print('* PythonTeX error')

print(' Code file ' + raw_jobname + '.pytxcode does not exist.')

print(' Run LaTeX to create it.')

return sys.exit(1)

# Split code and settings

try:

pytxcode, pytxsettings = pytxcode.rsplit('=>PYTHONTEX:SETTINGS#', 1)

except:

print('The .pytxcode file appears to have an outdated format or be invalid')

print('Run LaTeX to make sure the file is current')

return sys.exit(1)

# Prepare to process settings

#

# Create a dict for storing settings.

settings = {}

# Create a dict for storing Pygments settings.

# Each dict entry will itself be a dict.

pygments_settings = defaultdict(dict)

# Create a dict of processing functions, and generic processing functions

settings_func = dict()

def set_kv_data(k, v):

if v == 'true':

settings[k] = True

elif v == 'false':

settings[k] = False

else:

settings[k] = v

# Need a function for when assignment is only needed if not default value

def set_kv_temp_data_if_not_default(k, v):

if v != 'default':

if v == 'true':

temp_data[k] = True

elif v == 'false':

temp_data[k] = False

else:

temp_data[k] = v

def set_kv_data_fvextfile(k, v):

# Error checking on TeX side should be enough, but be careful anyway

try:

v = int(v)

except ValueError:

print('* PythonTeX error')

print(' Unable to parse package option fvextfile.')

return sys.exit(1)

if v < 0:

settings[k] = sys.maxsize

elif v == 0:

settings[k] = 1

print('* PythonTeX warning')

print(' Invalid value for package option fvextfile.')

temp_data['warnings'] += 1

else:

settings[k] = v

def set_kv_pygments(k, v):

family, lexer_opts, options = v.replace(' ','').split('|')

lexer = None

lex_dict = {}

opt_dict = {}

if lexer_opts:

for l in lexer_opts.split(','):

if '=' in l:

k, v = l.split('=', 1)

if k == 'lexer':

lexer = l

else:

lex_dict[k] = v

else:

lexer = l

if options:

for o in options.split(','):

if '=' in o:

k, v = o.split('=', 1)

if v in ('true', 'True'):

v = True

elif v in ('false', 'False'):

v = False

else:

k = option

v = True

opt_dict[k] = v

if family != ':GLOBAL':

if 'lexer' in pygments_settings[':GLOBAL']:

lexer = pygments_settings[':GLOBAL']['lexer']

lex_dict.update(pygments_settings[':GLOBAL']['lexer_options'])

opt_dict.update(pygments_settings[':GLOBAL']['formatter_options'])

if 'style' not in opt_dict:

opt_dict['style'] = 'default'

opt_dict['commandprefix'] = 'PYG' + opt_dict['style']

if lexer is not None:

pygments_settings[family]['lexer'] = lexer

pygments_settings[family]['lexer_options'] = lex_dict

pygments_settings[family]['formatter_options'] = opt_dict

settings_func['version'] = set_kv_data

settings_func['outputdir'] = set_kv_data

settings_func['workingdir'] = set_kv_data

settings_func['workingdirset'] = set_kv_data

settings_func['gobble'] = set_kv_data

settings_func['rerun'] = set_kv_temp_data_if_not_default

settings_func['hashdependencies'] = set_kv_temp_data_if_not_default

settings_func['makestderr'] = set_kv_data

settings_func['stderrfilename'] = set_kv_data

settings_func['keeptemps'] = set_kv_data

settings_func['pyfuture'] = set_kv_data

settings_func['pyconfuture'] = set_kv_data

settings_func['pygments'] = set_kv_data

settings_func['fvextfile'] = set_kv_data_fvextfile

settings_func['pygglobal'] = set_kv_pygments

settings_func['pygfamily'] = set_kv_pygments

settings_func['pyconbanner'] = set_kv_data

settings_func['pyconfilename'] = set_kv_data

settings_func['depythontex'] = set_kv_data

# Process settings

for line in pytxsettings.split('\n'):

if line:

key, val = line.split('=', 1)

try:

settings_func[key](key, val)

except KeyError:

print('* PythonTeX warning')

print(' Unknown option "' + key + '"')

temp_data['warnings'] += 1

# Check for compatility between the .pytxcode and the script

if 'version' not in settings or settings['version'] != data['version']:

print('* PythonTeX error')

print(' The version of the PythonTeX scripts does not match the last code')

print(' saved by the document--run LaTeX to create an updated version.\n')

sys.exit(1)

# Store all results that haven't already been stored.

data['settings'] = settings

data['pygments_settings'] = pygments_settings

# Create a tuple of vital quantities that invalidate old saved data

# Don't need to include outputdir, because if that changes, no old output

# fvextfile could be checked on a case-by-case basis, which would result

# in faster output, but that would involve a good bit of additional

# logic, which probably isn't worth it for a feature that will rarely be

# changed.

data['vitals'] = (data['version'], data['encoding'],

settings['gobble'], settings['fvextfile'])

# Create tuples of vital quantities

data['code_vitals'] = (settings['workingdir'], settings['keeptemps'],

settings['makestderr'], settings['stderrfilename'])

data['cons_vitals'] = (settings['workingdir'])

data['typeset_vitals'] = ()

# Pass any customizations to types

for k in engine_dict:

engine_dict[k].customize(pyfuture=settings['pyfuture'],

pyconfuture=settings['pyconfuture'],

pyconbanner=settings['pyconbanner'],

pyconfilename=settings['pyconfilename'])

# Store code

# Do this last, so that Pygments settings are available

if pytxcode.startswith('=>PYTHONTEX#'):

gobble = settings['gobble']

temp_data['pytxcode'] = [Pytxcode(c, gobble) for c in pytxcode.split('=>PYTHONTEX#')[1:]]

else:

'''

if (old['version'].startswith('v') and

not data['settings']['workingdirset'] and

data['settings']['outputdir'] != '.'):

old['compatibility'] = '0.13'

if 'compatibility' in old_data:

c = old_data['compatibility']

if (c == '0.13' and not data['settings']['workingdirset'] and

data['settings']['outputdir'] != '.'):

data['compatibility'] = c

data['settings']['workingdir'] = data['settings']['outputdir']

msg = '''

'''

# Create a string containing the name of the data file

pythontex_data_file = os.path.expanduser(os.path.normcase(os.path.join(data['settings']['outputdir'], 'pythontex_data.pkl')))

# Load the old data if it exists (read as binary pickle)

if os.path.isfile(pythontex_data_file):

f = open(pythontex_data_file, 'rb')

old = pickle.load(f)

f.close()

# Check for compabilility

if 'vitals' in old and data['vitals'] == old['vitals']:

temp_data['loaded_old_data'] = True

old_data.update(old)

do_upgrade_compatibility(data, old_data, temp_data)

else:

if 'version' in old and old['version'] != data['version']:

set_upgrade_compatibility(data, old, temp_data)

temp_data['loaded_old_data'] = False

# Clean up all old files

if 'files' in old:

for key in old['files']:

for f in old['files'][key]:

f = os.path.expanduser(os.path.normcase(f))

if os.path.isfile(f):

os.remove(f)

if 'pygments_files' in old:

for key in old['pygments_files']:

for f in old['pygments_files'][key]:

f = os.path.expanduser(os.path.normcase(f))

if os.path.isfile(f):

os.remove(f)

else:

temp_data['loaded_old_data'] = False

# Set the utilspath

# Assume that if the utils aren't in the same location as

# `pythontex.py`, then they are somewhere else on `sys.path` that

# will always be available (for example, installed as a Python module),

# and thus specifying a path isn't necessary.

if os.path.isfile(os.path.join(sys.path[0], 'pythontex_utils.py')):

# Need the path with forward slashes, so escaping isn't necessary

data['utilspath'] = sys.path[0].replace('\\', '/')

else:

hashdependencies = temp_data['hashdependencies']

if key not in old_data['dependencies']:

return False

else:

old_dep_hash_dict = old_data['dependencies'][key]

workingdir = data['settings']['workingdir']

for dep in old_dep_hash_dict.keys():

# We need to know if the path is relative (based off the

# working directory) or absolute. We can't use

# os.path.isabs() alone for determining the distinction,

# because we must take into account the possibility of an

# initial ~ (tilde) standing for the home directory.

dep_file = os.path.expanduser(os.path.normcase(dep))

if not os.path.isabs(dep_file):

dep_file = os.path.expanduser(os.path.normcase(os.path.join(workingdir, dep_file)))

if not os.path.isfile(dep_file):

print('* PythonTeX error')

print(' Cannot find dependency "' + dep + '"')

print(' It belongs to ' + key.replace('#', ':'))

print(' Relative paths to dependencies must be specified from the working directory.')

temp_data['errors'] += 1

# A removed dependency should trigger an error, but it

# shouldn't cause code to execute. Running the code

# again would just give more errors when it can't find

# the dependency. (There won't be issues when a

# dependency is added or removed, because that would

# involve modifying code, which would trigger

# re-execution.)

elif hashdependencies:

# Read and hash the file in binary. Opening in text mode

# would require an unnecessary decoding and encoding cycle.

f = open(dep_file, 'rb')

hasher = sha1()

h = hasher(f.read()).hexdigest()

f.close()

if h != old_dep_hash_dict[dep][1]:

return True

else:

mtime = os.path.getmtime(dep_file)

if mtime != old_dep_hash_dict[dep][0]:

return True

# #### Need to clean up arg passing here

if rerun == 'never':

if (hash != old_hash or modified_dependencies(key, data, old_data, temp_data)):

print('* PythonTeX warning')

print(' Session ' + key.replace('#', ':') + ' has rerun=never')

print(' But its code or dependencies have been modified')

temp_data['warnings'] += 1

return False

elif rerun == 'modified':

if (hash != old_hash or modified_dependencies(key, data, old_data, temp_data)):

return True

else:

return False

elif rerun == 'errors':

if (hash != old_hash or modified_dependencies(key, data, old_data, temp_data) or

old_exit_status[0] != 0):

return True

else:

return False

elif rerun == 'warnings':

if (hash != old_hash or modified_dependencies(key, data, old_data, temp_data) or

old_exit_status != (0, 0)):

return True

else:

return False

elif rerun == 'always':

'''

# Note that the PythonTeX information that accompanies code must be

# hashed in addition to the code itself; the code could stay the same,

# but its context or args could change, which might require that code be

# executed. All of the PythonTeX information is hashed except for the

# input line number. Context-dependent code is going too far if

# it depends on that.

# Create variables to more easily access parts of data

pytxcode = temp_data['pytxcode']

encoding = data['encoding']

loaded_old_data = temp_data['loaded_old_data']

rerun = temp_data['rerun']

pygments_settings = data['pygments_settings']

# Calculate cumulative hashes for all code that is executed

# Calculate individual hashes for all code that will be typeset

code_hasher = defaultdict(sha1)

cons_hasher = defaultdict(sha1)

cc_hasher = defaultdict(sha1)

typeset_hasher = defaultdict(sha1)

for c in pytxcode:

if c.is_code:

code_hasher[c.key_run].update(c.hashable_delims_run.encode(encoding))

code_encoded = c.code.encode(encoding)

code_hasher[c.key_run].update(code_encoded)

if c.is_typeset:

typeset_hasher[c.key_typeset].update(c.hashable_delims_typeset.encode(encoding))

typeset_hasher[c.key_typeset].update(code_encoded)

typeset_hasher[c.key_typeset].update(c.args_prettyprint.encode(encoding))

elif c.is_cons:

cons_hasher[c.key_run].update(c.hashable_delims_run.encode(encoding))

code_encoded = c.code.encode(encoding)

cons_hasher[c.key_run].update(code_encoded)

if c.is_typeset:

typeset_hasher[c.key_typeset].update(c.hashable_delims_typeset.encode(encoding))

typeset_hasher[c.key_typeset].update(code_encoded)

typeset_hasher[c.key_typeset].update(c.args_prettyprint.encode(encoding))

elif c.is_cc:

cc_hasher[c.cc_type].update(c.hashable_delims_run.encode(encoding))

cc_hasher[c.cc_type].update(c.code.encode(encoding))

elif c.is_typeset:

typeset_hasher[c.key_typeset].update(c.hashable_delims_typeset.encode(encoding))

typeset_hasher[c.key_typeset].update(c.code.encode(encoding))

typeset_hasher[c.key_typeset].update(c.args_prettyprint.encode(encoding))

# Store hashes

code_hash_dict = {}

for key in code_hasher:

family = key.split('#', 1)[0]

code_hash_dict[key] = (code_hasher[key].hexdigest(),

cc_hasher[family].hexdigest(),

engine_dict[family].get_hash())

data['code_hash_dict'] = code_hash_dict

cons_hash_dict = {}

for key in cons_hasher:

family = key.split('#', 1)[0]

cons_hash_dict[key] = (cons_hasher[key].hexdigest(),

cc_hasher[family].hexdigest(),

engine_dict[family].get_hash())

data['cons_hash_dict'] = cons_hash_dict

typeset_hash_dict = {}

for key in typeset_hasher:

typeset_hash_dict[key] = typeset_hasher[key].hexdigest()

data['typeset_hash_dict'] = typeset_hash_dict

# See what needs to be updated.

# In the process, copy over macros and files that may be reused.

code_update = {}

cons_update = {}

pygments_update = {}

macros = defaultdict(list)

files = defaultdict(list)

pygments_macros = {}

pygments_files = {}

typeset_cache = {}

dependencies = defaultdict(dict)

exit_status = {}

pygments_settings_changed = {}

if loaded_old_data:

old_macros = old_data['macros']

old_files = old_data['files']

old_pygments_macros = old_data['pygments_macros']

old_pygments_files = old_data['pygments_files']

old_typeset_cache = old_data['typeset_cache']

old_dependencies = old_data['dependencies']

old_exit_status = old_data['exit_status']

old_code_hash_dict = old_data['code_hash_dict']

old_cons_hash_dict = old_data['cons_hash_dict']

old_typeset_hash_dict = old_data['typeset_hash_dict']

old_pygments_settings = old_data['pygments_settings']

for s in pygments_settings:

if (s in old_pygments_settings and

pygments_settings[s] == old_pygments_settings[s]):

pygments_settings_changed[s] = False

else:

pygments_settings_changed[s] = True

# If old data was loaded (and thus is compatible) determine what has

# changed so that only

# modified code may be executed. Otherwise, execute everything.

# We don't have to worry about checking for changes in pyfuture, because

# custom code and default code are hashed. The treatment of keeptemps

# could be made more efficient (if changed to 'none', just delete old temp

# files rather than running everything again), but given that it is

# intended as a debugging aid, that probable isn't worth it.

# We don't have to worry about hashdependencies changing, because if it

# does the hashes won't match (file contents vs. mtime) and thus code will

# be re-executed.

if loaded_old_data and data['code_vitals'] == old_data['code_vitals']:

# Compare the hash values, and set which code needs to be run

for key in code_hash_dict:

if (key in old_code_hash_dict and

not should_rerun(code_hash_dict[key], old_code_hash_dict[key], old_exit_status[key], key, rerun, data, old_data, temp_data)):

code_update[key] = False

macros[key] = old_macros[key]

files[key] = old_files[key]

dependencies[key] = old_dependencies[key]

exit_status[key] = old_exit_status[key]

else:

code_update[key] = True

else:

for key in code_hash_dict:

code_update[key] = True

if loaded_old_data and data['cons_vitals'] == old_data['cons_vitals']:

# Compare the hash values, and set which code needs to be run

for key in cons_hash_dict:

if (key in old_cons_hash_dict and

not should_rerun(cons_hash_dict[key], old_cons_hash_dict[key], old_exit_status[key], key, rerun, data, old_data, temp_data)):

cons_update[key] = False

macros[key] = old_macros[key]

files[key] = old_files[key]

typeset_cache[key] = old_typeset_cache[key]

dependencies[key] = old_dependencies[key]

exit_status[key] = old_exit_status[key]

else:

cons_update[key] = True

else:

for key in cons_hash_dict:

cons_update[key] = True

if loaded_old_data and data['typeset_vitals'] == old_data['typeset_vitals']:

for key in typeset_hash_dict:

family = key.split('#', 1)[0]

if family in pygments_settings:

if (not pygments_settings_changed[family] and

key in old_typeset_hash_dict and

typeset_hash_dict[key] == old_typeset_hash_dict[key]):

pygments_update[key] = False

if key in old_pygments_macros:

pygments_macros[key] = old_pygments_macros[key]

if key in old_pygments_files:

pygments_files[key] = old_pygments_files[key]

else:

pygments_update[key] = True

else:

pygments_update[key] = False

# Make sure Pygments styles are up-to-date

pygments_style_list = list(get_all_styles())

if pygments_style_list != old_data['pygments_style_list']:

pygments_style_defs = {}

# Lazy import

from pygments.formatters import LatexFormatter

for s in pygments_style_list:

formatter = LatexFormatter(style=s, commandprefix='PYG'+s)

pygments_style_defs[s] = formatter.get_style_defs()

else:

pygments_style_defs = old_data['pygments_style_defs']

else:

for key in typeset_hash_dict:

family = key.split('#', 1)[0]

if family in pygments_settings:

pygments_update[key] = True

else:

pygments_update[key] = False

# Create Pygments styles

pygments_style_list = list(get_all_styles())

pygments_style_defs = {}

# Lazy import

from pygments.formatters import LatexFormatter

for s in pygments_style_list:

formatter = LatexFormatter(style=s, commandprefix='PYG'+s)

pygments_style_defs[s] = formatter.get_style_defs()

# Save to data

temp_data['code_update'] = code_update

temp_data['cons_update'] = cons_update

temp_data['pygments_update'] = pygments_update

data['macros'] = macros

data['files'] = files

data['pygments_macros'] = pygments_macros

data['pygments_style_list'] = pygments_style_list

data['pygments_style_defs'] = pygments_style_defs

data['pygments_files'] = pygments_files

data['typeset_cache'] = typeset_cache

data['dependencies'] = dependencies

data['exit_status'] = exit_status

# Clean up for code that will be run again, and for code that no longer

# exists.

if loaded_old_data:

# Take care of code files

for key in code_hash_dict:

if code_update[key] and key in old_files:

for f in old_files[key]:

f = os.path.expanduser(os.path.normcase(f))

if os.path.isfile(f):

os.remove(f)

for key in old_code_hash_dict:

if key not in code_hash_dict:

for f in old_files[key]:

f = os.path.expanduser(os.path.normcase(f))

if os.path.isfile(f):

os.remove(f)

# Take care of old console files

for key in cons_hash_dict:

if cons_update[key] and key in old_files:

for f in old_files[key]:

f = os.path.expanduser(os.path.normcase(f))

if os.path.isfile(f):

os.remove(f)

for key in old_cons_hash_dict:

if key not in cons_hash_dict:

for f in old_files[key]:

f = os.path.expanduser(os.path.normcase(f))

if os.path.isfile(f):

os.remove(f)

# Take care of old Pygments files

# The approach here is a little different since there isn't a

# Pygments-specific hash dict, but there is a Pygments-specific

# dict of lists of files.

for key in pygments_update:

if pygments_update[key] and key in old_pygments_files:

for f in old_pygments_files[key]:

f = os.path.expanduser(os.path.normcase(f))

if os.path.isfile(f):

os.remove(f)

for key in old_pygments_files:

if key not in pygments_update:

for f in old_pygments_files[key]:

f = os.path.expanduser(os.path.normcase(f))

if os.path.isfile(f):

'''

code_dict = defaultdict(list)

cc_dict_begin = defaultdict(list)

cc_dict_end = defaultdict(list)

cons_dict = defaultdict(list)

pygments_list = []

# Create variables to ease data access

encoding = data['encoding']

utilspath = data['utilspath']

outputdir = data['settings']['outputdir']

workingdir = data['settings']['workingdir']

pytxcode = temp_data['pytxcode']

code_update = temp_data['code_update']

cons_update = temp_data['cons_update']

pygments_update = temp_data['pygments_update']

files = data['files']

debug = temp_data['debug']

interactive = temp_data['interactive']

# Tweak the update dicts to work with debug command-line option.

# #### This should probably be refactored later, once the debug interface

# stabilizes

if debug is not None or interactive is not None:

if debug is not None:

arg = debug