core Package

core Package

bzr_version Module

format-code Module

leoApp Module

class leo.core.leoApp.IdleTimeManager

Bases: object

A singleton class to manage idle-time handling. This class handles all details of running code at idle time, including running ‘idle’ hooks.

Any code can call g.app.idleTimeManager.add_callback(callback) to cause the callback to be called at idle time forever.

add_callback(callback)

Add a callback to be called at every idle time.

on_idle(timer)

IdleTimeManager: Run all idle-time callbacks.

on_idle_count = 0

start()

Start the idle-time timer.

class leo.core.leoApp.LeoApp

Bases: object

A class representing the Leo application itself.

Ivars of this class are Leo’s global variables.

checkForOpenFile(c, fn)

Warn if fn is already open and add fn to already_open_files list.

closeLeoWindow(frame, new_c=None, finish_quit=True)

Attempt to close a Leo window.

Return False if the user veto’s the close.

finish_quit - usually True, close Leo when last file closes, but

False when closing an already-open-elsewhere file during initial load, so UI remains for files further along the command line.

cmd()

Command decorator for the LeoApp class.

commanders()

Return list of currently active controllers

computeSignon()

createCursesGui(fileName='', verbose=False)

createDefaultGui(fileName='', verbose=False)

A convenience routines for plugins to create the default gui class.

createNullGuiWithScript(script=None)

createQtGui(fileName='', verbose=False)

A convenience routines for plugins to create the Qt gui class.

createTextGui(fileName='', verbose=False)

createWxGui(fileName='', verbose=False)

A convenience routines for plugins to create the wx gui class.

define_delegate_language_dict()

define_extension_dict()

define_global_constants()

define_language_delims_dict()

define_language_extension_dict()

destroyAllOpenWithFiles()

Remove temp files created with the Open With command.

destroyWindow(frame)

Destroy all ivars in a Leo frame.

finishQuit()

forceShutdown()

Forces an immediate shutdown of Leo at any time.

In particular, may be called from plugins during startup.

forgetOpenFile(fn, force=False)

Forget the open file, so that is no longer considered open.

init_at_auto_names()

Init the app.atAutoNames set.

init_at_file_names()

Init the app.atFileNames set.

listenToLog(event=None)

A socket listener, listening on localhost. See: https://docs.python.org/2/howto/logging-cookbook.html#sending-and-receiving-logging-events-across-a-network

Start this listener first, then start the broadcaster.

leo/plugins/cursesGui2.py is a typical broadcaster.

lockLog()

Disable changes to the log

makeAllBindings()

LeoApp.makeAllBindings:

Call c.k.makeAllBindings for all open commanders c.

newCommander(fileName, relativeFileName=None, gui=None, previousSettings=None)

Create a commander and its view frame for the Leo main window.

onQuit(event=None)

Exit Leo, prompting to save unsaved outlines first.

rememberOpenFile(fn)

runAlreadyOpenDialog(c)

Warn about possibly already-open files.

scanner_for_at_auto(c, p, **kwargs)

A factory returning a scanner function for p, an @auto node.

scanner_for_ext(c, ext, **kwargs)

A factory returning a scanner function for the given file extension.

selectLeoWindow(c)

setGlobalDb()

Create global pickleshare db

Usable by:

g.app.db['hello'] = [1,2,5]

setIDFile()

Create leoID.txt.

setIDFromEnv(verbose)

Set leoID from environment vars.

setIDFromFile(verbose)

Attempt to set g.app.leoID from leoID.txt.

setIDFromSys(verbose)

Attempt to set g.app.leoID from sys.leoID.

This might be set by in Python’s sitecustomize.py file.

setIdFromDialog()

Get leoID from a dialog.

setLeoID(useDialog=True, verbose=True)

Get g.app.leoID from various sources.

setLog(log)

set the frame to which log messages will go

unlockLog()

Enable changes to the log

writeWaitingLog(c)

Write all waiting lines to the log.

class leo.core.leoApp.LoadManager

Bases: object

A class to manage loading .leo files, including configuration files.

addOptionsToParser(parser)

adjustSysPath()

Adjust sys.path to enable imports as usual with Leo.

This method is no longer needed:

1. g.importModule will import from the ‘external’ or ‘extensions’ folders as needed without altering sys.path.
2. Plugins now do fully qualified imports.

checkForDuplicateShortcuts(c, d)

Check for duplicates in an “inverted” dictionary d whose keys are strokes and whose values are lists of BindingInfo nodes.

Duplicates happen only if panes conflict.

completeFileName(fileName)

computeBindingLetter(kind)

computeFilesList(options, fileName)

Return the list of files on the command line.

computeGlobalConfigDir()

computeHomeDir()

Returns the user’s home directory.

computeHomeLeoDir()

computeLeoDir()

computeLeoSettingsPath()

Return the full path to leoSettings.leo.

computeLoadDir()

Returns the directory containing leo.py.

computeLocalSettings(c, settings_d, bindings_d, localFlag)

Merge the settings dicts from c’s outline into new copies of settings_d and bindings_d.

computeMachineName()

Return the name of the current machine, i.e, HOSTNAME.

computeMyLeoSettingsPath()

Return the full path to myLeoSettings.leo.

The “footnote”: Get the local directory from lm.files[0]

computeStandardDirectories()

Compute the locations of standard directories and set the corresponding ivars.

computeThemeDirectories()

Return a list of existing directories that might contain theme .leo files.

computeThemeFilePath()

Return the absolute path to the theme .leo file.

computeWorkbookFileName()

Return the name of the workbook.

Return None only if: 1. The workbook does not exist. 2. We are unit testing or in batch mode.

createAllImporetersData()

New in Leo 5.5:

Create global data structures describing importers and writers.

createDefaultSettingsDicts()

Create lm.globalSettingsDict & lm.globalBindingsDict.

createGui(pymacs)

createImporterData()

Create the data structures describing importer plugins.

createMenu(c, fn=None)

createSettingsDicts(c, localFlag, theme=False)

createSpecialGui(gui, pymacs, script, windowFlag)

createWritersData()

Create the data structures describing writer plugins.

doDiff()

Support –diff option after loading Leo.

doGuiOption(options)

doLoadTypeOption(options)

doPostPluginsInit()

Create a Leo window for each file in the lm.files list.

doPrePluginsInit(fileName, pymacs)

Scan options, set directories and read settings.

doScreenShotOption(options)

doScriptOption(options, parser)

doSimpleOptions(options)

These args just set g.app ivars.

doWindowSizeOption(options)

findOpenFile(fn)

finishOpen(c)

getDefaultFile()

getPreviousSettings(fn)

Return the settings in effect for fn. Typically, this involves pre-reading fn.

initApp(verbose)

initFocusAndDraw(c, fileName)

initWrapperLeoFile(c, fn)

Create an empty file if the external fn is empty.

Otherwise, create an @edit or @file node for the external file.

invert(d)

Invert a shortcut dict whose keys are command names, returning a dict whose keys are strokes.

isLeoFile(fn)

isValidPython()

isZippedFile(fn)

load(fileName=None, pymacs=None)

Load the indicated file

loadLocalFile(fn, gui, old_c)

Completely read a file, creating the corresonding outline.

1. If fn is an existing .leo file (possibly zipped), read it twice: the first time with a NullGui to discover settings, the second time with the requested gui to create the outline.

2. If fn is an external file: get settings from the leoSettings.leo and myLeoSetting.leo, then create a “wrapper” outline continain an @file node for the external file.

3. If fn is empty: get settings from the leoSettings.leo and myLeoSetting.leo or default settings, or open an empty outline.

make_screen_shot(fn)

Create a screenshot of the present Leo outline and save it to path.

mergeShortcutsDicts(c, old_d, new_d, localFlag)

Create a new dict by overriding all shortcuts in old_d by shortcuts in new_d.

Both old_d and new_d remain unchanged.

openEmptyWorkBook()

Open an empty frame and paste the contents of CheatSheet.leo into it.

openFileByName(fn, gui, old_c, previousSettings)

Read the local file whose full path is fn using the given gui. fn may be a Leo file (including .leo or zipped file) or an external file.

This is not a pre-read: the previousSettings always exist and the commander created here persists until the user closes the outline.

Reads the entire outline if fn exists and is a .leo file or zipped file. Creates an empty outline if fn is a non-existent Leo file. Creates an wrapper outline if fn is an external file, existing or not.

openLeoFile(fn)

openLeoOrZipFile(fn)

openSettingsFile(fn)

Open a settings file with a null gui. Return the commander.

The caller must init the c.config object.

openZipFile(fn)

parse_importer_dict(sfn, m)

Set entries in g.app.classDispatchDict, g.app.atAutoDict and g.app.atAutoNames using entries in m.importer_dict.

parse_writer_dict(sfn, m)

Set entries in g.app.writersDispatchDict and g.app.atAutoWritersDict using entries in m.writers_dict.

readGlobalSettingsFiles()

Read leoSettings.leo and myLeoSettings.leo using a null gui.

readOpenedLeoFile(c, fn, readAtFileNodesFlag, theFile)

reportDirectories(verbose)

Report directories.

resolve_theme_path(fn, tag)

Search theme directories for the given .leo file.

revertCommander(c)

Revert c to the previously saved contents.

scanOptions(fileName, pymacs)

Handle all options, remove them from sys.argv and set lm.options.

setStdStreams()

Make sure that stdout and stderr exist. This is an issue when running Leo with pythonw.exe.

traceSettingsDict(d, verbose=False)

traceShortcutsDict(d, verbose=False)

uninvert(d)

Uninvert an inverted shortcut dict whose keys are strokes, returning a dict whose keys are command names.

class leo.core.leoApp.PreviousSettings(settingsDict, shortcutsDict)

Bases: object

A class holding the settings and shortcuts dictionaries that are computed in the first pass when loading local files and passed to the second pass.

class leo.core.leoApp.RecentFilesManager

Bases: object

A class to manipulate leoRecentFiles.txt.

appendToRecentFiles(files)

cleanRecentFiles(c)

Remove items from the recent files list that no longer exist.

This almost never does anything because Leo’s startup logic removes nonexistent files from the recent files list.

clearRecentFiles(c)

Clear the recent files list, then add the present file.

createRecentFiles()

Try to create .leoRecentFiles.txt, in the users home directory, or in Leo’s config directory if that fails.

createRecentFilesMenuItems(c)

demangleRecentFiles(c, data)

Rewrite recent files based on c.config.getData(‘path-demangle’)

editRecentFiles(c)

Dump recentFiles into new node appended as lastTopLevel, selects it and request focus in body.

NOTE: command write-edited-recent-files assume that headline of this node is not changed by user.

getRecentFiles()

getRecentFilesTable()

readRecentFiles(localConfigFile)

Read all .leoRecentFiles.txt files.

readRecentFilesFile(path)

sanitize(name)

Return a sanitized file name.

setRecentFiles(files)

Update the recent files list.

sortRecentFiles(c)

Sort the recent files list.

updateRecentFiles(fileName)

Create the RecentFiles menu. May be called with Null fileName.

writeEditedRecentFiles(c)

Write content of “edit_headline” node as recentFiles and recreates menues.

writeRecentFilesFile(c, force=False)

Write the appropriate .leoRecentFiles.txt file.

Write a message if force is True, or if it hasn’t been written yet.

writeRecentFilesFileHelper(fileName)

leo.core.leoApp.ctrlClickAtCursor(event)

Simulate a control-click at the cursor.

leo.core.leoApp.demangle_recent_files_command(event)

Path demangling potentially alters the paths in the recent files list according to find/replace patterns in the @data path-demangle setting. For example:

REPLACE: .gnome-desktop WITH: My Desktop

The default setting specifies no patterns.

leo.core.leoApp.disable_idle_time_events(event)

Disable default idle-time event handling.

leo.core.leoApp.enable_idle_time_events(event)

Enable default idle-time event handling.

leo.core.leoApp.join_leo_irc(event=None)

Open the web page to Leo’s irc channel on freenode.net.

leo.core.leoApp.openUrl(event=None)

Open the url in the headline or body text of the selected node.

Use the headline if it contains a valid url. Otherwise, look only at the first line of the body.

leo.core.leoApp.openUrlUnderCursor(event=None)

Open the url under the cursor.

leo.core.leoApp.toggle_idle_time_events(event)

Toggle default idle-time event handling.

leoAtFile Module

Classes to read and write @file nodes.

class leo.core.leoAtFile.AtFile(c)

Bases: object

A class implementing the atFile subcommander.

adjustTargetLanguage(fn)

Use the language implied by fn’s extension if there is a conflict between it and c.target_language.

allDirective = 2

appendToDocPart(s)

Append the next line of the @doc part to docOut.

appendToOut(s)

Append s to at.out (old sentinels) or at.v.tempBodyList (new sentinels).

asisWrite(root, toString=False)

atDirective = 4

at_directive_kind_pattern = <_sre.SRE_Pattern object>

autoBeautify(p)

Auto beautify p’s tree if allowed by settings and directives.

badEndSentinel(expectedKind)

Handle a mismatched ending sentinel.

bodyIsInited(v)

Return True if v.b has been inited.

bodySetInited(v)

Indicate that v.b has been inited.

cDirective = 6

changeLevel(oldLevel, newLevel)

Update data structures when changing node level.

The key invariant: on exit, the top of at.thinNodeStack is the new parent node.

checkDerivedFile(event=None)

Make sure an external file written by Leo may be read properly.

checkExternalFileAgainstDb(root)

Returns True if file is not modified since last save in db. Otherwise returns False.

checkPythonCode(root, s=None, targetFn=None, pyflakes_errors_only=False)

Perform python-related checks on root.

checkPythonSyntax(p, body, supress=False)

chmod(fileName, mode)

clearAllBodyInited()

Clear all v.b inited bits.

clearAllOrphanBits(p)

Clear orphan bits for all nodes except orphan @file nodes.

closeStringFile(theFile)

closeWriteFile()

cmd()

Command decorator for the AtFileCommands class.

codeDirective = 5

compareFiles(path1, path2, ignoreLineEndings, ignoreBlankLines=False)

Compare two text files.

completeFirstDirectives(out, firstLines)

14-SEP-2002 DTHEIN

Scans the lines in the list ‘out’ for @first directives, appending the corresponding line from ‘firstLines’ to each @first directive found.

NOTE: the @first directives must be the very first lines in ‘out’.

completeLastDirectives(out, lastLines)

14-SEP-2002 DTHEIN.

Scans the lines in the list ‘out’ for @last directives, appending the corresponding line from ‘lastLines’ to each @last directive found.

NOTE: the @last directives must be the very last lines in ‘out’.

completeRootNode(firstLines, lastLines, root)

Terminate the root’s body text, handling @first and @last.

create(fn, s)

Create a file whose contents are s.

createImportedNode(root, headline)

createNewThinNode(gnx, headline, level)

Create a new (new-style) vnode.

createResurrectedNodesNode()

Create a ‘Resurrected Nodes’ node as the last top-level node.

createV5ThinNode(gnx, headline, level)

Create a version 5 vnode.

defineDispatchDict()

Return the dispatch dictionary used by scanText4.

defineResurrectedNodeCallback(r, root)

Define a callback that moves node p as r’s last child.

deleteAllTempBodyStrings()

Delete all temp attributes.

deleteTnodeList(p)

Remove p’s tnodeList.

deleteUnvisitedNodes(root, redraw=True)

Delete unvisited nodes in root’s subtree, not including root.

Before Leo 5.6: Move unvisited node to be children of the ‘Resurrected Nodes’.

directiveKind4(s, i)

Return the kind of at-directive or noDirective.

dispatch(ext, p)

Return the correct writer function for p, an @auto node.

docDirective = 3

dump(lines, tag)

Dump all lines.

endAll = 70

endAt = 21

endBody = 22

endDoc = 24

endLeo = 25

endMiddle = 71

endNode = 26

endOthers = 27

endRawDirective = 10

endRef = 84

ensureTrailingNewline(s)

Ensure a trailing newline in s. If we add a trailing newline, we’ll generate an @nonl sentinel below.

• We always ensure a newline in @file and @thin trees.
• This code is not used used in @asis trees.
• New in Leo 4.4.3 b1: We add a newline in @clean/@nosent trees unless @bool force_newlines_in_at_nosent_bodies = False

error(*args)

exception(message)

findChild4(headline)

Return the next VNode in at.root.tnodeList. Called only for legacy @file nodes.

tnodeLists are used only when reading @file (not @thin) nodes. tnodeLists compensate for not having gnx’s in derived files!

findReference(name, p)

Find a reference to name. Raise an error if not found.

findSectionName(s, i)

Return n1, n2 representing a section name. The section name, including brackes is s[n1:n2]

getEncodingFromHeader(fn, s)

Return the encoding given in the @+leo sentinel, if the sentinel is present, or the previous value of at.encoding otherwise.

getNodeHeadline(s, i)

Set headline to the rest of the line. Don’t strip leading whitespace.

getPathUa(p)

handleChangedNode(new_body, old_body, p, thinFile)

Set ancestor files dirty and support mod_labels plugin.

ignoreOldSentinel(s, unused_i)

Ignore an 3.x sentinel.

importAtShadowNode(fn, p)

indicateNodeChanged(old, new, postPass, v)

Add an entry to c.nodeConflictList. Called only from at.terminateBody.

initCommonIvars()

Init ivars common to both reading and writing.

The defaults set here may be changed later.

initFileName(fromString, importFileName, root)

Return the fileName to be used in messages.

initReadIvars(root, fileName, importFileName=None, perfectImportRoot=None, atShadow=False)

initReadLine(s)

Init the ivars so that at.readLine will read all of s.

initScanText4(p)

Init all ivars for at.scanText4().

initWriteIvars(root, targetFileName, atEdit=False, atShadow=False, forcePythonSentinels=False, nosentinels=False, toString=False)

isFileLike(s)

Return True if s has file-like sentinels.

isSectionName(s, i)

isSignificantTree(p)

Return True if p’s tree has a significant amount of information.

massageAtDocPart(s)

Compute the final @doc part when block comments are used.

miscDirective = 8

new_createThinChild4(gnxString, headline, n, parent)

Find or create a new vnode whose parent (also a vnode) is at.lastThinNode. This is called only for @thin trees.

noDirective = 1

noSentinel = 20

nodeSentinelText(p)

Return the text of a @+node or @-node sentinel for p.

oblank()

oblanks(n)

old_createThinChild4(gnxString, headline)

Find or create a new vnode whose parent (also a vnode) is at.lastThinNode. This is called only for @thin trees.

onl()

Write a newline to the output stream.

onl_sent()

Write a newline to the output stream, provided we are outputting sentinels.

openAtShadowFileForReading(fn)

Open an @shadow for reading and return shadow_fn.

openFileForReading(fromString=False)

Open the file given by at.root. This will be the private file for @shadow nodes.

openFileForWriting(root, fileName, toString)

openFileForWritingHelper(fileName)

Open the file and return True if all went well.

openFileHelper(fn)

Open a file, reporting all exceptions.

openForWrite(filename, wb='wb')

Open a file for writes, handling shadow files.

openStringFile(fn, encoding='utf-8')

os(s)

Write a string to the output stream.

All output produced by leoAtFile module goes here.

otabs(n)

othersDirective = 7

outputStringWithLineEndings(s)

parseLeoSentinel(s)

Parse the sentinel line s. If the sentinel is valid, set at.encoding, at.readVersion, at.readVersion5.

parseNodeSentinel(s, i, middle)

parseThinNodeSentinel(s, i)

parseUnderindentTag(s)

popSentinelStack(expectedKind)

Pop an entry from endSentinelStack and check it.

printError(*args)

Print an error message that may contain non-ascii characters.

promptForDangerousWrite(fileName, kind, message=None)

Raise a dialog asking the user whether to overwrite an existing file.

putAfterLastRef(s, start, delta)

Handle whatever follows the last ref of a line.

putAfterMiddleRef(s, delta)

Handle whatever follows a ref that is not the last ref of a line.

putAtAllBody(p)

Generate the body enclosed in sentinel lines.

putAtAllChild(p)

putAtAllLine(s, i, p)

Put the expansion of @all.

putAtFirstLines(s)

Write any @firstlines from string s. These lines are converted to @verbatim lines, so the read logic simply ignores lines preceding the @+leo sentinel.

putAtLastLines(s)

Write any @last lines from string s. These lines are converted to @verbatim lines, so the read logic simply ignores lines following the @-leo sentinel.

putAtOthersChild(p)

putAtOthersLine(s, i, p)

Put the expansion of @others.

putBlankDocLine()

putBody(p, fromString='')

Generate the body enclosed in sentinel lines. Return True if the body contains an @others line.

putBuffered(s)

Put s, converting all tabs to blanks as necessary.

putCloseNodeSentinel(p)

End a node.

putCodeLine(s, i)

Put a normal code line.

putDelims(directive, s, k)

Put an @delims directive.

putDirective(s, i)

Output a sentinel a directive or reference s.

It is important for PHP and other situations that @first and @last directives get translated to verbatim lines that do not include what follows the @first & @last directives.

putDocLine(s, i)

Handle one line of a doc part.

Output complete lines and split long lines and queue pending lines. Inserted newlines are always preceded by whitespace.

putEndDocLine()

Write the conclusion of a doc part.

putIndent(n, s='')

Put tabs and spaces corresponding to n spaces, assuming that we are at the start of a line.

Remove extra blanks if the line starts with the underindentEscapeString

putInitialComment()

putLeadInSentinel(s, i, j, delta)

Set at.leadingWs as needed for @+others and @+<< sentinels.

i points at the start of a line. j points at @others or a section reference. delta is the change in at.indent that is about to happen and hasn’t happened yet.

putLine(i, kind, p, s, status)

Put the line at s[i:] of the given kind, updating the status.

putOpenLeoSentinel(s)

Write @+leo sentinel.

putOpenNodeSentinel(p, inAtAll=False)

Write @+node sentinel for p.

putPending(split)

Write the pending part of a doc part.

We retain trailing whitespace iff the split flag is True.

putRefAt(name, ref, delta)

putRefLine(s, i, n1, n2, name, p)

Put a line containing one or more references.

putSentinel(s)

Write a sentinel whose text is s, applying the CWEB hack if needed.

putStartDocLine(s, i, kind)

Write the start of a doc part.

rawDirective = 9

read(root, importFileName=None, fromString=None, atShadow=False, force=False)

Read an @thin or @file tree.

readAfterRef(s, i)

Read an @afterref sentinel.

readAll(root, force=False)

Scan positions, looking for @<file> nodes to read.

readAtShadowNodes(p)

Read all @shadow nodes in the p’s tree.

readClone(s, i)

readComment(s, i)

Read an @comment sentinel.

readDelims(s, i)

Read an @delims sentinel.

readDirective(s, i)

Read an @@sentinel.

readEndAll(unused_s, unused_i)

Read an @-all sentinel.

readEndAt(unused_s, unused_i)

Read an @-at sentinel.

readEndDoc(unused_s, unused_i)

Read an @-doc sentinel.

readEndLeo(unused_s, unused_i)

Read an @-leo sentinel.

readEndMiddle(s, i)

Read an @-middle sentinel.

readEndNode(unused_s, unused_i, middle=False)

Handle old-style @-node sentinels. In the new scheme, only the post-pass terminates nodes.

readEndOthers(unused_s, unused_i)

Read an @-others sentinel.

readEndRef(unused_s, unused_i)

Read an @-<< sentinel.

readError(message)

readFileToUnicode(fn)

Carefully sets at.encoding, then uses at.encoding to convert the file to a unicode string. Calls at.initReadLine if all went well.

Sets at.encoding as follows: 1. Use the BOM, if present. This unambiguously determines the encoding. 2. Use the -encoding= field in the @+leo header, if present and valid. 3. Otherwise, uses existing value of at.encoding, which comes from:

1. An @encoding directive, found by at.scanAllDirectives.
2. The value of c.config.default_derived_file_encoding.

Returns the string, or None on failure.

This method is now part of the main @file read code. at.openFileForReading calls this method to read all @file nodes. Previously only at.scanHeaderForThin (import code) called this method.

readLastDocLine(tag)

Read the @c line that terminates the doc part. tag is @doc or @.

Not used when reading new sentinels.

readLine()

Read one line from file using the present encoding. Returns at.read_lines[at.read_i++]

readNl(s, i)

Handle an @nonl sentinel.

readNonl(s, i)

Handle an @nonl sentinel.

readNormalLine(s, i=0)

readOneAtAutoNode(fileName, p)

Read an @auto file into p. Return the new position.

readOneAtCleanNode(root)

Update the @clean/@nosent node at root.

readOneAtEditNode(fn, p)

readOneAtShadowNode(fn, p, force=False)

readOpenFile(root, fileName, deleteNodes=False)

Read an open derived file. Leo 4.5 and later can only read 4.x derived files.

readPostPass(root, thinFile)

Post-process all vnodes.

readRef(s, i)

Handle an @<< sentinel.

readStartAll(s, i)

Read an @+all sentinel.

readStartAt(s, i)

Read an @+at sentinel.

readStartDoc(s, i)

Read an @+doc sentinel.

readStartLeo(s, i)

Read an unexpected @+leo sentinel.

readStartMiddle(s, i)

Read an @+middle sentinel.

readStartNode(s, i, middle=False)

Read an @+node or @+middle sentinel. This will terminate the previous node.

readStartOthers(s, i)

Read an @+others sentinel.

readVerbatim(s, i)

Read an @verbatim sentinel.

read_at_clean_lines(fn)

Return all lines of the @clean/@nosent file at fn.

reloadSettings()

rememberReadPath(fn, p)

Remember the files that have been read and the full headline (@<file> type) that caused the read.

remove(fileName, verbose=True)

removeCommentDelims(p)

If the present @language/@comment settings do not specify a single-line comment we remove all block comment delims from h. This prevents headline text from interfering with the parsing of node sentinels.

rename(src, dst, mode=None, verbose=True)

Remove dst if it exists, then rename src to dst. Change the mode of the renamed file if mode is given. Return True if all went well.

replaceFileWithString(fn, s)

Replace the file with s if s is different from theFile’s contents.

Return True if theFile was changed.

This is used only by the @shadow logic.

replaceTargetFileIfDifferent(root, ignoreBlankLines=False)

Create target file as follows: 1. If target file does not exist, rename output file to target file. 2. If target file is identical to output file, remove the output file. 3. If target file is different from output file,

remove target file, then rename output file to be target file.

Return True if the original file was changed.

reportCorrection(old, new, v)

Debugging only. Report changed perfect import lines.

runPyflakes(root, pyflakes_errors_only)

Run pyflakes on the selected node.

saveOutlineIfPossible()

Save the outline if only persistence data nodes are dirty.

scanAllDirectives(p, forcePythonSentinels=False, importing=False, issuePathWarning=False, reading=False)

Scan p and p’s ancestors looking for directives, setting corresponding AtFile ivars.

scanFirstLines(firstLines)

Append all lines before the @+leo line to firstLines.

Empty lines are ignored because empty @first directives are ignored.

We can not call sentinelKind here because that depends on the comment delimiters we set here.

scanForClonedSibs(parent_v, v)

Scan the siblings of VNode v looking for clones of v. Return the number of cloned sibs and n where p is the n’th cloned sibling.

scanHeader(fileName, giveErrors=True)

Scan the @+leo sentinel.

Sets self.encoding, and self.start/endSentinelComment.

Returns (firstLines,new_df,isThinDerivedFile) where: firstLines contains all @first lines, new_df is True if we are reading a new-format derived file. isThinDerivedFile is True if the file is an @thin file.

scanHeaderForThin(fileName)

Return true if the derived file is a thin file.

This is a kludgy method used only by the import code.

scanText4(fileName, p, verbose=False)

Scan a 4.x derived file non-recursively.

sentinelDict = {'@+all': 72, '@+at': 41, '@+body': 42, '@+doc': 43, '@+leo': 44, '@+middle': 73, '@+node': 45, '@+others': 46, '@-all': 70, '@-at': 21, '@-body': 22, '@-doc': 24, '@-leo': 25, '@-middle': 71, '@-node': 26, '@-others': 27, '@afterref': 80, '@clone': 81, '@comment': 60, '@delims': 61, '@nl': 82, '@nonl': 83, '@verbatim': 64, '@verbatimAfterRef': 65}

sentinelKind4(s)

Return the kind of sentinel at s.

sentinelKind4_helper(s)

sentinelName(kind)

Returns the name of the sentinel for warnings..

setDirtyOrphanBits(root)

Setting the orphan and dirty flags tells Leo to write the tree. However, the dirty bits get cleared if we are called from the save command.

setPathUa(p, path)

setTargetFileName(root, toString)

Set the target file name for at.write.

shouldDeleteChildren(root, thinFile)

Return True if we should delete all children before a read.

shouldPromptForDangerousWrite(fn, p)

Return True if a prompt should be issued when writing p (an @<file> node) to fn.

silentWrite(root, toString=False)

skipIndent(s, i, width)

skipSentinelStart4(s, i)

Skip the start of a sentinel.

skipToEndSentinel(s, i)

Skip to the end of the sentinel line.

startAfterRef = 80

startAll = 72

startAt = 41

startBody = 42

startClone = 81

startComment = 60

startDelims = 61

startDirective = 62

startDoc = 43

startLeo = 44

startMiddle = 73

startNl = 82

startNode = 45

startNonl = 83

startOthers = 46

startRef = 63

startVerbatim = 64

startVerbatimAfterRef = 65

stat(fileName)

Return the access mode of named file, removing any setuid, setgid, and sticky bits.

syntaxError(p, body)

Report a syntax error.

tabNannyNode(p, body, suppress=False)

terminateBody(v, postPass=False)

Terminate scanning of body text for node v. Set v.b.

terminateNode(middle=False, postPass=True, v=None)

Set the body text of at.v, and issue warning if it has changed.

This is called as follows:

old sentinels: when handling a @-node sentinel. new sentinels: from the post-pass when v.tempBodyList exists.

validInAtOthers(p)

Return True if p should be included in the expansion of the @others directive in the body text of p’s parent.

warnAboutOrphandAndIgnoredNodes()

warnOnReadOnlyFile(fn)

write(root, kind='@unknown', nosentinels=False, toString=False)

Write a 4.x derived file. root is the position of an @<file> node.

writeAll(writeAtFileNodesFlag=False, writeDirtyAtFileNodesFlag=False, toString=False)

Write @file nodes in all or part of the outline

writeAllHelper(p, root, force, toString, writeAtFileNodesFlag, writtenFiles)

Write one file for the at.writeAll. Do not write @auto files unless p == root. This prevents the write-all command from needlessly updating the @persistence data, thereby annoyingly changing the .leo file.

writeAsisNode(p)

Write the p’s node to an @asis file.

writeAtAutoNodes(event=None)

Write all @auto nodes in the selected outline.

writeAtAutoNodesHelper(toString=False, writeDirtyOnly=True)

Write @auto nodes in the selected outline

writeAtShadowNodes(event=None)

Write all @shadow nodes in the selected outline.

writeAtShadowNodesHelper(toString=False, writeDirtyOnly=True)

Write @shadow nodes in the selected outline

writeDirtyAtAutoNodes(event=None)

Write all dirty @auto nodes in the selected outline.

writeDirtyAtShadowNodes(event=None)

Write all dirty @shadow nodes in the selected outline.

writeError(message=None)

Issue an error while writing an @<file> node.

writeException(root=None)

writeFromString(root, s, forcePythonSentinels=True, useSentinels=True)

Write a 4.x derived file from a string.

This is at.write specialized for scripting.

writeMissing(p, toString=False)

writeMissingNode(p)

writeOneAtAutoNode(p, force=False, toString=False, trialWrite=False)

Write p, an @auto node. File indices must have already been assigned.

writeOneAtEditNode(p, toString, force=False)

Write one @edit node.

writeOneAtShadowNode(p, toString, force)

Write p, an @shadow node. File indices must have already been assigned.

writeOpenFile(root, nosentinels=False, toString=False, fromString='')

Do all writes except asis writes.

write_at_clean_sentinels(root)

Return all lines of the @clean tree as if it were written as an @file node.

writer_for_at_auto(root)

A factory returning a writer function for the given kind of @auto directive.

writer_for_ext(ext)

A factory returning a writer function for the given file extension.

leo.core.leoAtFile.atFile

alias of leo.core.leoAtFile.AtFile

leoBridge Module

A module to allow full access to Leo commanders from outside Leo.

class leo.core.leoBridge.BridgeController(guiName, loadPlugins, readSettings, silent, tracePlugins, verbose)

Bases: object

Creates a way for host programs to access Leo.

adjustSysPath()

Adjust sys.path to enable imports as usual with Leo.

completeFileName(fileName)

createFrame(fileName)

Create a commander and frame for the given file. Create a new frame if the fileName is empty or non-exisent.

createGui()

globals()

Return a fully initialized leoGlobals module.

initLeo()

Init the Leo app to which this class gives access. This code is based on leo.run().

isOpen()

Return True if the bridge is open.

isValidPython()

openLeoFile(fileName)

Open a .leo file, or create a new Leo frame if no fileName is given.

reportDirectories()

leo.core.leoBridge.controller(gui='nullGui', loadPlugins=True, readSettings=True, silent=False, tracePlugins=False, verbose=False)

Create an singleton instance of a bridge controller.

leoBridgeTest Module

A module that runs unit tests with the leoBridge module.

All options come from sys.argv. See scan_options for the available options.

Important: Leo’s core does not use this module in any way.

leo.core.leoBridgeTest.main()

The main line of leoBridgeTest.py.

leo.core.leoBridgeTest.runUnitTests(c, g)

Run all the unit tests from the leoBridge.

leo.core.leoBridgeTest.scanOptions()

Handle all options and remove them from sys.argv.

leoCache Module

A module encapsulating Leo’s file caching

class leo.core.leoCache.Cacher(c=None)

Bases: object

A class that encapsulates all aspects of Leo’s file caching.

checkForChangedNodes(child_tuple, fileName, parent_v)

Update the outline described by child_tuple, including all descendants.

clearAllCaches()

Clear the Cachers only for all open windows. This is much safer than killing all db’s.

clearCache()

Clear the cache for the open window.

collectChangedNodes(root_v, aList, fileName)

Populates c.nodeConflictList with data about nodes that are going to change during recreation of outline from cached list.

commit(close=True)

createOutlineFromCacheList(parent_v, aList, fileName, top=True)

Create outline structure from recursive aList built by makeCacheList.

createOutlineFromCacheList2(parent_v, aList)

Create outline structure from recursive aList built by makeCacheList.

fastAddLastChild(fileName, gnxString, parent_v)

Create new VNode as last child of the receiver. If the gnx exists already, create a clone instead of new VNode.

fileKey(fileName, content, requireEncodedString=False)

Compute the hash of fileName and content. fileName may be unicode, content must be bytes (or plain string in Python 2.x).

getCachedGlobalFileRatios()

getCachedStringPosition()

getCachedWindowPositionDict(fn)

Return a dict containing window positions.

initFileDB(fn)

initGlobalDB()

makeCacheList(p)

Create a recursive list describing a tree for use by createOutlineFromCacheList.

readFile(fileName, root)

Read the file from the cache if possible. Return (s,ok,key)

reportIfNodeChanged(child_tuple, child_v, fileName, parent_v)

Schedule a recovered node if child_v is substantially different from an earlier version.

Issue a (rare) warning if two different files are involved.

save(fn, changeName)

setCachedGlobalsElement(fn)

setCachedStringPosition(str_pos)

test()

warning(s)

Print a warning message in red.

writeFile(p, fileKey)

Update the cache after reading the file.

class leo.core.leoCache.PickleShareDB(root)

Bases: object

The main ‘connection’ object for PickleShare database

clear(verbose=False)

get(key, default=None)

has_key(key)

items()

keys(globpat=None)

Return all keys in DB, or all keys matching a glob

uncache(*items)

Removes all, or specified items from cache

Use this after reading a large amount of large objects to free up memory, when you won’t be needing the objects for a while.

class leo.core.leoCache.SqlitePickleShare(root)

Bases: object

The main ‘connection’ object for SqlitePickleShare database

clear(verbose=False)

get(key, default=None)

has_key(key)

init_dbtables(conn)

items()

keys(globpat=None)

Return all keys in DB, or all keys matching a glob

reset_protocol_in_values()

uncache(*items)

not used in SqlitePickleShare

leoChapters Module

Classes that manage chapters in Leo’s core.

class leo.core.leoChapters.Chapter(c, chapterController, name)

Bases: object

A class representing the non-gui data of a single chapter.

chapterSelectHelper(w=None, selectEditor=True)

findEditorInChapter(p)

return w, an editor displaying position p.

findPositionInChapter(p1, strict=False)

Return a valid position p such that p.v == v.

findRootNode()

Return the @chapter node for this chapter.

positionIsInChapter(p)

select(w=None, selectEditor=True)

Restore chapter information and redraw the tree when a chapter is selected.

unselect()

Remember chapter info when a chapter is about to be unselected.

class leo.core.leoChapters.ChapterController(c)

Bases: object

A per-commander controller that manages chapters and related nodes.

backChapter(event=None)

cmd()

Command decorator for the ChapterController class.

createIcon()

Create chapter-selection Qt ListBox in the icon area.

error(s)

findAnyChapterNode()

Return True if the outline contains any @chapter node.

findChapterNameForPosition(p)

Return the name of a chapter containing p or None if p does not exist.

findChapterNode(name)

Return the position of the first @chapter node with the given name anywhere in the entire outline.

All @chapter nodes are created as children of the @chapters node, but users may move them anywhere.

finishCreate()

Create the box in the icon area.

getChapter(name)

getSelectedChapter()

inChapter()

makeCommand(chapterName, binding=None)

Make chapter-select-<chapterName> command.

nextChapter(event=None)

note(s, killUnitTest=False)

parseHeadline(p)

Return the chapter name and key binding for p.h.

reloadSettings()

sanitize(s)

Convert s to a safe chapter name.

selectChapter(event=None)

Use the minibuffer to get a chapter name, then create the chapter.

selectChapter1(event)

selectChapterByName(name, collapse=True)

Select a chapter. Return True if a redraw is needed.

selectChapterByNameHelper(chapter, collapse=True)

Select the chapter, and redraw if necessary.

selectChapterForPosition(p, chapter=None)

Select a chapter containing position p. New in Leo 4.11: prefer the given chapter if possible. Do nothing if p if p does not exist or is in the presently selected chapter.

Note: this code calls c.redraw() if the chapter changes.

setAllChapterNames()

Called early and often to discover all chapter names.

warning(s)

leoColor Module

A color database for Leo.

leo_color_database is a dictionary of color names mapped onto the colors ‘#rrggbb’ representation.

The color names are derived from standard Linux color names which includes all Tk color names.

The names have been normalized by excluding spaces and removing capitalization. This should also be done for all new colors.

Accessor functions are provided which will normalize name requests before looking them up in the database.

These are:

getColor (aka: get)
getColorRGB (aka: getRGB)
getColorCairo (aka: getCairo)

Use these functions as follows:

import leo.core.leoColor as leoColor
leoColor.getRGB(name, default)

If neither ‘name’ nor ‘default’ can be translated then accessor functions will return None.

leo.core.leoColor.get(name, default=None)

Translate a named color into #rrggbb’ format.

if ‘name’ is not a string it is returned unchanged.

If ‘name’ is already in ‘#rrggbb’ format then it is returned unchanged.

If ‘name’ is not in global_color_database then getColor(default, None) is called and that result returned.

leo.core.leoColor.getCairo(name, default=None)

Convert a named color into a cairo color tuple.

leo.core.leoColor.getColor(name, default=None)

Translate a named color into #rrggbb’ format.

if ‘name’ is not a string it is returned unchanged.

If ‘name’ is already in ‘#rrggbb’ format then it is returned unchanged.

If ‘name’ is not in global_color_database then getColor(default, None) is called and that result returned.

leo.core.leoColor.getColorCairo(name, default=None)

Convert a named color into a cairo color tuple.

leo.core.leoColor.getColorRGB(name, default=None)

Convert a named color into an (r, g, b) tuple.

leo.core.leoColor.getRGB(name, default=None)

Convert a named color into an (r, g, b) tuple.

leoCommands Module

class leo.core.leoCommands.Commands(fileName, relativeFileName=None, gui=None, previousSettings=None)

Bases: object

A per-outline class that implements most of Leo’s commands. The “c” predefined object is an instance of this class.

c.initObjects() creates sucommanders corresponding to files in the leo/core and leo/commands. All of Leo’s core code is accessible via this class and its subcommanders.

g.app.pluginsController is Leo’s plugins controller. Many plugins inject controllers objects into the Commands class. These are another kind of subcommander.

The @g..commander_command decorator injects methods into this class.

BeginUpdate()

Deprecated: does nothing.

BringToFront(c2=None, set_focus=True)

EndUpdate(flag=True)

Request a redraw of the screen if flag is True.

add_command(menu, **keys)

alert(message)

allNodes_iter()

A generator return all positions of the outline, in outline order.

all_nodes()

A generator returning all vnodes in the outline, in outline order.

all_positions()

A generator return all positions of the outline, in outline order.

all_positions_iter()

A generator return all positions of the outline, in outline order.

all_positions_with_unique_tnodes_iter()

A generator return all positions of the outline, in outline order. Returns only the first position for each vnode.

all_positions_with_unique_vnodes_iter()

A generator return all positions of the outline, in outline order. Returns only the first position for each vnode.

all_roots(predicate=None)

A generator yielding all the root positions in the outline that satisfy the given predicate. p.isAnyAtFileNode is the default predicate.

The generator yields all root anywhere in the outline that satisfy the predicate. Once a root is found, the generator skips its subtree.

all_tnodes_iter()

A generator returning all vnodes in the outline, in outline order.

all_unique_nodes()

A generator returning each vnode of the outline.

all_unique_positions()

A generator return all positions of the outline, in outline order. Returns only the first position for each vnode.

all_unique_roots(predicate=None)

A generator yielding all unique root positions in the outline that satisfy the given predicate. p.isAnyAtFileNode is the default predicate.

The generator yields all root anywhere in the outline that satisfy the predicate. Once a root is found, the generator skips its subtree.

all_unique_tnodes_iter()

A generator returning each vnode of the outline.

all_unique_vnodes_iter()

A generator returning each vnode of the outline.

all_vnodes_iter()

A generator returning all vnodes in the outline, in outline order.

appendStringToBody(p, s)

backup(fileName=None, prefix=None, silent=False, useTimeStamp=True)

Back up given fileName or c.fileName(). If useTimeStamp is True, append a timestamp to the filename.

backup_helper(base_dir=None, env_key='LEO_BACKUP', sub_dir=None, use_git_prefix=True)

A helper for scripts that back up a .leo file. Use os.environ[env_key] as the base_dir only if base_dir is not given. Backup to base_dir or join(base_dir, sub_dir).

beginUpdate()

Deprecated: does nothing.

bodyWantsFocus()

bodyWantsFocusNow()

bringToFront(c2=None, set_focus=True)

canClone()

canContractAllHeadlines()

Contract all nodes in the tree.

canContractAllSubheads()

canContractParent()

canContractSubheads()

canCutOutline()

canDehoist()

Return True if do-hoist should be enabled in a menu. Should not be used in any other context.

canDeleteHeadline()

canDemote()

canExpandAllHeadlines()

Return True if the Expand All Nodes menu item should be enabled.

canExpandAllSubheads()

canExpandSubheads()

canExtract()

canExtractSection()

canExtractSectionNames()

canFindMatchingBracket()

canGoToNextDirtyHeadline()

canGoToNextMarkedHeadline()

canHoist()

Return True if hoist should be enabled in a menu. Should not be used in any other context.

canMarkChangedHeadlines()

canMarkChangedRoots()

canMoveOutlineDown()

canMoveOutlineLeft()

canMoveOutlineRight()

canMoveOutlineUp()

canPasteOutline(s=None)

canPromote()

canRedo()

canSelectThreadBack()

canSelectThreadNext()

canSelectVisBack()

canSelectVisNext()

canShiftBodyLeft()

canShiftBodyRight()

canSortChildren()

canSortSiblings()

canUndo()

canUnmarkAll()

checkAllPythonCode(event=None, unittest=False, ignoreAtIgnore=True)

Check all nodes in the selected tree for syntax and tab errors.

checkBatchOperationsList(aList)

checkDrag(root, target)

Return False if target is any descendant of root.

checkFileTimeStamp(fn)

Return True if the file given by fn has not been changed since Leo read it or if the user agrees to overwrite it.

checkGnxs()

Check the consistency of all gnx’s and remove any tnodeLists. Reallocate gnx’s for duplicates or empty gnx’s. Return the number of structure_errors found.

checkLinks()

Check the consistency of all links in the outline.

checkMoveWithParentWithWarning(root, parent, warningFlag)

Return False if root or any of root’s descendents is a clone of parent or any of parents ancestors.

checkOutline(event=None, check_links=False)

Check for errors in the outline. Return the count of serious structure errors.

checkParentAndChildren(p)

Check consistency of parent and child data structures.

checkPythonCode(event=None, unittest=False, ignoreAtIgnore=True, suppressErrors=False, checkOnSave=False)

Check the selected tree for syntax and tab errors.

checkPythonNode(p, unittest=False, suppressErrors=False)

checkSiblings(p)

Check the consistency of next and back links.

checkThreadLinks(p)

Check consistency of threadNext & threadBack links.

check_event(event)

Check an event object.

clearAllMarked()

clearAllVisited()

clearMarked(p)

cloneFindByPredicate(generator, predicate, failMsg=None, flatten=False, iconPath=None, redraw=True, undoType=None)

Traverse the tree given using the generator, cloning all positions for which predicate(p) is True. Undoably move all clones to a new node, created as the last top-level node. Returns the newly-created node. Arguments:

generator, The generator used to traverse the tree. predicate, A function of one argument p returning true if p should be included. failMsg=None, Message given if nothing found. Default is no message. flatten=False, True: Move all node to be parents of the root node. iconPath=None, Full path to icon to attach to all matches. redraw=True, True: redraw the screen. undo_type=None, The undo/redo name shown in the Edit:Undo menu.

The default is ‘clone-find-predicate’

command_count = 0

computeWindowTitle(fileName)

Set the window title and fileName.

contractAllHeadlines(event=None, redrawFlag=True)

Contract all nodes in the outline.

contractSubtree(p)

createCloneFindPredicateRoot(flatten, undoType)

Create a root node for clone-find-predicate.

createCommandNames()

Create all entries in c.commandsDict. Do not clear c.commandsDict here.

createNodeFromExternalFile(fn)

Read the file into a node. Return None, indicating that c.open should set focus.

createNodeHierarchy(heads, parent=None, forcecreate=False)

Create the proper hierarchy of nodes with headlines defined in ‘heads’ under ‘parent’

params: parent - parent node to start from. Set to None for top-level nodes heads - list of headlines in order to create, i.e. [‘foo’,’bar’,’baz’]

will create:

parent -foo –bar —baz

forcecreate - If False (default), will not create nodes unless they don’t exist

If True, will create nodes regardless of existing nodes

returns the final position (‘baz’ in the above example)

currentPosition()

Return a copy of the presently selected position or a new null position. So c.p.copy() is never necessary.

currentPositionHasNext()

Return True if the current position is the root position.

This method is called during idle time, so not generating positions here fixes a major leak.

currentPositionIsRootPosition()

Return True if the current position is the root position.

This method is called during idle time, so not generating positions here fixes a major leak.

currentVnode()

Return a copy of the presently selected position or a new null position. So c.p.copy() is never necessary.

deletePositionsInList(aList, callback=None, redraw=True)

Delete all vnodes corresponding to the positions in aList. If a callback is given, the callback is called for every node in the list.

The callback takes one explicit argument, p. As usual, the callback can bind values using keyword arguments.

This is very tricky code. The theory of operation section explains why.

diff_file(fn, rev1='HEAD', rev2='', directory=None)

Create an outline describing the git diffs for all files changed between rev1 and rev2.

diff_two_branches(branch1, branch2, fn, directory=None)

Create an outline describing the git diffs for all files changed between rev1 and rev2.

diff_two_revs(directory=None, rev1='', rev2='')

Create an outline describing the git diffs for all files changed between rev1 and rev2.

disable_redraw()

Disable all redrawing until enabled.

doBatchOperations(aList=None)

doCommand(command, label, event=None)

Execute the given command, invoking hooks and catching exceptions.

The code assumes that the “command1” hook has completely handled the command if g.doHook(“command1”) returns False. This provides a simple mechanism for overriding commands.

dragAfter(p, after)

dragCloneAfter(p, after)

dragCloneToNthChildOf(p, parent, n)

dragToNthChildOf(p, parent, n)

dumpPosition(p)

Dump position p and it’s ancestors.

edit_widget(p)

enable_redraw()

endEditing()

endUpdate(flag=True)

Request a redraw of the screen if flag is True.

executeAnyCommand(command, event)

Execute a command, no matter how defined.

Supports @g.commander_command and @g.new_cmd_decorator and plain methods.

executeMinibufferCommand(commandName)

executeScript(event=None, args=None, p=None, script=None, useSelectedText=True, define_g=True, define_name='__main__', silent=False, namespace=None, raiseFlag=False)

Execute a Leo script. Keyword args: args=None Not None: set script_args in the execution environment. p=None Get the script from p.b, unless script is given. script=None None: use script in p.b or c.p.b useSelectedText=True False: use all the text in p.b or c.p.b. define_g=True True: define g for the script. define_name=’__main__’ Not None: define the name symbol. silent=False No longer used. namespace=None Not None: execute the script in this namespace. raiseFlag=False True: reraise any exceptions.

executeScriptHelper(args, define_g, define_name, namespace, script)

expandAllAncestors(p)

Expand all ancestors without redrawing. Return a flag telling whether a redraw is needed.

expandSubtree(v)

expandToLevel(level)

fileName()

findNodeOutsideAnyAtFileTree(target)

Select the first clone of target that is outside any @file node.

findRootPosition()

Return the root position.

Root position is the first position in the document. Other top level positions are siblings of this node.

find_b(regex, flags=10)

Return list (a PosList) of all nodes whose body matches regex one or more times.

find_h(regex, flags=2)

Return list (a PosList) of all nodes where zero or more characters at the beginning of the headline match regex

finishCreate()

Finish creating the commander and all sub-objects. This is the last step in the startup process.

firstVisible()

Move to the first visible node of the present chapter or hoist.

force_redraw(p=None, setFocus=False)

Redraw the screen immediately.

getBodyLines(expandSelection=False)

Return head,lines,tail where:

before is string containg all the lines before the selected text (or the text before the insert point if no selection) lines is a list of lines containing the selected text (or the line containing the insert point if no selection) after is a string all lines after the selected text (or the text after the insert point if no selection)

getLanguageAtCursor(p, language)

Return the language in effect at the present insert point. Use the language argument as a default if no @language directive seen.

getNodeFileName(p)

Return the full file name at node p, including effects of all @path directives. Return None if p is no kind of @file node.

getNodePath(p)

Return the path in effect at node p.

getSelectedPositions()

Get list (PosList) of currently selected positions

So far only makes sense on qt gui (which supports multiselection)

getTabWidth(p)

Return the tab width in effect at p.

getTime(body=True)

get_focus()

get_requested_focus()

git_diff(rev1='HEAD', rev2='', directory=None)

goToLineNumber(n)

Go to line n (zero-based) of a script. A convenience method called from g.handleScriptException.

goToScriptLineNumber(n, p)

Go to line n (zero-based) of a script. A convenience method called from g.handleScriptException.

hasAmbiguousLanguage(p)

Return True if p.b contains different @language directives.

hash()

idle_focus_count = 0

idle_focus_helper(tag, keys)

An idle-tme handler that ensures that focus is somewhere.

initAfterLoad()

Provide an offical hook for late inits of the commander.

initCommandIvars()

Init ivars used while executing a command.

initConfigSettings()

Init all cached commander config settings.

initDebugIvars()

Init Commander debugging ivars.

initDocumentIvars()

Init per-document ivars.

initEventIvars()

Init ivars relating to gui events.

initFileIvars(fileName, relativeFileName)

Init file-related ivars of the commander.

initObjectIvars()

initObjects(gui)

initOptionsIvars()

Init Commander ivars corresponding to user options.

initSettings(previousSettings)

Init the settings before initing the objects.

init_error_dialogs()

initialFocusHelper()

interactive(callback, event, prompts)

c.interactive: Prompt for up to three arguments from the minibuffer.

The number of prompts determines the number of arguments.

Use the @command decorator to define commands. Examples:

@g.command(‘i3’) def i3_command(event):

c = event.get(‘c’) if not c: return

def callback(args, c, event):

g.trace(args) c.bodyWantsFocus()

c.interactive(callback, event,

prompts=[‘Arg1: ‘, ‘ Arg2: ‘, ‘ Arg3: ‘])

interactive1(callback, event, prompts)

interactive2(callback, event, prompts)

interactive3(callback, event, prompts)

invalidateFocus()

Indicate that the focus is in an invalid location, or is unknown.

isChanged()

isCurrentPosition(p)

isRootPosition(p)

is_unusual_focus(w)

Return True if w is not in an expected place.

lastTopLevel()

Return the last top-level position in the outline.

lastVisible()

Move to the last visible node of the present chapter or hoist.

last_unusual_focus = None

logWantsFocus()

logWantsFocusNow()

looksLikeDerivedFile(fn)

Return True if fn names a file that looks like an external file written by Leo.

markAllAtFileNodesDirty(event=None)

Mark all @file nodes as changed.

markAtFileNodesDirty(event=None)

Mark all @file nodes in the selected tree as changed.

minibufferWantsFocus()

minibufferWantsFocusNow()

navHelper(p, ch, extend)

navQuickKey()

return true if there are two quick outline navigation keys in quick succession.

Returns False if @float outline_nav_extend_delay setting is 0.0 or unspecified.

notValidInBatchMode(commandName)

nullPosition()

New in Leo 5.5: Return None. Using empty positions masks problems in program logic.

In fact, there are no longer any calls to this method in Leo’s core.

onCanvasKey(event)

Navigate to the next headline starting with ch = event.char. If ch is uppercase, search all headlines; otherwise search only visible headlines. This is modelled on Windows explorer.

openWith(event=None, d=None)

This is not a command.

Handles the items in the Open With… menu.

See ExternalFilesController.open_with for details about d.

os_path_finalize(path, **keys)

os_path_finalize_join(*args, **keys)

outerUpdate()

Handle delayed focus requests and modified events.

p

commander current position property

positionExists(p, root=None, trace=False)

Return True if a position exists in c’s tree

printCommandsDict()

putHelpFor(s, short_title='')

Helper for various help commands.

raise_error_dialogs(kind='read')

Warn abouit read/write failures.

recolor(**kwargs)

recolorCommand(event=None)

Force a full recolor.

recolor_now(**kwargs)

recreateGnxDict()

Recreate the gnx dict prior to refreshing nodes from disk.

recursiveImport(dir_, kind, add_path=True, recursive=True, safe_at_file=True, theTypes=None)

Recursively import all python files in a directory and clean the results.

Parameters::

dir_ The root directory or file to import. kind One of (‘@clean’,’@edit’,’@file’,’@nosent’). add_path=True True: add a full @path directive to @<file> nodes. recursive=True True: recurse into subdirectories. safe_at_file=True True: produce @@file nodes instead of @file nodes. theTypes=None A list of file extensions to import.

None is equivalent to [‘.py’]

This method cleans imported files as follows:

• Replace backslashes with forward slashes in headlines.
• Remove empty nodes.
• Add @path directives that reduce the needed path specifiers in descendant nodes.
• Add @file to nodes or replace @file with @@file.

redirectScriptOutput()

redraw(p=None, setFocus=False)

Redraw the screen immediately.

redrawAndEdit(p, selectAll=False, selection=None, keepMinibuffer=False)

Redraw the screen and edit p’s headline.

redraw_after_contract(p=None, setFocus=False)

redraw_after_expand(p=None, setFocus=False)

redraw_after_head_changed()

Redraw the screen (if needed) when editing ends. This may be a do-nothing for some gui’s.

redraw_after_icons_changed()

Update the icon for the presently selected node

redraw_after_select(p)

Redraw the screen after node p has been selected.

redraw_later()

Ensure that c.redraw() will be called eventually.

c.outerUpdate will call c.redraw() only if no other code calls c.redraw().

redraw_now(p=None, setFocus=False)

Redraw the screen immediately.

registerReloadSettings(obj)

Enter object into c.configurables.

relativeFileName()

reloadConfigurableSettings()

Call all reloadSettings method in c.subcommanders, c.configurables and other known classes.

request_focus(w)

rootPosition()

Return the root position.

Root position is the first position in the document. Other top level positions are siblings of this node.

rootVnode()

Return the root position.

Root position is the first position in the document. Other top level positions are siblings of this node.

safe_all_positions()

A generator returning all positions of the outline. This generator does not assume that vnodes are never their own ancestors.

scanAllDirectives(p=None)

Scan p and ancestors for directives.

Returns a dict containing the results, including defaults.

scanAtPathDirectives(aList)

Scan aList for @path directives. Return a reasonable default if no @path directive is found.

scanAtRootDirectives(aList)

Scan aList for @root-code and @root-doc directives.

selectPosition(p, **kwargs)

Select a new position, redrawing the screen only if we must change chapters.

selectVnode(p, **kwargs)

Select a new position, redrawing the screen only if we must change chapters.

setBodyString(p, s)

setChanged(changedFlag=True, redrawFlag=True)

Set or clear the marker that indicates that the .leo file has been changed.

setCloneFindByPredicateIcon(iconPath, p)

Attach an icon to p.v.u.

setComplexCommand(commandName)

Make commandName the command to be executed by repeat-complex-command.

setCurrentDirectoryFromContext(p)

setCurrentPosition(p)

Set the presently selected position. For internal use only. Client code should use c.selectPosition instead.

setCurrentVnode(p)

Set the presently selected position. For internal use only. Client code should use c.selectPosition instead.

setFileTimeStamp(fn)

Update the timestamp for fn..

setHeadString(p, s)

Set the p’s headline and the corresponding tree widget to s.

This is used in by unit tests to restore the outline.

setLog()

setMarked(p)

setPositionAfterSort(sortChildren)

setRootPosition(unused_p=None)

Set c._rootPosition.

setRootVnode(v)

setTopPosition(p)

Set the root positioin.

setTopVnode(p)

Set the root positioin.

setWindowPosition()

set_focus(w, force=False)

shortFileName()

shortFilename()

shouldBeExpanded(p)

Return True if the node at position p should be expanded.

syntaxErrorDialog()

Warn about syntax errors in files.

tabNannyNode(p, headline, body, unittest=False, suppressErrors=False)

Check indentation using tabnanny.

topPosition()

Return the root position.

topVnode()

Return the root position.

traceFocus(w)

trace_idle_focus(w)

Trace the focus for w, minimizing chatter.

treeFocusHelper()

treeSelectHelper(p)

treeWantsFocus()

treeWantsFocusNow()

trimTrailingLines(p)

Trims trailing blank lines from a node.

It is surprising difficult to do this during Untangle.

universalCallback(source_c, function)

Create a universal command callback.

Create and return a callback that wraps a function with an rClick signature in a callback which adapts standard minibufer command callbacks to a compatible format.

This also serves to allow rClick callback functions to handle minibuffer commands from sources other than rClick menus so allowing a single function to handle calls from all sources.

A function wrapped in this wrapper can handle rclick generator and invocation commands and commands typed in the minibuffer.

It will also be able to handle commands from the minibuffer even if rclick is not installed.

universallCallback(source_c, function)

Create a universal command callback.

Create and return a callback that wraps a function with an rClick signature in a callback which adapts standard minibufer command callbacks to a compatible format.

This also serves to allow rClick callback functions to handle minibuffer commands from sources other than rClick menus so allowing a single function to handle calls from all sources.

A function wrapped in this wrapper can handle rclick generator and invocation commands and commands typed in the minibuffer.

It will also be able to handle commands from the minibuffer even if rclick is not installed.

unredirectScriptOutput()

updateBodyPane(head, middle, tail, undoType, oldSel, oldYview, preserveSel=False)

Handle changed text in the body pane.

updateSyntaxColorer(v)

validateOutline(event=None)

visLimit()

Return the topmost visible node. This is affected by chapters and hoists.

vnode2allPositions(v)

Given a VNode v, find all valid positions p such that p.v = v.

Not really all, just all for each of v’s distinct immediate parents.

vnode2position(v)

Given a VNode v, construct a valid position p such that p.v = v.

widgetWantsFocus(w)

widgetWantsFocusNow(w)

widget_name(widget)

writeScriptFile(script)

leo.core.leoCommands.cmd(name)

Command decorator for the Commands class.

leoCompare Module

Leo’s base compare class.

class leo.core.leoCompare.BaseLeoCompare(commands=None, appendOutput=False, ignoreBlankLines=True, ignoreFirstLine1=False, ignoreFirstLine2=False, ignoreInteriorWhitespace=False, ignoreLeadingWhitespace=True, ignoreSentinelLines=False, limitCount=0, limitToExtension='.py', makeWhitespaceVisible=True, printBothMatches=False, printMatches=False, printMismatches=True, printTrailingMismatches=False, outputFileName=None)

Bases: object

The base class for Leo’s compare code.

compare_directories(path1, path2)

compare_files(name1, name2)

compare_lines(s1, s2)

compare_list_of_files(aList1)

compare_open_files(f1, f2, name1, name2)

compare_two_files(name1, name2)

A helper function.

doOpen(name)

dump(tag, s)

dumpToEndOfFile(tag, f, s, line, printTrailing)

filecmp(f1, f2)

isLeoHeader(s)

isSentinel(s, sentinelComment)

openOutputFile()

show(s)

showIvars()

class leo.core.leoCompare.CompareLeoOutlines(c)

Bases: object

A class to do outline-oriented diffs of two or more .leo files. Similar to GitDiffController, adapted for use by scripts.

compute_dicts(c1, c2)

Compute inserted, deleted, changed dictionaries.

create_compare_node(c1, c2, d, kind)

Create nodes describing the changes.

create_file_node(diff_list, fn1, fn2)

Create an organizer node for the file.

create_root(aList)

Create the top-level organizer node describing all the diffs.

diff_list_of_files(aList, visible=True)

The main entry point for scripts.

diff_two_files(fn1, fn2)

Create an outline describing the git diffs for fn.

find_gnx(c, gnx)

Return a position in c having the given gnx.

finish()

Finish execution of this command.

get_file(path)

Return the contents of the file whose path is given.

make_diff_outlines(c1, c2)

Create an outline-oriented diff from the outlines c1 and c2.

open_outline(fn)

Find the commander for fn, creating a new outline tab if necessary.

Using open commanders works because we always read entire .leo files.

class leo.core.leoCompare.LeoCompare(commands=None, appendOutput=False, ignoreBlankLines=True, ignoreFirstLine1=False, ignoreFirstLine2=False, ignoreInteriorWhitespace=False, ignoreLeadingWhitespace=True, ignoreSentinelLines=False, limitCount=0, limitToExtension='.py', makeWhitespaceVisible=True, printBothMatches=False, printMatches=False, printMismatches=True, printTrailingMismatches=False, outputFileName=None)

Bases: leo.core.leoCompare.BaseLeoCompare

A class containing Leo’s compare code.

These are not very useful comparisons.

leo.core.leoCompare.diffMarkedNodes(event)

When two or more nodes are marked, this command does the following:

• Creates a “diff marked node” as the last top-level node. The body of this node contains “diff n” nodes, one for each pair of compared nodes.
• Each diff n contains the diffs between the two diffed nodes, that is, difflib.Differ().compare(p1.b, p2.b). The children of the diff n are clones of the two compared nodes.

leo.core.leoCompare.diff_and_open_leo_files(event)

Open a dialog prompting for two or more .leo files.

Opens all the files and creates a top-level node in c’s outline showing the diffs of those files, two at a time.

leo.core.leoCompare.diff_leo_files(event)

Open a dialog prompting for two or more .leo files.

Creates a top-level node showing the diffs of those files, two at a time.

leo.core.leoCompare.diff_leo_files_helper(event, title, visible)

Prompt for a list of .leo files to open.

leo.core.leoCompare.go()

leoConfig Module

leoDebugger Module

Per-commander debugging class.

class leo.core.leoDebugger.leoDebugger(c)

Bases: pdb.Pdb

Leo’s debugger class: a thin wrapper around Python’s pdb class.

leo.core.leoDebugger.set_trace(c)

leoDynamicTest Module

A module to run unit tests with the leoBridge module. Leo’s unit test code uses this module when running unit tests externally.

leo.core.leoDynamicTest.main()

Run a dynamic test using the Leo bridge.

leo.core.leoDynamicTest.runUnitTests(c, g)

leo.core.leoDynamicTest.scanOptions()

Handle all options and remove them from sys.argv.

leoEditCommands Module

leoFileCommands Module

Classes relating to reading and writing .leo files.

exception leo.core.leoFileCommands.BadLeoFile(message)

Bases: exceptions.Exception

class leo.core.leoFileCommands.FileCommands(c)

Bases: object

A class creating the FileCommands subcommander.

archivedPositionToPosition(s)

assignFileIndices()

Assign a file index to all tnodes

bytes_to_unicode(ob)

recursively convert bytes objects in strings / lists / dicts to str objects, thanks to TNT http://stackoverflow.com/questions/22840092/unpickling-data-from-python-2-with-unicode-strings-in-python-3

Needed for reading Python 2.7 pickles in Python 3.4 in getSaxUa()

canonicalTnodeIndex(index)

Convert Tnnn to nnn, leaving gnx’s unchanged.

checkLeoFile(event=None)

The check-leo-file command.

checkPaste(parent, p)

Return True if p may be pasted as a child of parent.

cleanSaxInputString(s)

Clean control characters from s. s may be a bytes or a (unicode) string.

cmd()

Command decorator for the FileCommands class.

compactFileIndices()

Assign a file index to all tnodes

compute_attribute_bits(forceWrite, p)

Return the initial values of v’s attributes.

createActualFile(fileName, toOPML, toZip)

createBackupFile(fileName)

Create a closed backup file and copy the file to it, but only if the original file exists.

createSaxChildren(sax_node, parent_v)

Create vnodes for all children in sax_node.children.

createSaxVnode(sax_node, parent_v)

Create a vnode, or use an existing vnode.

createUaList(aList)

Given aList of pairs (p,torv), return a list of pairs (torv,d) where d contains all picklable items of torv.unknownAttributes.

decodePosition(s)

Creates position from its string representation encoded by fc.encodePosition.

deleteFileWithMessage(fileName, unused_kind)

dumpSaxTree(root, dummy)

encodePosition(p)

New schema for encoding current position hopefully simplier one.

exportDbVersion(conn)

exportGeomToSqlite(conn)

exportHashesToSqlite(conn)

exportToSqlite(fileName)

Dump all vnodes to sqlite database. Returns True on success.

exportVnodesToSqlite(conn, rows)

getDescendentAttributes(s, tag='')

s is a list of gnx’s, separated by commas from a <v> or <t> element. Parses s into a list.

This is used to record marked and expanded nodes.

getDescendentUnknownAttributes(s, v=None)

Unhexlify and unpickle t/v.descendentUnknownAttribute field.

getLeoFile(theFile, fileName, readAtFileNodesFlag=True, silent=False, checkOpenFiles=True)

Read a .leo file. The caller should follow this with a call to c.redraw().

getLeoFileHelper(theFile, fileName, silent)

Read the .leo file and create the outline.

getLeoOutline(s, reassignIndices=True)

Read a Leo outline from string s in clipboard format.

getLeoOutlineFromClipboard(s, reassignIndices=True)

Read a Leo outline from string s in clipboard format.

getPosFromClipboard(s)

getSaxUa(attr, val, kind=None)

Parse an unknown attribute in a <v> or <t> element. The unknown tag has been pickled and hexlify’d.

getVnodeFromClipboard(s)

getWindowGeometryFromDb(conn)

handleNodeConflicts()

Create a ‘Recovered Nodes’ node for each entry in c.nodeConflictList.

handleTnodeSaxAttributes(sax_node, v)

handleVnodeSaxAttributes(sax_node, v)

The native attributes of <v> elements are a, t, vtag, tnodeList, marks, expanded, and descendentTnode/VnodeUnknownAttributes.

handleWriteLeoFileException(fileName, backupName, theActualFile)

initIvars()

Init ivars of the FileCommands class.

initNewDb(conn)

Initializes tables and returns None

initReadIvars()

isReadOnly(fileName)

linkChildrenToParents(p)

Populate the parent links in all children of p.

openLeoFile(theFile, fileName, readAtFileNodesFlag=True, silent=False)

Open a Leo file.

parse_leo_file(theFile, inputFileName, silent, inClipboard, s=None)

pickle(torv, val, tag)

Pickle val and return the hexlified result.

prepareDbTables(conn)

propegateDirtyNodes()

put(s)

Put string s to self.outputFile. All output eventually comes here.

putClipboardHeader()

putDescendentAttributes(p)

putDescendentVnodeUas(p)

Return the a uA field for descendent VNode attributes, suitable for reconstituting uA’s for anonymous vnodes.

putFindSettings()

putGlobals()

putHeader()

putLeoFile()

putLeoOutline(p=None)

Return a string, not unicode, encoded with self.leo_file_encoding, suitable for pasting to the clipboard.

putPostlog()

putPrefs()

putProlog()

Put the prolog of the xml file.

putReferencedTnodes()

Put all referenced tnodes.

putSavedMessage(fileName)

putStyleSheetLine()

Put the xml stylesheet line.

Leo 5.3: - Use only the stylesheet setting, ignoreing c.frame.stylesheet. - Write no stylesheet element if there is no setting.

The old way made it almost impossible to delete stylesheet element.

putTnode(v)

putTnodes()

Puts all tnodes as required for copy or save commands

putUaHelper(torv, key, val)

Put attribute whose name is key and value is val to the output stream.

putUnknownAttributes(torv)

Put pickleable values for all keys in torv.unknownAttributes dictionary.

putVnode(p, isIgnore=False)

Write a <v> element corresponding to a VNode.

putVnodes(p=None)

Puts all <v> elements in the order in which they appear in the outline.

putXMLLine()

Put the properly encoded <?xml> element.

put_dquote()

put_dquoted_bool(b)

put_flag(a, b)

put_in_dquotes(a)

put_nl()

put_tab()

put_tabs(n)

readAtFileNodes()

readExternalFiles(fileName)

Read all external files.

readOutlineOnly(theFile, fileName)

readSaxFile(theFile, fileName, silent, inClipboard, reassignIndices, s=None)

Read the entire .leo file using the sax parser.

reassignAllIndices(p)

Reassign all indices in p’s subtree.

resolveArchivedPosition(archivedPosition, root_v)

Return a VNode corresponding to the archived position relative to root node root_v.

resolveTnodeLists()

Called before reading external files.

restoreDescendentAttributes()

retrieveVnodesFromDb(conn)

Recreates tree from the data contained in table vnodes. This method follows behavior of readSaxFile.

save(fileName, silent=False)

saveAs(fileName)

saveTo(fileName, silent=False)

save_ref()

Saves reference outline file

setDefaultDirectoryForNewFiles(fileName)

Set c.openDirectory for new files for the benefit of leoAtFile.scanAllDirectives.

setPositionsFromVnodes()

setReferenceFile(fileName)

updateFixedStatus()

updateFromRefFile()

Updates public part of outline from the specified file.

updateSaxClone(sax_node, parent_v, v)

Update the body text of v. It overrides any previous body text.

warnOnReadOnlyFiles(fileName)

writeAllAtFileNodesHelper()

Write all @<file> nodes and set orphan bits.

writeAtFileNodes(event=None)

Write all @file nodes in the selected outline.

writeAtShadowNodes(event=None)

Write all @file nodes in the selected outline.

writeDirtyAtFileNodes(event=None)

Write all changed @file Nodes.

writeDirtyAtShadowNodes(event=None)

Write all changed @shadow Nodes.

writeMissingAtFileNodes(event=None)

Write all @file nodes for which the corresponding external file does not exist.

writeOutlineOnly(event=None)

Write the entire outline without writing any derived files.

writeToFileHelper(fileName, toOPML)

writeToStringHelper(fileName)

writeZipFile(s)

write_LEO_file(fileName, outlineOnlyFlag, toString=False, toOPML=False)

Write the .leo file.

write_Leo_file(fileName, outlineOnlyFlag, toString=False, toOPML=False)

Write the .leo file.

exception leo.core.leoFileCommands.InvalidPaste

Bases: exceptions.Exception

class leo.core.leoFileCommands.SaxContentHandler(c, fileName, silent, inClipboard)

Bases: xml.sax.saxutils.XMLGenerator

A sax content handler class that reads Leo files.

attrsToList(attrs)

Convert the attributes to a list of g.Bunches.

attrs: an Attributes item passed to startElement.

attrsToString(attrs, sep='\n')

Convert the attributes to a string.

attrs: an Attributes item passed to startElement.

sep: the separator charater between attributes.

characters(content)

Handle the characters element.

clean(s)

endDocument()

endElement(name)

Handle the end of any xml element.

endElementNS(unused_name, unused_qname)

endTnode()

Handle the end of a <tnode> element.

endVH()

Handle the end of a <vh> element.

endVnode()

Handle the end of a <vnode> element.

error(message)

getRootNode()

getWindowPositionAttributes(attrs)

ignorableWhitespace(unused_whitespace)

inElement(name)

printStartElement(name, attrs)

processingInstruction(target, data)

sax: handle an xml processing instruction. We expect the target to be ‘xml-stylesheet’.

skippedEntity(name)

startDocument()

startElement(name, attrs)

startElementNS(unused_name, unused_qname, unused_attrs)

startGlobals(attrs)

startLeoHeader(unused_attrs)

startTnode(attrs)

startVH(unused_attrs)

startVnode(attrs)

startVnodes(unused_attrs)

startWinPos(attrs)

tnodeAttributes(attrs)

vnodeAttributes(attrs)

class leo.core.leoFileCommands.SaxNodeClass

A class representing one <v> element.

Use getters to access the attributes, properties and rules of this mode.

dump()

leoFind Module

Leo’s gui-independent find classes.

class leo.core.leoFind.LeoFind(c)

Bases: object

The base class for Leo’s Find commands.

abortSearch()

Restore the original position and selection.

addChangeStringToLabel()

Add an unprotected change string to the minibuffer label.

addFindStringToLabel(protect=True)

backwardsHelper(s, i, j, pattern, nocase, word)

batchChange(pos1, pos2)

Do a single batch change operation, updating the head or body string of p and leaving the result in s_ctrl.

s_ctrl contains the found text on entry and contains the changed text on exit. pos and pos2 indicate the selection. The selection will never be empty.

change(event=None)

changeAll()

changeAllButton(event=None)

Handle Replace All button.

changeAllCommand(event=None)

changeButton(event=None)

Handle Change button.

changeCommand(event=None)

Handle replace command.

changeSelection()

changeThenFind()

changeThenFindButton(event=None)

Handle Change, Then Find button.

changeThenFindCommand(event=None)

Handle the replace-then-find command.

checkArgs()

cloneFindAllCommand(event=None)

cloneFindAllFlattenedCommand(event=None)

cloneFindTag(tag)

Handle the clone-find-tag command.

cmd()

Command decorator for the findCommands class.

computeFindOptions()

Return the status line as two strings.

computeFindOptionsInStatusArea()

createCloneFindAllNodes(clones, flattened)

Create a “Found” node as the last node of the outline. Clone all positions in the clones set a children of found.

createCloneTagNodes(clones)

Create a “Found Tag” node as the last node of the outline. Clone all positions in the clones set as children of found.

createFindAllNode(result)

Create a “Found All” node as the last node of the outline.

createFindUniqueNode()

Create a “Found Unique” node as the last node of the outline.

debugIndices = []

doCloneFindAll(after, data, flatten, p, undoType)

Handle the clone-find-all command, from p to after.

doCloneFindAllHelper(clones, count, flatten, p, skip)

Handle the cff or cfa at node p.

doFindAll(after, data, p, undoType)

Handle the find-all command from p to after.

doWrap()

Return the position resulting from a wrap.

editWidget(event, forceFocus=True)

An override of baseEditCommands.editWidget that does not set focus when using anything other than the tk gui.

This prevents this class from caching an edit widget that is about to be deallocated.

endSearch()

escapeCommand(event)

Return the escaped command to execute.

findAll(clone_find_all=False, clone_find_all_flattened=False)

findAllButton(event=None)

Handle Find All button.

findAllCommand(event=None)

findButton(event=None)

Handle pressing the “Find” button in the find panel.

findDef(event=None)

Find the def or class under the cursor.

findDefHelper(event, defFlag)

Find the definition of the class, def or var under the cursor.

findEscapes()

Return the keystrokes corresponding to find-next & find-prev commands.

findNext(initFlag=True)

Find the next instance of the pattern.

findNextBatchMatch(p)

Find the next batch match at p.

findNextCommand(event=None)

The find-next command.

findNextMatch()

Resume the search where it left off.

findPrevCommand(event=None)

Handle F2 (find-previous)

findPreviousButton(event=None)

Handle the Find Previous button.

findVar(event=None)

Find the var under the cursor.

finishCreate()

firstSearchPane()

Set return the value of self.in_headline indicating which pane to search first.

focusInTree()

Return True is the focus widget w is anywhere in the tree pane.

Note: the focus may be in the find pane.

focusToFind(event=None)

generalChangeHelper(find_pattern, change_pattern, changeAll=False)

generalSearchHelper(pattern, cloneFindAll=False, cloneFindAllFlattened=False, findAll=False)

getFindResultStatus(find_all=False)

Return the status to be shown in the status line after a find command completes.

getStrokes(commandName)

helpForFindCommands(event=None)

Called from Find panel. Redirect.

hideFindTab(event=None)

Hide the Find tab.

iSearch(again=False)

Handle the actual incremental search.

iSearchBackspace()

iSearchStateHandler(event)

The state manager when the state is ‘isearch

initBatchCommands()

Init for find-all and replace-all commands.

initBatchText(ins=None)

Init s_ctrl from self.p and ins at the beginning of a search.

initFindDef(event)

Init the find-def command. Return the word to find or None.

initInHeadline()

Select the first pane to search for incremental searches and changes. This is called only at the start of each search. This must not alter the current insertion point or selection range.

initInteractiveCommands()

Init an interactive command. This is tricky!

Always start in the presently selected widget, provided that searching is enabled for that widget. Always start at the present insert point for the body pane. For headlines, start at beginning or end of the headline text.

initNextText(ins=None)

Init s_ctrl when a search fails. On entry: - self.in_headline indicates what text to use. - self.reverse indicates how to set the insertion point.

init_s_ctrl(s, ins)

Init the contents of s_ctrl from s and ins.

isearchBackward(event)

Begin a backward incremental search.

• Plain characters extend the search backward.
• !<isearch-forward>! repeats the search.
• Esc or any non-plain key ends the search.
• Backspace reverses the search.
• Backspacing to an empty search pattern completely undoes the effect of the search.

isearchBackwardRegexp(event)

Begin a backward incremental regexp search.

• Plain characters extend the search.
• !<isearch-forward-regexp>! repeats the search.
• Esc or any non-plain key ends the search.
• Backspace reverses the search.
• Backspacing to an empty search pattern completely undoes the effect of the search.

isearchForward(event)

Begin a forward incremental search.

• Plain characters extend the search.
• !<isearch-forward>! repeats the search.
• Esc or any non-plain key ends the search.
• Backspace reverses the search.
• Backspacing to an empty search pattern completely undoes the effect of the search.

isearchForwardRegexp(event)

Begin a forward incremental regexp search.

• Plain characters extend the search.
• !<isearch-forward-regexp>! repeats the search.
• Esc or any non-plain key ends the search.
• Backspace reverses the search.
• Backspacing to an empty search pattern completely undoes the effect of the search.

isearchWithPresentOptions(event)

Begin an incremental search using find panel options.

• Plain characters extend the search.
• !<isearch-forward-regexp>! repeats the search.
• Esc or any non-plain key ends the search.
• Backspace reverses the search.
• Backspacing to an empty search pattern completely undoes the effect of the search.

lastStateHelper()

makeRegexSubs(s, groups)

Carefully substitute group[i-1] for i strings in s. The group strings may contain i strings: they are not substituted.

matchWord(s, i, pattern)

Do a whole-word search.

minibufferCloneFindAll(event=None, preloaded=None)

clone-find-all ( aka find-clone-all and cfa).

Create an organizer node whose descendants contain clones of all nodes matching the search string, except @nosearch trees.

The list is not flattened: clones appear only once in the descendants of the organizer node.

minibufferCloneFindAll1(event)

minibufferCloneFindAllFlattened(event=None, preloaded=None)

clone-find-all-flattened (aka find-clone-all-flattened and cff).

Create an organizer node whose direct children are clones of all nodes matching the search string, except @nosearch trees.

The list is flattened: every cloned node appears as a direct child of the organizer node, even if the clone also is a descendant of another cloned node.

minibufferCloneFindAllFlattened1(event)

minibufferCloneFindTag(event=None)

clone-find-tag (aka find-clone-tag and cft).

Create an organizer node whose descendants contain clones of all nodes matching the given tag, except @nosearch trees.

The list is always flattened: every cloned node appears as a direct child of the organizer node, even if the clone also is a descendant of another cloned node.

minibufferCloneFindTag1(event)

minibufferFindAll(event=None)

Create a summary node containing descriptions of all matches of the search string.

minibufferFindAllUniqueRegex(event=None)

Create a summary node containing all unique matches of the regex search string. This command shows only the matched string itself.

minibufferReplaceAll(event=None)

Replace all instances of the search string with the replacement string.

minibufferTagChildren(event=None)

tag-children: prompt for a tag and add it to all children of c.p.

minibufferTagChildren1(event)

nextNodeAfterFail(p)

Return the next node after a failed search or None.

openFindTab(event=None, show=True)

Open the Find tab in the log pane.

outsideSearchRange(p)

Return True if the search is about to go outside its range, assuming both the headline and body text of the present node have been searched.

passedWrapPoint(p, pos, newpos)

Return True if the search has gone beyond the wrap point.

plainHelper(s, i, j, pattern, nocase, word)

Do a plain search.

pop()

precompilePattern()

Precompile the regexp pattern if necessary.

preloadFindPattern(w)

Preload the find pattern from the selected text of widget w.

printLine(line, allFlag=False)

push(p, i, j, in_headline)

reSearch1(event)

reSearchBackward(event)

reSearchForward(event)

regexHelper(s, i, j, pattern, backwards, nocase)

reloadSettings()

LeoFind.reloadSettings.

replace(event=None)

replaceBackSlashes(s)

Carefully replace backslashes in a search pattern.

resetWrap(event=None)

reset_state_ivars()

Reset ivars related to suboutline-only and wrapped searches.

restore(data)

Restore the screen and clear state after a search fails.

restoreAfterFindDef()

Restore find settings in effect before a find-def command.

restoreAllExpansionStates(expanded, redraw=False)

expanded is a set of gnx of nodes that should be expanded

returnToOrigin(event)

save()

Save everything needed to restore after a search fails.

saveBeforeFindDef(p)

Save the find settings in effect before a find-def command.

search()

Search s_ctrl for self.find_text with present options. Returns (pos, newpos) or (None,None).

search1(event)

searchBackward(event)

searchForward(event)

searchHelper(s, i, j, pattern)

Dispatch the proper search method based on settings.

searchWithPresentOptions(event, findAllFlag=False, findAllUniqueFlag=False, changeAllFlag=False)

Open the search pane and get the search string.

searchWithPresentOptions1(event)

setFindDefOptions(p)

Set the find options needed for the find-def command.

setFindScope(where)

Set the radio buttons to the given scope

setFindScopeEveryWhere(event=None)

Set the ‘Entire Outline’ radio button in the Find tab.

setFindScopeNodeOnly(event=None)

Set the ‘Node Only’ radio button in the Find tab.

setFindScopeSuboutlineOnly(event=None)

Set the ‘Suboutline Only’ radio button in the Find tab.

setReplaceString(event)

A state handler to get the replacement string.

setReplaceString1(event)

setReplaceString2(event)

setWidget()

setupArgs(forward=False, regexp=False, word=False)

Set up args for commands that force various values for commands (re-/word-/search-backward/forward) that force one or more of these values to be a spefic value.

setupChangePattern(pattern)

setupSearchPattern(pattern)

setup_button()

Init a search started by a button in the Find panel.

setup_command()

shouldStayInNode(p)

Return True if the find should simply switch panes.

showFindOptions(event=None)

Show the present find options in the status line. This is useful for commands like search-forward that do not show the Find Panel.

showFindOptionsInStatusArea()

Show find options in the status area.

showStatus(found)

Show the find status the Find dialog, if present, and the status line.

showSuccess(pos, newpos, showState=True)

Display the result of a successful find operation.

startIncremental(event, commandName, forward, ignoreCase, regexp)

startSearch(event)

stateZeroHelper(event, prefix, handler, escapes=None)

switchStyle(word)

Switch between camelCase and underscore_style function defintiions. Return None if there would be no change.

tagChildren(tag)

Handle the clone-find-tag command.

toggleFindCollapesNodes(event)

Toggle the ‘Collapse Nodes’ checkbox in the find tab.

toggleIgnoreCaseOption(event)

Toggle the ‘Ignore Case’ checkbox in the Find tab.

toggleMarkChangesOption(event)

Toggle the ‘Mark Changes’ checkbox in the Find tab.

toggleMarkFindsOption(event)

Toggle the ‘Mark Finds’ checkbox in the Find tab.

toggleOption(checkbox_name)

toggleRegexOption(event)

Toggle the ‘Regexp’ checkbox in the Find tab.

toggleSearchBodyOption(event)

Set the ‘Search Body’ checkbox in the Find tab.

toggleSearchHeadlineOption(event)

Toggle the ‘Search Headline’ checkbox in the Find tab.

toggleWholeWordOption(event)

Toggle the ‘Whole Word’ checkbox in the Find tab.

toggleWrapSearchOption(event)

Toggle the ‘Wrap Around’ checkbox in the Find tab.

updateChangeList(s)

updateFindList(s)

update_ivars()

Update ivars from the find panel.

wordSearch1(event)

wordSearchBackward(event)

wordSearchForward(event)

class leo.core.leoFind.SearchWidget(*args, **keys)

Bases: object

A class to simulating high-level interface widget.

delete(i, j=None)

getAllText()

getInsertPoint()

getSelectionRange()

insert(i, s)

setAllText(s)

setInsertPoint(i, s=None)

setSelectionRange(i, j, insert=None)

toPythonIndex(i)

leoFrame Module

leoGlobals Module

Global constants, variables and utility functions used throughout Leo.

Important: This module imports no other Leo module.

class leo.core.leoGlobals.BindingInfo(kind, commandName='', func=None, nextMode=None, pane=None, stroke=None)

Bases: object

A class representing any kind of key binding line.

This includes other information besides just the KeyStroke.

dump()

isModeBinding()

class leo.core.leoGlobals.Bunch(**keywords)

Bases: object

A class that represents a colection of things.

Especially useful for representing a collection of related variables.

get(key, theDefault=None)

ivars()

keys()

toString()

leo.core.leoGlobals.CheckVersion(s1, s2, condition='>=', stringCompare=None, delimiter='.', trace=False)

leo.core.leoGlobals.CheckVersionToInt(s)

class leo.core.leoGlobals.Command(name, **kwargs)

Bases: object

A global decorator for creating commands.

This is the recommended way of defining all new commands, including commands that could befined inside a class. The typical usage is:

@g.command(‘command-name’) def A_Command(event):

c = event.get(‘c’) …

g can not be used anywhere in this class!

class leo.core.leoGlobals.CommanderCommand(name, **kwargs)

Bases: object

A global decorator for creating commander commands, that is, commands that were formerly methods of the Commands class in leoCommands.py.

Usage:

@g.command(‘command-name’) def command_name(self, *args, **kwargs):

…

The decorator injects command_name into the Commander class and calls funcToMethod so the ivar will be injected in all future commanders.

g can not be used anywhere in this class!

class leo.core.leoGlobals.FileLikeObject(encoding='utf-8', fromString=None)

Bases: object

Define a file-like object for redirecting writes to a string.

The caller is responsible for handling newlines correctly.

clear()

close()

flush()

get()

getvalue()

read()

readline()

Read the next line using at.list and at.ptr.

write(s)

class leo.core.leoGlobals.GeneralSetting(kind, encoding=None, ivar=None, setting=None, val=None, path=None, tag='setting', unl=None)

Bases: object

A class representing any kind of setting except shortcuts.

dump()

x.__repr__() <==> repr(x)

class leo.core.leoGlobals.GitIssueController

Bases: object

A class encapsulating the retrieval of GitHub issues.

The GitHub api: https://developer.github.com/v3/issues/

backup_issues(base_url, c, label_list, root, state=None)

get_all_issues(label_list, root, state, limit=100)

Get all issues for the base url.

get_issues(base_url, label_list, milestone, root, state)

Create a list of issues for each label in label_list.

get_one_issue(label, state, limit=20)

Create a list of issues with the given label.

get_one_page(label, page, r, root)

print_header(r)

leo.core.leoGlobals.IdleTime(handler, delay=500, tag=None)

A thin wrapper for the LeoQtGui.IdleTime class.

The IdleTime class executes a handler with a given delay at idle time. The handler takes a single argument, the IdleTime instance:

def handler(timer):
    """IdleTime handler.  timer is an IdleTime instance."""
    delta_t = timer.time-timer.starting_time
    g.trace(timer.count, '%2.4f' % (delta_t))
    if timer.count >= 5:
        g.trace('done')
        timer.stop()

# Execute handler every 500 msec. at idle time.
timer = g.IdleTime(handler,delay=500)
if timer: timer.start()

Timer instances are completely independent:

def handler1(timer):
    delta_t = timer.time-timer.starting_time
    g.trace('%2s %2.4f' % (timer.count,delta_t))
    if timer.count >= 5:
        g.trace('done')
        timer.stop()

def handler2(timer):
    delta_t = timer.time-timer.starting_time
    g.trace('%2s %2.4f' % (timer.count,delta_t))
    if timer.count >= 10:
        g.trace('done')
        timer.stop()

timer1 = g.IdleTime(handler1,delay=500)
timer2 = g.IdleTime(handler2,delay=1000)
if timer1 and timer2:
    timer1.start()
    timer2.start()

class leo.core.leoGlobals.KeyStroke(binding)

Bases: object

A class that represent any key stroke or binding.

stroke.s is the “canonicalized” stroke.

dump()

Show results of printable chars.

finalize_binding(binding)

finalize_char(s)

Perform very-last-minute translations on bindings.

find(pattern)

find_mods(s)

Return the list of all modifiers seen in s.

isAltCtrl()

Return True if this is an Alt-Ctrl character.

isFKey()

isNumPadKey()

isPlainKey()

Return True if self.s represents a plain key.

A plain key is a key that can be inserted into text.

Note: The caller is responsible for handling Alt-Ctrl keys.

isPlainNumPad()

lower()

prettyPrint()

removeNumPadModifier()

startswith(s)

strip_mods(s)

Remove all modifiers from s, without changing the case of s.

strip_shift(s)

Handle supposedly shifted keys.

User settings might specify an already-shifted key, which is not an error.

The legacy Tk binding names have already been translated, so we don’t have to worry about Shift-ampersand, etc.

toGuiChar()

Replace special chars by the actual gui char.

toInsertableChar()

Convert self to an (insertable) char.

class leo.core.leoGlobals.MatchBrackets(c, p, language)

Bases: object

A class implementing the match-brackets command. In the interest of speed, the code assumes that the user invokes the match-bracket command ouside of any string, comment or (for perl or javascript) regex.

back_scan_comment(s, i)

Return the index of the character after a comment.

ends_comment(s, i)

Return True if s[i] ends a comment. This is called while scanning backward, so this is a bit of a guess.

expand_range(s, left, right, max_right, expand=False)

Find the bracket nearest the cursor searching outwards left and right.

Expand the range (left, right) in string s until either s[left] or s[right] is a bracket. right can not exceed max_right, and if expand is True, the new range must encompass the old range, in addition to s[left] or s[right] being a bracket.

Returns

new_left, new_right, bracket_char, index_of_bracket_char

if expansion succeeds, otherwise

None, None, None, None

Note that only one of new_left and new_right will necessarily be a bracket, but index_of_bracket_char will definitely be a bracket.

find_matching_bracket(ch1, s, i)

Find the bracket matching s[i] for self.language.

is_regex(s, i)

Return true if there is another slash on the line.

oops(s)

Report an error in the match-brackets command.

run()

The driver for the MatchBrackets class.

With no selected range, find the nearest bracket and select from it to it’s match, moving cursor to mathc. With selected range, the first time, move cursor back to other end of range. The second time, select enclosing range.

scan(ch1, target, s, i)

Scan forward for target.

scan_back(ch1, target, s, i)

Scan backwards for delim.

scan_comment(s, i)

Return the index of the character after a comment.

scan_regex(s, i)

Scan a regex (or regex substitution for perl).

scan_string(s, i)

Scan the string starting at s[i] (forward or backward). Return the index of the next character.

starts_comment(s, i)

Return True if s[i] starts a comment.

class leo.core.leoGlobals.NullObject(*args, **keys)

Bases: object

An object that does nothing, and does it very well. From the Python cookbook, recipe 5.23

class leo.core.leoGlobals.PosList(c, aList=None)

Bases: list

A subclass of list for creating and selecting lists of positions.

This is deprecated, use leoNodes.PosList instead!

aList = g.PosList(c)

# Creates a PosList containing all positions in c.

aList = g.PosList(c,aList2)

# Creates a PosList from aList2.

aList2 = aList.select(pattern,regex=False,removeClones=True)

# Creates a PosList containing all positions p in aList # such that p.h matches the pattern. # The pattern is a regular expression if regex is True. # if removeClones is True, all positions p2 are removed # if a position p is already in the list and p2.v == p.v.

aList.dump(sort=False,verbose=False)

# Prints all positions in aList, sorted if sort is True. # Prints p.h, or repr(p) if verbose is True.

dump(sort=False, verbose=False)

removeClones(aList)

select(pat, regex=False, removeClones=True)

Return a new PosList containing all positions in self that match the given pattern.

class leo.core.leoGlobals.ReadLinesClass(s)

Bases: object

A class whose next method provides a readline method for Python’s tokenize module.

next()

class leo.core.leoGlobals.RedirectClass

Bases: object

A class to redirect stdout and stderr to Leo’s log pane.

flush(*args)

isRedirected()

rawPrint(s)

redirect(stdout=1)

undirect(stdout=1)

write(s)

class leo.core.leoGlobals.SherlockTracer(patterns, dots=True, show_args=True, show_return=True, verbose=True)

Bases: object

A stand-alone tracer class with many of Sherlock’s features.

This class should work in any environment containing the re, os and sys modules.

The arguments in the pattern lists determine which functions get traced or which stats get printed. Each pattern starts with “+”, “-“, “+:” or “-:”, followed by a regular expression:

"+x"  Enables tracing (or stats) for all functions/methods whose name

matches the regular expression x.

“-x” Disables tracing for functions/methods. “+:x” Enables tracing for all functions in the file whose name matches x. “-:x” Disables tracing for an entire file.

Enabling and disabling depends on the order of arguments in the pattern list. Consider the arguments for the Rope trace:

patterns=[‘+.*’,’+:.*’,

‘-:.*lib.*’,’+:.*rope.*’,’-:.*leoGlobals.py’, ‘-:.*worder.py’,’-:.*prefs.py’,’-:.*resources.py’,])

This enables tracing for everything, then disables tracing for all library modules, except for all rope modules. Finally, it disables the tracing for Rope’s worder, prefs and resources modules. Btw, this is one of the best uses for regular expressions that I know of.

Being able to zero in on the code of interest can be a big help in studying other people’s code. This is a non-invasive method: no tracing code needs to be inserted anywhere.

bad_pattern(pattern)

Report a bad Sherlock pattern.

check_pattern(pattern)

Give an error and return False for an invalid pattern.

dispatch(frame, event, arg)

The dispatch method.

do_call(frame, unused_arg)

Trace through a function call.

do_line(frame, arg)

print each line of enabled functions.

do_return(frame, arg)

Trace a return statement.

fn_is_enabled(fn, patterns)

Return True if tracing for fn is enabled. Used only to enable statistics for fn.

format_ret(arg)

Format arg, the value returned by a “return” statement.

get_args(frame)

Return name=val for each arg in the function call.

get_full_name(locals_, name)

Return class_name::name if possible.

is_enabled(fn, name, patterns=None)

Return True if tracing for name in fn is enabled.

pop()

Restore the pushed patterns.

print_stats(patterns=None)

Print all accumulated statisitics.

push(patterns)

Push the old patterns and set the new.

run(frame=None)

Trace from the given frame or the caller’s frame.

set_patterns(patterns)

Set the patterns in effect.

show(item)

return the best representation of item.

stop()

Stop all tracing.

class leo.core.leoGlobals.Tracer(limit=0, trace=False, verbose=False)

Bases: object

A “debugger” that computes a call graph.

To trace a function and its callers, put the following at the function’s start:

g.startTracer()

computeName(frame)

report()

stop()

tracer(frame, event, arg)

A function to be passed to sys.settrace.

updateStats(name)

class leo.core.leoGlobals.TypedDict(name, keyType, valType)

Bases: object

A class containing a name and enforcing type checking.

add(key, val)

copy(name=None)

Return a new dict with the same contents.

dump()

get(key, default=None)

get_setting(key)

get_string_setting(key)

keys()

name()

replace(key, val)

setName(name)

update(d)

class leo.core.leoGlobals.TypedDictOfLists(name, keyType, valType)

Bases: leo.core.leoGlobals.TypedDict

A class whose values are lists of typed values.

copy(name=None)

Return a new dict with the same contents.

exception leo.core.leoGlobals.UiTypeException

Bases: exceptions.Exception

leo.core.leoGlobals.act_on_node(c, p, event)

leo.core.leoGlobals.actualColor(color)

Return the actual color corresponding to the requested color.

leo.core.leoGlobals.adjustTripleString(s, tab_width)

Remove leading indentation from a triple-quoted string.

This works around the fact that Leo nodes can’t represent underindented strings.

leo.core.leoGlobals.alert(message, c=None)

Raise an alert.

This method is deprecated: use c.alert instead.

leo.core.leoGlobals.angleBrackets(s)

leo.core.leoGlobals.assertUi(uitype)

leo.core.leoGlobals.assert_is(obj, list_or_class, warn=True)

leo.core.leoGlobals.backupGitIssues(c, base_url=None)

Get a list of issues from Leo’s GitHub site.

leo.core.leoGlobals.blue(*args, **keys)

leo.core.leoGlobals.bunch

alias of leo.core.leoGlobals.Bunch

leo.core.leoGlobals.callback(func)

A global decorator that protects Leo against crashes in callbacks.

This is the recommended way of defining all callback.

@g.callback def a_callback(…):

c = event.get(‘c’) …

leo.core.leoGlobals.caller(i=1)

Return the caller name i levels up the stack.

leo.core.leoGlobals.callers(n=4, count=0, excludeCaller=True, verbose=False)

Return a list containing the callers of the function that called g.callerList.

excludeCaller: True (the default), g.callers itself is not on the list.

If the verbose keyword is True, or the caller name is in the names list, return:

line N <file name> <class_name>.<caller_name> # methods line N <file name> <caller_name> # functions.

Otherwise, just return the <caller name>

leo.core.leoGlobals.cantImport(moduleName, pluginName=None, verbose=True)

Print a “Can’t Import” message and return None.

leo.core.leoGlobals.chdir(path)

leo.core.leoGlobals.checkOpenDirectory(c)

leo.core.leoGlobals.checkUnchangedIvars(obj, d, exceptions=None)

leo.core.leoGlobals.check_cmd_instance_dict(c, g)

Check g.check_cmd_instance_dict. This is a permanent unit test, called from c.finishCreate.

leo.core.leoGlobals.choose(cond, a, b)

(Deprecated) simulate “a if cond else b”

leo.core.leoGlobals.clearAllIvars(o)

Clear all ivars of o, a member of some class.

leo.core.leoGlobals.clearStats()

leo.core.leoGlobals.cls(event=None)

Clear the screen.

leo.core.leoGlobals.collectGarbage()

leo.core.leoGlobals.command

alias of leo.core.leoGlobals.Command

leo.core.leoGlobals.command_alias(alias, func)

Create an alias for the already defined method in the Commands class.

leo.core.leoGlobals.commander_command

alias of leo.core.leoGlobals.CommanderCommand

leo.core.leoGlobals.comment_delims_from_extension(filename)

Return the comment delims corresponding to the filename’s extension.

>>> import leo.core.leoGlobals as g
>>> g.comment_delims_from_extension(".py")
('#', '', '')

>>> g.comment_delims_from_extension(".c")
('//', '/*', '*/')

>>> g.comment_delims_from_extension(".html")
('', '<!--', '-->')

leo.core.leoGlobals.composeScript(c, p, s, forcePythonSentinels=True, useSentinels=True)

Compose a script from p.b.

leo.core.leoGlobals.computeBaseDir(c, base_dir, path_setting, trace=False)

Compute a base_directory. If given, @string path_setting takes precedence.

leo.core.leoGlobals.computeCommands(c, commands, command_setting, trace=False)

Get the list of commands. If given, @data command_setting takes precedence.

leo.core.leoGlobals.computeFileUrl(fn, c=None, p=None)

Compute finalized url for filename fn. This involves adding url escapes and evaluating Leo expressions.

leo.core.leoGlobals.computeGlobalConfigDir()

leo.core.leoGlobals.computeHomeDir()

leo.core.leoGlobals.computeLeadingWhitespace(width, tab_width)

leo.core.leoGlobals.computeLeadingWhitespaceWidth(s, tab_width)

leo.core.leoGlobals.computeLeoDir()

leo.core.leoGlobals.computeLoadDir()

leo.core.leoGlobals.computeMachineName()

leo.core.leoGlobals.computeStandardDirectories()

leo.core.leoGlobals.computeWidth(s, tab_width)

leo.core.leoGlobals.computeWindowTitle(fileName)

leo.core.leoGlobals.compute_directives_re()

Return an re pattern which word matches all Leo directives. Only g.get_directives_dict uses this pattern.

leo.core.leoGlobals.convertPythonIndexToRowCol(s, i)

Convert index i into string s into zero-based row/col indices.

leo.core.leoGlobals.convertRowColToPythonIndex(s, row, col, lines=None)

Convert zero-based row/col indices into a python index into string s.

leo.core.leoGlobals.createScratchCommander(fileName=None)

leo.core.leoGlobals.createTopologyList(c, root=None, useHeadlines=False)

Creates a list describing a node and all its descendents

leo.core.leoGlobals.create_temp_file(textMode=False)

Return a tuple (theFile,theFileName)

theFile: a file object open for writing. theFileName: the name of the temporary file.

leo.core.leoGlobals.defaultLeoFileExtension(c=None)

leo.core.leoGlobals.dictToString(d, indent='', tag=None)

Pretty print a Python dict to a string.

leo.core.leoGlobals.disableIdleTimeHook()

Disable the global idle-time hook.

leo.core.leoGlobals.doHook(tag, *args, **keywords)

This global function calls a hook routine. Hooks are identified by the tag param.

Returns the value returned by the hook routine, or None if the there is an exception.

We look for a hook routine in three places: 1. c.hookFunction 2. app.hookFunction 3. leoPlugins.doPlugins()

Set app.hookError on all exceptions. Scripts may reset app.hookError to try again.

leo.core.leoGlobals.doKeywordArgs(keys, d=None)

Return a result dict that is a copy of the keys dict with missing items replaced by defaults in d dict.

leo.core.leoGlobals.dummy_act_on_node(c, p, event)

leo.core.leoGlobals.dump(s)

leo.core.leoGlobals.dump_encoded_string(encoding, s)

Dump s, assumed to be an encoded string.

leo.core.leoGlobals.ecnl(tabName='Log')

leo.core.leoGlobals.ecnls(n, tabName='Log')

leo.core.leoGlobals.enableIdleTimeHook(*args, **keys)

Enable idle-time processing.

leo.core.leoGlobals.enable_gc_debug(event=None)

leo.core.leoGlobals.enl(tabName='Log')

leo.core.leoGlobals.ensureLeadingNewlines(s, n)

leo.core.leoGlobals.ensureTrailingNewlines(s, n)

leo.core.leoGlobals.ensure_extension(name, ext)

leo.core.leoGlobals.error(*args, **keys)

leo.core.leoGlobals.es(*args, **keys)

Put all non-keyword args to the log pane. The first, third, fifth, etc. arg translated by g.translateString. Supports color, comma, newline, spaces and tabName keyword arguments.

leo.core.leoGlobals.esDiffTime(message, start)

leo.core.leoGlobals.es_debug(*args, **keys)

Print all non-keyword args, and put them to the log pane in orange.

The first, third, fifth, etc. arg translated by g.translateString. Supports color, comma, newline, spaces and tabName keyword arguments.

leo.core.leoGlobals.es_dump(s, n=30, title=None)

leo.core.leoGlobals.es_error(*args, **keys)

leo.core.leoGlobals.es_event_exception(eventName, full=False)

leo.core.leoGlobals.es_exception(full=True, c=None, color='red')

leo.core.leoGlobals.es_exception_type(c=None, color='red')

leo.core.leoGlobals.es_print(*args, **keys)

Print all non-keyword args, and put them to the log pane.

The first, third, fifth, etc. arg translated by g.translateString. Supports color, comma, newline, spaces and tabName keyword arguments.

leo.core.leoGlobals.es_print_error(*args, **keys)

leo.core.leoGlobals.es_print_exception(full=True, c=None, color='red')

Print exception info about the last exception.

leo.core.leoGlobals.es_trace(*args, **keys)

leo.core.leoGlobals.escaped(s, i)

leo.core.leoGlobals.execGitCommand(command, directory=None)

Execute the given git command in the given directory.

leo.core.leoGlobals.exec_file(path, d, script=None)

Simulate python’s execfile statement for python 3.

leo.core.leoGlobals.executeFile(filename, options='')

leo.core.leoGlobals.executeScript(name)

Execute a script whose short python file name is given.

This is called only from the scripts_menu plugin.

leo.core.leoGlobals.execute_shell_commands(commands, trace=False)

Execute each shell command in a separate process. Wait for each command to complete, except those starting with ‘&’

leo.core.leoGlobals.execute_shell_commands_with_options(base_dir=None, c=None, command_setting=None, commands=None, path_setting=None, trace=False, warning=None)

A helper for prototype commands or any other code that runs programs in a separate process.

base_dir: Base directory to use if no config path given. commands: A list of commands, for g.execute_shell_commands. commands_setting: Name of @data setting for commands. path_setting: Name of @string setting for the base directory. warning: A warning to be printed before executing the commands.

leo.core.leoGlobals.extractExecutableString(c, p, s, language='python')

Return all lines for the given @language directive.

Ignore all lines under control of any other @language directive.

leo.core.leoGlobals.fileFilters(key)

leo.core.leoGlobals.fileLikeObject

alias of leo.core.leoGlobals.FileLikeObject

leo.core.leoGlobals.file_date(theFile, format=None)

leo.core.leoGlobals.findLanguageDirectives(c, p)

Return the language in effect at position p.

leo.core.leoGlobals.findNodeAnywhere(c, headline, exact=True)

leo.core.leoGlobals.findNodeInChildren(c, p, headline, exact=True)

Search for a node in v’s tree matching the given headline.

leo.core.leoGlobals.findNodeInTree(c, p, headline, exact=True)

Search for a node in v’s tree matching the given headline.

leo.core.leoGlobals.findReference(name, root)

Find the section definition for name.

If a search of the descendants fails, and an ancestor is an @root node, search all the descendants of the @root node.

leo.core.leoGlobals.findRootsWithPredicate(c, root, predicate=None)

Commands often want to find one or more roots, given a position p. A root is the position of any node matching a predicate.

This function formalizes the search order used by the pylint, pyflakes and the rst3 commands, returning a list of zero or more found roots.

leo.core.leoGlobals.findTabWidthDirectives(c, p)

Return the language in effect at position p.

leo.core.leoGlobals.findTestScript(c, h, where=None, warn=True)

leo.core.leoGlobals.findTopLevelNode(c, headline, exact=True)

leo.core.leoGlobals.find_line_start(s, i)

Return the index in s of the start of the line containing s[i].

leo.core.leoGlobals.find_on_line(s, i, pattern)

leo.core.leoGlobals.find_word(s, word, i=0)

Return the index of the first occurance of word in s, or -1 if not found.

g.find_word is not the same as s.find(i,word); g.find_word ensures that only word-matches are reported.

leo.core.leoGlobals.flatten_list(obj)

A generator yielding a flattened (concatenated) version of obj.

leo.core.leoGlobals.fullPath(c, p, simulate=False)

Return the full path (including fileName) in effect at p. Neither the path nor the fileName will be created if it does not exist.

leo.core.leoGlobals.funcToMethod(f, theClass, name=None)

From the Python Cookbook…

The following method allows you to add a function as a method of any class. That is, it converts the function to a method of the class. The method just added is available instantly to all existing instances of the class, and to all instances created in the future.

The function’s first argument should be self.

The newly created method has the same name as the function unless the optional name argument is supplied, in which case that name is used as the method name.

leo.core.leoGlobals.getBaseDirectory(c)

Convert ‘!’ or ‘.’ to proper directory references.

leo.core.leoGlobals.getDocString(s)

Return the text of the first docstring found in s.

leo.core.leoGlobals.getDocStringForFunction(func)

Return the docstring for a function that creates a Leo command.

leo.core.leoGlobals.getEncodingAt(p, s=None)

Return the encoding in effect at p and/or for string s.

Read logic: s is not None. Write logic: s is None.

leo.core.leoGlobals.getGitIssues(c, base_url=None, label_list=None, milestone=None, state=None)

Get a list of issues from Leo’s GitHub site.

leo.core.leoGlobals.getHandlersForTag(tags)

leo.core.leoGlobals.getIvarsDict(obj)

Return a dictionary of ivars:values for non-methods of obj.

leo.core.leoGlobals.getLanguageAtPosition(c, p)

Return the language in effect at position p. This is always a lowercase language name, never None.

leo.core.leoGlobals.getLanguageFromAncestorAtFileNode(p)

Return the language in effect as determined by the file extension of the nearest enclosing @<file> node.

leo.core.leoGlobals.getLastTracebackFileAndLineNumber()

leo.core.leoGlobals.getLine(s, i)

Return i,j such that s[i:j] is the line surrounding s[i]. s[i] is a newline only if the line is empty. s[j] is a newline unless there is no trailing newline.

leo.core.leoGlobals.getLineAfter(s, i)

leo.core.leoGlobals.getLoadedPlugins()

leo.core.leoGlobals.getOutputNewline(c=None, name=None)

Convert the name of a line ending to the line ending itself.

Priority: - Use name if name given - Use c.config.output_newline if c given, - Otherwise use g.app.config.output_newline.

leo.core.leoGlobals.getPluginModule(moduleName)

leo.core.leoGlobals.getPythonEncodingFromString(s)

Return the encoding given by Python’s encoding line. s is the entire file.

leo.core.leoGlobals.getScript(c, p, useSelectedText=True, forcePythonSentinels=True, useSentinels=True)

Return the expansion of the selected text of node p. Return the expansion of all of node p’s body text if p is not the current node or if there is no text selection.

leo.core.leoGlobals.getTestVars()

leo.core.leoGlobals.getTime()

leo.core.leoGlobals.getUrlFromNode(p)

Get an url from node p: 1. Use the headline if it contains a valid url. 2. Otherwise, look only at the first line of the body.

leo.core.leoGlobals.getWord(s, i)

Return i,j such that s[i:j] is the word surrounding s[i].

leo.core.leoGlobals.get_directives_dict(p, root=None)

Scan p for @directives found in globalDirectiveList.

Returns a dict containing the stripped remainder of the line following the first occurrence of each recognized directive

leo.core.leoGlobals.get_directives_dict_list(p)

Scans p and all its ancestors for directives.

Returns a list of dicts containing pointers to the start of each directive

leo.core.leoGlobals.get_leading_ws(s)

Returns the leading whitespace of ‘s’.

leo.core.leoGlobals.get_line(s, i)

leo.core.leoGlobals.get_line_after(s, i)

leo.core.leoGlobals.gitBranchName(path=None)

Return the git branch name associated with path/.git, or the empty string if path/.git does not exist. If path is None, use the leo-editor directory.

leo.core.leoGlobals.gitCommitNumber(path=None)

Return the git commit number associated with path/.git, or the empty string if path/.git does not exist. If path is None, use the leo-editor directory.

leo.core.leoGlobals.gitDescribe(path=None)

Return the Git tag, distance-from-tag, and commit hash for the associated path. If path is None, use the leo-editor directory.

Given git describe cmd line output: `x-leo-v5.6-55-ge1129da

`

This function returns (‘x-leo-v5.6’, ‘55’, ‘e1129da’)

leo.core.leoGlobals.gitHeadPath(path=None)

Compute the path to the .git/HEAD directory given the path to another directory. If no path is given, use the path to this file. This code can not use g.app.loadDir because it is called too early in Leo’s startup code.

leo.core.leoGlobals.gitInfo(path=None)

Path is a .git/HEAD directory, or None.

Return the branch and commit number or (‘’, ‘’).

leo.core.leoGlobals.glob_glob(pattern)

Return the regularized glob.glob(pattern)

leo.core.leoGlobals.goto_last_exception(c)

Go to the line given by sys.last_traceback.

leo.core.leoGlobals.guessExternalEditor(c=None)

Return a ‘sensible’ external editor

leo.core.leoGlobals.handleScriptException(c, p, script, script1)

leo.core.leoGlobals.handleUnl(unl, c)

Handle a Leo UNL. This must never open a browser.

leo.core.leoGlobals.handleUrl(url, c=None, p=None)

Open a url or a unl.

leo.core.leoGlobals.handleUrlHelper(url, c, p)

Open a url. Most browsers should handle: ftp://ftp.uu.net/public/whatever http://localhost/MySiteUnderDevelopment/index.html file:///home/me/todolist.html

leo.core.leoGlobals.idleTimeHookHandler(timer)

This function exists for compatibility.

leo.core.leoGlobals.importExtension(moduleName, pluginName=None, verbose=False, required=False)

Try to import a module. If that fails, try to import the module from Leo’s extensions directory.

moduleName is the module’s name, without file extension.

leo.core.leoGlobals.importFromPath(moduleName, path, verbose=False)

Import a module whose name is given from the directory given by path.

Warning: This is a thin wrapper for imp.load_module, which is equivalent to reload! Reloading Leo files while running will crash Leo.

leo.core.leoGlobals.importModule(moduleName, pluginName=None, verbose=False)

Try to import a module as Python’s import command does.

moduleName is the module’s name, without file extension.

This function first attempts to import from sys.modules, then from the extensions and external directories.

leo.core.leoGlobals.initScriptFind(c, findHeadline, changeHeadline=None, firstNode=None, script_search=True, script_change=True)

leo.core.leoGlobals.init_dialog_folder(c, p, use_at_path=True)

Return the most convenient folder to open or save a file.

leo.core.leoGlobals.init_zodb(pathToZodbStorage, verbose=True)

Return an ZODB.DB instance from ZODB.FileStorage.FileStorage(pathToZodbStorage) return None on any error.

leo.core.leoGlobals.input_(message='', c=None)

Safely execute python’s input statement.

c.executeScriptHelper binds ‘input’ to be a wrapper that calls g.input_ with c and handler bound properly.

leo.core.leoGlobals.insertCodingLine(encoding, script)

Insert a coding line at the start of script s if no such line exists. The coding line must start with @first because it will be passed to at.writeFromString.

leo.core.leoGlobals.internalError(*args)

Report a serious interal error in Leo.

leo.core.leoGlobals.isBindingInfo(obj)

leo.core.leoGlobals.isBytes(s)

Return True if s is Python3k bytes type.

leo.core.leoGlobals.isCallable(obj)

leo.core.leoGlobals.isDirective(s)

Return True if s starts with a directive.

leo.core.leoGlobals.isGeneralSetting(obj)

leo.core.leoGlobals.isInt(obj)

Return True if obj is an int or a long.

leo.core.leoGlobals.isList(s)

Return True if s is a list.

leo.core.leoGlobals.isMacOS()

leo.core.leoGlobals.isString(s)

Return True if s is any string, but not bytes.

leo.core.leoGlobals.isStroke(obj)

leo.core.leoGlobals.isStrokeOrNone(obj)

leo.core.leoGlobals.isTextWidget(w)

leo.core.leoGlobals.isTextWrapper(w)

leo.core.leoGlobals.isTypedDict(obj)

leo.core.leoGlobals.isTypedDictOfLists(obj)

leo.core.leoGlobals.isUnicode(s)

Return True if s is a unicode string.

leo.core.leoGlobals.isValidEncoding(encoding)

Return True if the encooding is valid.

leo.core.leoGlobals.isValidUrl(url)

Return true if url looks like a valid url.

leo.core.leoGlobals.isWordChar(ch)

Return True if ch should be considered a letter.

leo.core.leoGlobals.isWordChar1(ch)

leo.core.leoGlobals.is_binary_external_file(fileName)

leo.core.leoGlobals.is_binary_file(f)

leo.core.leoGlobals.is_binary_string(s)

leo.core.leoGlobals.is_c_id(ch)

leo.core.leoGlobals.is_nl(s, i)

leo.core.leoGlobals.is_sentinel(line, delims)

Return True if line starts with a sentinel comment.

>>> import leo.core.leoGlobals as g
>>> py_delims = g.comment_delims_from_extension('.py')
>>> g.is_sentinel("#@+node",py_delims)
True
>>> g.is_sentinel("#comment",py_delims)
False

>>> c_delims = g.comment_delims_from_extension('.c')
>>> g.is_sentinel("//@+node",c_delims)
True
>>> g.is_sentinel("//comment",c_delims)
False

>>> html_delims = g.comment_delims_from_extension('.html')
>>> g.is_sentinel("<!--@+node-->",html_delims)
True
>>> g.is_sentinel("<!--comment-->",html_delims)
False

leo.core.leoGlobals.is_special(s, i, directive)

Return True if the body text contains the @ directive.

leo.core.leoGlobals.is_ws(c)

leo.core.leoGlobals.is_ws_or_nl(s, i)

leo.core.leoGlobals.itemsMatchingPrefixInList(s, aList, matchEmptyPrefix=False)

This method returns a sorted list items of aList whose prefix is s.

It also returns the longest common prefix of all the matches.

leo.core.leoGlobals.ivars2instance(c, g, ivars)

Return the instance of c given by ivars. ivars is a list of strings. A special case: ivars may be ‘g’, indicating the leoGlobals module.

leo.core.leoGlobals.joinLines(aList)

leo.core.leoGlobals.join_list(aList, indent='', leading='', sep='', trailing='')

Create a dict representing the concatenation of the strings in aList, formatted per the keyword args. See the HTMLReportTraverser class for many examples.

leo.core.leoGlobals.joinlines(aList)

leo.core.leoGlobals.jsonCommitInfo()

return asctime and timestamp from leo/core/commit_timestamp.json. return (‘’, ‘’) if the file does not exist or is not a valid .json file.

leo.core.leoGlobals.listToString(obj, indent='', tag=None)

Pretty print a Python list to a string.

leo.core.leoGlobals.list_to_string(obj)

Convert obj (a list of lists) to a single string.

This function stresses the gc; it will usually be better to work with the much smaller strings generated by flatten_list.

Use this function only in special circumstances, for example, when it is known that the resulting string will be small.

leo.core.leoGlobals.loadOnePlugin(pluginName, verbose=False)

leo.core.leoGlobals.log(*args, **keys)

Put all non-keyword args to the log pane. The first, third, fifth, etc. arg translated by g.translateString. Supports color, comma, newline, spaces and tabName keyword arguments.

leo.core.leoGlobals.log_to_file(s, fn=None)

Write a message to ~/test/leo_log.txt.

leo.core.leoGlobals.longestCommonPrefix(s1, s2)

Find the longest prefix common to strings s1 and s2.

leo.core.leoGlobals.makeAllNonExistentDirectories(theDir, c=None, force=False, verbose=True)

Attempt to make all non-existent directories

leo.core.leoGlobals.makeDict(**keys)

Returns a Python dictionary from using the optional keyword arguments.

leo.core.leoGlobals.makePathRelativeTo(fullPath, basePath)

leo.core.leoGlobals.match(s, i, pattern)

leo.core.leoGlobals.match_c_word(s, i, name)

leo.core.leoGlobals.match_ignoring_case(s1, s2)

leo.core.leoGlobals.match_word(s, i, pattern)

leo.core.leoGlobals.module_date(mod, format=None)

leo.core.leoGlobals.new_cmd_decorator(name, ivars)

Return a new decorator for a command with the given name. Compute the class instance using the ivar string or list.

leo.core.leoGlobals.note(*args, **keys)

leo.core.leoGlobals.nullObject

alias of leo.core.leoGlobals.NullObject

leo.core.leoGlobals.objToString(obj, indent='', printCaller=False, tag=None)

Pretty print any Python object to a string.

leo.core.leoGlobals.oldDump(s)

leo.core.leoGlobals.openUrl(p)

Open the url of node p. Use the headline if it contains a valid url. Otherwise, look only at the first line of the body.

leo.core.leoGlobals.openUrlHelper(event, url=None)

Open the UNL or URL under the cursor. Return it for unit testing.

leo.core.leoGlobals.openUrlOnClick(event, url=None)

Open the URL under the cursor. Return it for unit testing.

leo.core.leoGlobals.openWithFileName(fileName, old_c=None, gui=None)

Create a Leo Frame for the indicated fileName if the file exists.

returns the commander of the newly-opened outline.

leo.core.leoGlobals.optimizeLeadingWhitespace(line, tab_width)

leo.core.leoGlobals.os_path_abspath(path)

Convert a path to an absolute path.

leo.core.leoGlobals.os_path_basename(path)

Return the second half of the pair returned by split(path).

leo.core.leoGlobals.os_path_dirname(path)

Return the first half of the pair returned by split(path).

leo.core.leoGlobals.os_path_exists(path)

Return True if path exists.

leo.core.leoGlobals.os_path_expandExpression(s, **keys)

Expand all {{anExpression}} in c’s context.

leo.core.leoGlobals.os_path_expanduser(path)

wrap os.path.expanduser

leo.core.leoGlobals.os_path_finalize(path, **keys)

Expand ‘~’, then return os.path.normpath, os.path.abspath of the path. There is no corresponding os.path method

leo.core.leoGlobals.os_path_finalize_join(*args, **keys)

Do os.path.join(*args), then finalize the result.

leo.core.leoGlobals.os_path_getmtime(path)

Return the modification time of path.

leo.core.leoGlobals.os_path_getsize(path)

Return the size of path.

leo.core.leoGlobals.os_path_isabs(path)

Return True if path is an absolute path.

leo.core.leoGlobals.os_path_isdir(path)

Return True if the path is a directory.

leo.core.leoGlobals.os_path_isfile(path)

Return True if path is a file.

leo.core.leoGlobals.os_path_join(*args, **keys)

The same as os.path.join, but safe for unicode. In addition, it supports the !! and . conventions.

leo.core.leoGlobals.os_path_normcase(path)

Normalize the path’s case.

leo.core.leoGlobals.os_path_normpath(path)

Normalize the path.

leo.core.leoGlobals.os_path_normslashes(path)

leo.core.leoGlobals.os_path_realpath(path)

Return the canonical path of the specified filename, eliminating any symbolic links encountered in the path (if they are supported by the operating system).

leo.core.leoGlobals.os_path_split(path)

leo.core.leoGlobals.os_path_splitext(path)

leo.core.leoGlobals.os_startfile(fname)

leo.core.leoGlobals.pause(s)

leo.core.leoGlobals.pdb(message='')

Fall into pdb.

leo.core.leoGlobals.pep8_class_name(s)

Return the proper class name for s.

leo.core.leoGlobals.pluginIsLoaded(fn)

leo.core.leoGlobals.plugin_date(plugin_mod, format=None)

leo.core.leoGlobals.plugin_signon(module_name, verbose=False)

leo.core.leoGlobals.plural(obj)

Return “s” or “” depending on n.

leo.core.leoGlobals.pno(tag='')

Print newly allocated objects.

leo.core.leoGlobals.pr(*args, **keys)

Print all non-keyword args. This is a wrapper for the print statement.

The first, third, fifth, etc. arg translated by g.translateString. Supports color, comma, newline, spaces and tabName keyword arguments.

leo.core.leoGlobals.prettyPrintType(obj)

leo.core.leoGlobals.printDict(obj, indent='', printCaller=False, tag=None)

Pretty print any Python object using g.pr.

leo.core.leoGlobals.printDiffTime(message, start)

leo.core.leoGlobals.printEntireTree(c, tag='')

leo.core.leoGlobals.printGc(tag=None)

leo.core.leoGlobals.printGcAll(tag='')

leo.core.leoGlobals.printGcObjects(tag='')

Print newly allocated objects.

leo.core.leoGlobals.printGcRefs(tag='')

leo.core.leoGlobals.printGcSummary(tag='')

leo.core.leoGlobals.printGcVerbose(tag='')

leo.core.leoGlobals.printGlobals(message=None)

leo.core.leoGlobals.printLeoModules(message=None)

leo.core.leoGlobals.printList(obj, indent='', printCaller=False, tag=None)

Pretty print any Python object using g.pr.

leo.core.leoGlobals.printNewObjects(tag='')

Print newly allocated objects.

leo.core.leoGlobals.printObj(obj, indent='', printCaller=False, tag=None)

Pretty print any Python object using g.pr.

leo.core.leoGlobals.printStack()

leo.core.leoGlobals.printStats(name=None)

leo.core.leoGlobals.printTuple(obj, indent='', printCaller=False, tag=None)

Pretty print any Python object using g.pr.

leo.core.leoGlobals.print_bindings(name, window)

leo.core.leoGlobals.python_tokenize(s, line_numbers=True)

Tokenize string s and return a list of tokens (kind,value,line_number)

where kind is in (‘comment,’id’,’nl’,’other’,’string’,’ws’).

leo.core.leoGlobals.rawPrint(s)

leo.core.leoGlobals.readFileIntoEncodedString(fn, silent=False)

Return the raw contents of the file whose full path is fn.

leo.core.leoGlobals.readFileIntoString(fn, encoding='utf-8', kind=None)

Return the contents of the file whose full path is fn.

Return (s,e) s is the string, converted to unicode, or None if there was an error. e is the encoding of s, computed in the following order: - The BOM encoding if the file starts with a BOM mark. - The encoding given in the # -- coding: utf-8 -- line for python files. - The encoding given by the ‘encoding’ keyword arg. - None, which typically means ‘utf-8’.

leo.core.leoGlobals.readFileIntoUnicodeString(fn, encoding=None, silent=False)

Return the raw contents of the file whose full path is fn.

leo.core.leoGlobals.readlineForceUnixNewline(f, fileName=None)

leo.core.leoGlobals.recursiveUNLFind(unlList, c, depth=0, p=None, maxdepth=0, maxp=None, soft_idx=False, hard_idx=False)

Internal part of recursiveUNLSearch which doesn’t change the selected position or call c.frame.bringToFront()

returns found, depth, p, where:

• found is True if a full match was found
• depth is the depth of the best match
• p is the position of the best match

NOTE: maxdepth is max depth seen in recursion so far, not a limit on

how far we will recurse. So it should default to 0 (zero).

• unlList: list of ‘headline’, ‘headline:N’, or ‘headline:N,M’ elements, where N is the node’s position index and M the zero based count of like named nodes, eg. ‘foo:2’, ‘foo:4,1’, ‘foo:12,3’
• c: outline
• soft_idx: use index when matching name not found
• hard_idx: use only indexes, ignore node names
• depth: part of recursion, don’t set explicitly
• p: part of recursion, don’t set explicitly
• maxdepth: part of recursion, don’t set explicitly
• maxp: part of recursion, don’t set explicitly

leo.core.leoGlobals.recursiveUNLParts(text)

recursiveUNLParts - return index, occurence, line_number, col_number from an UNL fragment. line_number is allowed to be negative to indicate a “global” line number within the file.

Parameters:text (str) – the fragment, foo or foo:2 or foo:2,0,4,10 Returns:index, occurence, line_number, col_number Return type:(int, int, int, int) or (None, None, None, None)

leo.core.leoGlobals.recursiveUNLSearch(unlList, c, depth=0, p=None, maxdepth=0, maxp=None, soft_idx=False, hard_idx=False)

try and move to unl in the commander c

All parameters passed on to recursiveUNLFind(), see that for docs.

NOTE: maxdepth is max depth seen in recursion so far, not a limit on

how far we will recurse. So it should default to 0 (zero).

leo.core.leoGlobals.red(*args, **keys)

leo.core.leoGlobals.redirectStderr()

leo.core.leoGlobals.redirectStdout()

leo.core.leoGlobals.registerExclusiveHandler(tags, fn)

leo.core.leoGlobals.registerHandler(tags, fn)

leo.core.leoGlobals.regularizeTrailingNewlines(s, kind)

Kind is ‘asis’, ‘zero’ or ‘one’.

leo.core.leoGlobals.removeBlankLines(s)

leo.core.leoGlobals.removeExtraLws(s, tab_width)

Remove extra indentation from one or more lines.

Warning: used by getScript. This is not the same as g.adjustTripleString.

leo.core.leoGlobals.removeLeading(s, chars)

Remove all characters in chars from the front of s.

leo.core.leoGlobals.removeLeadingBlankLines(s)

leo.core.leoGlobals.removeLeadingWhitespace(s, first_ws, tab_width)

leo.core.leoGlobals.removeTrailing(s, chars)

Remove all characters in chars from the end of s.

leo.core.leoGlobals.removeTrailingWs(s)

leo.core.leoGlobals.replace_path_expression(c, expr)

local function to replace a single path expression.

leo.core.leoGlobals.restoreStderr()

leo.core.leoGlobals.restoreStdout()

leo.core.leoGlobals.run_pylint(fn, rc, dots=True, patterns=None, sherlock=False, show_return=True, stats_patterns=None, verbose=True)

Run pylint with the given args, with Sherlock tracing if requested.

Do not assume g.app exists.

run() in pylint-leo.py and PylintCommand.run_pylint optionally call this function.

leo.core.leoGlobals.sanitize_filename(s)

Prepares string s to be a valid file name:

• substitute ‘_’ for whitespace and special path characters.
• eliminate all other non-alphabetic characters.
• convert double quotes to single quotes.
• strip leading and trailing whitespace.
• return at most 128 characters.

leo.core.leoGlobals.scanAllAtPathDirectives(c, p)

leo.core.leoGlobals.scanAllAtTabWidthDirectives(c, p)

Scan p and all ancestors looking for @tabwidth directives.

leo.core.leoGlobals.scanAllAtWrapDirectives(c, p)

Scan p and all ancestors looking for @wrap/@nowrap directives.

leo.core.leoGlobals.scanAtCommentAndAtLanguageDirectives(aList)

Scan aList for @comment and @language directives.

@comment should follow @language if both appear in the same node.

leo.core.leoGlobals.scanAtEncodingDirectives(aList)

Scan aList for @encoding directives.

leo.core.leoGlobals.scanAtHeaderDirectives(aList)

scan aList for @header and @noheader directives.

leo.core.leoGlobals.scanAtLineendingDirectives(aList)

Scan aList for @lineending directives.

leo.core.leoGlobals.scanAtPagewidthDirectives(aList, issue_error_flag=False)

Scan aList for @pagewidth directives.

leo.core.leoGlobals.scanAtPathDirectives(c, aList)

leo.core.leoGlobals.scanAtRootDirectives(aList)

Scan aList for @root directives.

leo.core.leoGlobals.scanAtRootOptions(s, i, err_flag=False)

leo.core.leoGlobals.scanAtTabwidthDirectives(aList, issue_error_flag=False)

Scan aList for @tabwidth directives.

leo.core.leoGlobals.scanAtWrapDirectives(aList, issue_error_flag=False)

Scan aList for @wrap and @nowrap directives.

leo.core.leoGlobals.scanDirectives(c, p=None)

leo.core.leoGlobals.scanError(s)

Bump the error count in the tangle command.

leo.core.leoGlobals.scanForAtIgnore(c, p)

Scan position p and its ancestors looking for @ignore directives.

leo.core.leoGlobals.scanForAtLanguage(c, p)

Scan position p and p’s ancestors looking only for @language and @ignore directives.

Returns the language found, or c.target_language.

leo.core.leoGlobals.scanForAtSettings(p)

Scan position p and its ancestors looking for @settings nodes.

leo.core.leoGlobals.scanf(s, pat)

leo.core.leoGlobals.setDefaultDirectory(c, p, importing=False)

Return a default directory by scanning @path directives.

leo.core.leoGlobals.setGlobalOpenDir(fileName)

leo.core.leoGlobals.set_delims_from_language(language)

Return a tuple (single,start,end) of comment delims.

leo.core.leoGlobals.set_delims_from_string(s)

Return (delim1, delim2, delim2), the delims following the @comment directive.

This code can be called from @language logic, in which case s can point at @comment

leo.core.leoGlobals.set_language(s, i, issue_errors_flag=False)

Scan the @language directive that appears at s[i:].

The @language may have been stripped away.

Returns (language, delim1, delim2, delim3)

leo.core.leoGlobals.shortFileName(fileName, n=None)

Return the base name of a path.

leo.core.leoGlobals.shortFilename(fileName, n=None)

Return the base name of a path.

leo.core.leoGlobals.skip_blank_lines(s, i)

leo.core.leoGlobals.skip_block_comment(s, i)

leo.core.leoGlobals.skip_braces(s, i)

Skips from the opening to the matching brace.

If no matching is found i is set to len(s)

leo.core.leoGlobals.skip_c_id(s, i)

leo.core.leoGlobals.skip_heredoc_string(s, i)

leo.core.leoGlobals.skip_id(s, i, chars=None)

leo.core.leoGlobals.skip_leading_ws(s, i, ws, tab_width)

leo.core.leoGlobals.skip_leading_ws_with_indent(s, i, tab_width)

Skips leading whitespace and returns (i, indent),

• i points after the whitespace
• indent is the width of the whitespace, assuming tab_width wide tabs.

leo.core.leoGlobals.skip_line(s, i)

leo.core.leoGlobals.skip_long(s, i)

Scan s[i:] for a valid int. Return (i, val) or (i, None) if s[i] does not point at a number.

leo.core.leoGlobals.skip_nl(s, i)

Skips a single “logical” end-of-line character.

leo.core.leoGlobals.skip_non_ws(s, i)

leo.core.leoGlobals.skip_parens(s, i)

Skips from the opening ( to the matching ).

If no matching is found i is set to len(s)

leo.core.leoGlobals.skip_pascal_begin_end(s, i)

Skips from begin to matching end. If found, i points to the end. Otherwise, i >= len(s) The end keyword matches begin, case, class, record, and try.

leo.core.leoGlobals.skip_pascal_block_comment(s, i)

leo.core.leoGlobals.skip_pascal_braces(s, i)

leo.core.leoGlobals.skip_pascal_string(s, i)

leo.core.leoGlobals.skip_pp_directive(s, i)

leo.core.leoGlobals.skip_pp_if(s, i)

leo.core.leoGlobals.skip_pp_part(s, i)

leo.core.leoGlobals.skip_python_string(s, i, verbose=True)

leo.core.leoGlobals.skip_string(s, i, verbose=True)

Scan forward to the end of a string. New in Leo 4.4.2 final: give error only if verbose is True

leo.core.leoGlobals.skip_to_char(s, i, ch)

leo.core.leoGlobals.skip_to_end_of_line(s, i)

leo.core.leoGlobals.skip_to_semicolon(s, i)

leo.core.leoGlobals.skip_to_start_of_line(s, i)

leo.core.leoGlobals.skip_typedef(s, i)

leo.core.leoGlobals.skip_ws(s, i)

leo.core.leoGlobals.skip_ws_and_nl(s, i)

leo.core.leoGlobals.sleep(n)

Wait about n milliseconds.

leo.core.leoGlobals.splitLines(s)

Split s into lines, preserving the number of lines and the endings of all lines, including the last line.

leo.core.leoGlobals.splitLongFileName(fn, limit=40)

Return fn, split into lines at slash characters.

leo.core.leoGlobals.splitlines(s)

Split s into lines, preserving the number of lines and the endings of all lines, including the last line.

leo.core.leoGlobals.startTracer(limit=0, trace=False, verbose=False)

leo.core.leoGlobals.stat(name=None)

Increments the statistic for name in g.app.statsDict The caller’s name is used by default.

leo.core.leoGlobals.stdErrIsRedirected()

leo.core.leoGlobals.stdOutIsRedirected()

leo.core.leoGlobals.stripBOM(s)

If there is a BOM, return (e,s2) where e is the encoding implied by the BOM and s2 is the s stripped of the BOM.

If there is no BOM, return (None,s)

s must be the contents of a file (a string) read in binary mode.

leo.core.leoGlobals.stripBlankLines(s)

leo.core.leoGlobals.stripBrackets(s)

Same as s.lstrip(‘<’).rstrip(‘>’) except it works for Python 2.2.1.

leo.core.leoGlobals.stripPathCruft(path)

Strip cruft from a path name.

leo.core.leoGlobals.timeSince(start)

leo.core.leoGlobals.toEncodedString(s, encoding='utf-8', reportErrors=False)

Convert unicode string to an encoded string.

leo.core.leoGlobals.toEncodedStringWithErrorCode(s, encoding, reportErrors=False)

For unit testing: convert s to an encoded string and return (s,ok).

leo.core.leoGlobals.toPythonIndex(s, index)

Convert index to a Python int.

index may be a Tk index (x.y) or ‘end’.

leo.core.leoGlobals.toString(obj, indent='', printCaller=False, tag=None)

Pretty print any Python object to a string.

leo.core.leoGlobals.toUnicode(s, encoding='utf-8', reportErrors=False)

Connvert a non-unicode string with the given encoding to unicode.

leo.core.leoGlobals.toUnicodeFileEncoding(path)

leo.core.leoGlobals.toUnicodeWithErrorCode(s, encoding, reportErrors=False)

For unit testing: convert s to unicode and return (s,ok).

leo.core.leoGlobals.tr(s)

Return the translated text of s.

leo.core.leoGlobals.trace(*args, **keys)

Print a tracing message.

leo.core.leoGlobals.traceUrl(c, path, parsed, url)

leo.core.leoGlobals.translateArgs(args, d)

Return the concatenation of s and all args,

with odd args translated.

leo.core.leoGlobals.translateString(s)

Return the translated text of s.

leo.core.leoGlobals.truncate(s, n)

Return s truncated to n characters.

leo.core.leoGlobals.tupleToString(obj, indent='', tag=None)

Pretty print a Python tuple to a string.

leo.core.leoGlobals.u(s)

Return s, converted to unicode from Qt widgets.

leo.core.leoGlobals.ue(s, encoding)

leo.core.leoGlobals.unCamel(s)

Return a list of sub-words in camelCased string s.

leo.core.leoGlobals.unloadOnePlugin(moduleOrFileName, verbose=False)

leo.core.leoGlobals.unquoteUrl(url)

Replace special characters (especially %20, by their equivalent).

This function handles 2/3 issues and suppresses pylint complaints.

leo.core.leoGlobals.unregisterHandler(tags, fn)

leo.core.leoGlobals.update_file_if_changed(c, file_name, temp_name)

Compares two files.

If they are different, we replace file_name with temp_name. Otherwise, we just delete temp_name. Both files should be closed.

leo.core.leoGlobals.ustr(s)

Define the pyzo ustr function.

leo.core.leoGlobals.utils_chmod(fileName, mode, verbose=True)

leo.core.leoGlobals.utils_remove(fileName, verbose=True)

leo.core.leoGlobals.utils_rename(c, src, dst, verbose=True)

Platform independent rename.

leo.core.leoGlobals.utils_stat(fileName)

Return the access mode of named file, removing any setuid, setgid, and sticky bits.

leo.core.leoGlobals.virtual_event_name(s)

leo.core.leoGlobals.warning(*args, **keys)

leo.core.leoGlobals.windows()

leo.core.leoGlobals.wrap_lines(lines, pageWidth, firstLineWidth=None)

Returns a list of lines, consisting of the input lines wrapped to the given pageWidth.

leoGui Module

leoIPython Module

leoImport Module

class leo.core.leoImport.FreeMindImporter(c)

Bases: object

Importer class for FreeMind (.mmap) files.

add_children(parent, element)

parent is the parent position, element is the parent element. Recursively add all the child elements as descendants of parent_p.

create_outline(path)

Create a tree of nodes from a FreeMind file.

import_file(path)

The main line of the FreeMindImporter class.

import_files(files)

Import a list of FreeMind (.mmap) files.

prompt_for_files()

Prompt for a list of FreeMind (.mm.html) files and import them.

class leo.core.leoImport.JSON_Import_Helper(c)

Bases: object

A class that helps client scripts import .json files.

Client scripts supply data describing how to create Leo outlines from the .json data.

create_nodes(parent, parent_d)

Create the tree of nodes rooted in parent.

create_outline(path)

scan(s, parent)

Create an outline from a MindMap (.csv) file.

class leo.core.leoImport.LeoImportCommands(c)

Bases: object

A class implementing all of Leo’s import/export code. This class uses importers in the leo/plugins/importers folder.

For more information, see leo/plugins/importers/howto.txt.

appendHeadRef(p, file_name, head_ref, result)

appendRefToFileName(file_name, result)

appendStringToBody(p, s)

Similar to c.appendStringToBody, but does not recolor the text or redraw the screen.

body_parser_for_ext(ext)

A factory returning a body parser function for the given file extension.

cSharpUnitTest(p, fileName=None, s=None, showTree=False)

cUnitTest(p, fileName=None, s=None, showTree=False)

coffeeScriptUnitTest(p, fileName=None, s=None, showTree=False)

compute_unit_test_kind(ext, fn)

Return kind from fn’s file extension.

convertCodePartToWeb(s, i, p, result)

# Headlines not containing a section reference are ignored in noweb and generate index index in cweb.

convertDocPartToWeb(s, i, result)

convertVnodeToWeb(v)

This code converts a VNode to noweb text as follows:

Convert @doc to @ Convert @root or @code to < < name > >=, assuming the headline contains < < name > > Ignore other directives Format doc parts so they fit in pagewidth columns. Output code parts as is.

copyPart(s, i, result)

createHeadline(parent, body, headline)

Create a new VNode as the last child of parent position.

createOutline(fileName, parent, atShadow=False, ext=None, s=None)

Create an outline by importing a file, reading the file with the given encoding if string s is None.

ext, The file extension to be used, or None. fileName: A string or None. The name of the file to be read. parent: The parent position of the created outline. s: A string or None. The file’s contents.

createOutlineFromWeb(path, parent)

cstCanonicalize(s, lower=True)

cstDump()

cstEnter(s)

cstLookup(target)

ctextUnitTest(p, fileName=None, s=None, showTree=False)

dartUnitTest(p, fileName=None, s=None, showTree=False)

defaultImporterUnitTest(p, fileName=None, s=None, showTree=False)

dispatch(ext, p)

Return the correct scanner function for p, an @auto node.

elispUnitTest(p, fileName=None, s=None, showTree=False)

error(s)

exportHeadlines(fileName)

findFunctionDef(s, i)

flattenOutline(fileName)

A helper for the flatten-outline command.

Export the selected outline to an external file. The outline is represented in MORE format.

getFileName(p)

Return the file name from an @file or @root node.

getHeadRef(p)

Look for either noweb or cweb brackets. Return everything between those brackets.

get_import_filename(fileName, parent)

Return the absolute path of the file and set .default_directory.

htmlUnitTest(p, fileName=None, s=None, showTree=False)

importDerivedFiles(parent=None, paths=None, command='Import')

Import one or more external files. This is not a command. It must not have an event arg. command is None when importing from the command line.

importFilesCommand(files=None, parent=None, redrawFlag=True, shortFn=False, treeType=None)

importFlattenedOutline(files)

importFreeMind(files)

Import a list of .mm.html files exported from FreeMind: http://freemind.sourceforge.net/wiki/index.php/Main_Page

importMindMap(files)

Import a list of .csv files exported from MindJet: https://www.mindjet.com/

importWebCommand(files, webType)

import_binary_file(fileName, parent)

iniUnitTest(p, fileName=None, s=None, showTree=False)

init_import(atShadow, ext, fileName, s)

Init ivars imports and read the file into s. Return ext, s.

isDocStart(s, i)

isModuleStart(s, i)

javaScriptUnitTest(p, fileName=None, s=None, showTree=False)

javaUnitTest(p, fileName=None, s=None, showTree=False)

languageForExtension(ext)

Return the language corresponding to the extension ext.

markdownUnitTest(p, fileName=None, s=None, showTree=False)

massageWebBody(s)

orgUnitTest(p, fileName=None, s=None, showTree=False)

otlUnitTest(p, fileName=None, s=None, showTree=False)

outlineToWeb(fileName, webType)

parse_body(p)

Parse p.b as source code, creating a tree of descendant nodes. This is essentially an import of p.b.

pascalUnitTest(p, fileName=None, s=None, showTree=False)

perlUnitTest(p, fileName=None, s=None, showTree=False)

phpUnitTest(p, fileName=None, s=None, showTree=False)

pythonUnitTest(p, fileName=None, s=None, showTree=False)

readAtAutoNodes()

reloadSettings()

reload_settings()

removeSentinelLines(s, line_delim, start_delim, unused_end_delim)

Properly remove all sentinle lines in s.

removeSentinelsCommand(paths, toString=False)

rstUnitTest(p, fileName=None, s=None, showTree=False)

scanBodyForHeadline(s)

scanUnknownFileType(s, p, ext)

Scan the text of an unknown file type.

scanWebFile(fileName, parent)

scannerUnitTest(p, ext=None, fileName=None, s=None, showTree=False)

Run a unit test of an import scanner, i.e., create a tree from string s at location p.

setBodyString(p, s)

Similar to c.setBodyString, but does not recolor the text or redraw the screen.

setEncoding(p=None, default=None)

textUnitTest(p, fileName=None, s=None, showTree=False)

typeScriptUnitTest(p, fileName=None, s=None, showTree=False)

weave(filename)

xmlUnitTest(p, fileName=None, s=None, showTree=False)

class leo.core.leoImport.MORE_Importer(c)

Bases: object

Class to import MORE files.

check(s)

check_lines(strings)

headlineLevel(s)

return the headline level of s,or -1 if the string is not a MORE headline.

import_file(fileName)

import_files(files)

Import a list of MORE (.csv) files.

import_lines(strings, first_p)

prompt_for_files()

Prompt for a list of MORE files and import them.

class leo.core.leoImport.MindMapImporter(c)

Bases: object

Mind Map Importer class.

create_outline(path)

csv_level(row)

Return the level of the given row.

csv_string(row)

Return the string for the given csv row.

import_files(files)

Import a list of MindMap (.csv) files.

prompt_for_files()

Prompt for a list of MindJet (.csv) files and import them.

scan(path, target)

Create an outline from a MindMap (.csv) file.

class leo.core.leoImport.RecursiveImportController(c, kind, add_path=True, recursive=True, safe_at_file=True, theTypes=None)

Bases: object

Recursively import all python files in a directory and clean the result.

add_class_names(p)

Add class names to headlines for all descendant nodes.

clear_dirty_bits(p)

dump_headlines(p)

fix_back_slashes(p)

Convert backslash to slash in all headlines.

import_dir(dir_, parent)

Import selected files from dir_, a directory.

import_one_file(path, parent)

Import one file to the last top-level node.

minimize_headlines(p, prefix)

Create @path nodes to minimize the paths required in descendant nodes.

post_process(p, prefix)

Traverse p’s tree, replacing all nodes that start with prefix by the smallest equivalent @path or @file node.

remove_empty_nodes(p)

Remove empty nodes. Not called for @auto or @edit trees.

run(dir_)

Import all files whose extension matches self.theTypes in dir_. In fact, dir_ can be a path to a single file.

strip_prefix(path, prefix)

Strip the prefix from the path and return the result.

class leo.core.leoImport.TabImporter(c, separate=True)

A class to import a file whose outline levels are indicated by leading tabs or blanks (but not both).

check(lines, warn=True)

Return False and warn if lines contains mixed leading tabs/blanks.

dump_stack()

Dump the stack, containing (level, p) tuples.

import_files(files)

Import a list of tab-delimited files.

lws(s)

Return the length of the leading whitespace of s.

prompt_for_files()

Prompt for a list of FreeMind (.mm.html) files and import them.

scan(s1, fn=None, root=None)

Create the outline corresponding to s1.

scan_helper(s)

Update the stack as necessary and return (level, parent, stack).

undent(level, s)

Unindent all lines of p.b by level.

class leo.core.leoImport.ZimImportController(c)

Bases: object

A class to import Zim folders and files: http://zim-wiki.org/ First use Zim to export your project to rst files.

Original script by Davy Cottet.

User options:

@int rst_level = 0 @string rst_type @string zim_node_name @string path_to_zim

clean(zimNode, rstType)

Clean useless nodes

parseZimIndex()

Parse Zim wiki index.rst and return a list of tuples (level, name, path)

rstToLastChild(p, name, rst)

Import an rst file as a last child of pos node with the specified name

run()

Create the zim node as the last top-level node.

leo.core.leoImport.headToPrevNode(event)

Move the code preceding a def to end of previous node.

leo.core.leoImport.import_MORE_files_command(event)

Prompt for MORE files and import them.

leo.core.leoImport.import_free_mind_files(event)

Prompt for free-mind files and import them.

leo.core.leoImport.import_mind_jet_files(event)

Prompt for mind-jet files and import them.

leo.core.leoImport.import_tabbed_files_command(event)

Prompt for tabbed files and import them.

leo.core.leoImport.import_zim_command(event)

Import a zim folder, http://zim-wiki.org/, as the last top-level node of the outline.

First use Zim to export your project to rst files.

This command requires the following Leo settings:

@int rst_level = 0
@string rst_type
@string zim_node_name
@string path_to_zim

leo.core.leoImport.parse_body_command(event)

The parse-body command.

leo.core.leoImport.tailToNextNode(event=None)

Move the code following a def to start of next node.

leoInspect Module

leoKeys Module

Gui-independent keystroke handling for Leo.

class leo.core.leoKeys.AutoCompleterClass(k)

Bases: object

A class that inserts autocompleted and calltip text in text widgets. This class shows alternatives in the tabbed log pane.

The keyHandler class contains hooks to support these characters: invoke-autocompleter-character (default binding is ‘.’) invoke-calltips-character (default binding is ‘(‘)

abort()

add_prefix(prefix, s)

A hack to match the callers expectations.

appendTabName(word)

attr_matches(s, namespace)

Compute matches when string s is of the form name.name….name.

Evaluates s using eval(s,namespace)

Assuming the text is of the form NAME.NAME….[NAME], and is evaluatable in the namespace, it will be evaluated and its attributes (as revealed by dir()) are used as possible completions.

For class instances, class members are are also considered.)

Warning: this can still invoke arbitrary C code, if an object with a __getattr__ hook is evaluated.

autoComplete(event=None, force=False)

An event handler for autocompletion.

autoCompleteForce(event=None)

Show autocompletion, even if autocompletion is not presently enabled.

auto_completer_state_handler(event)

Handle all keys while autocompleting.

beginTabName(word)

calltip()

Show the calltips for the present prefix. ch is ‘(‘ if the user has just typed it.

calltip_fail(prefix)

Evaluation of prefix failed.

calltip_success(prefix, obj)

clean(hits)

Clean up hits, a list of ctags patterns, for use in completion lists.

clean_completion_list(header, tabList)

Return aList with header removed from the start of each list item.

clean_for_display(hits)

Clean up hits, a list of ctags patterns, for display purposes.

clearTabName()

cmd()

Command decorator for the AutoCompleter class.

compute_completion_list()

Return the autocompleter completion list.

disableAutocompleter(event=None)

Disable the autocompleter.

disableCalltips(event=None)

Disable calltips.

do_backspace()

Delete the character and recompute the completion list.

do_qcompleter_tab(prefix, options)

Return the longest common prefix of all the options.

enableAutocompleter(event=None)

Enable the autocompleter.

enableCalltips(event=None)

Enable calltips.

exit()

finish()

get_autocompleter_prefix()

get_cached_options(prefix)

get_codewise_completions(prefix)

Use codewise to generate a list of hits.

get_completions(prefix)

Return jedi or codewise completions.

get_jedi_completions(prefix)

get_leo_completions(prefix)

Return completions in an environment defining c, g and p.

get_leo_namespace(prefix)

Return an environment in which to evaluate prefix. Add some common standard library modules as needed.

get_object()

Return the object corresponding to the current prefix.

get_summary_list(header, tabList)

Show the possible starting letters, but only if there are more than one.

guess_class(c, varname)

Return kind, class_list

info()

Show the docstring for the present completion.

init_qcompleter(event=None)

init_tabcompleter(event=None)

insert_general_char(ch)

insert_string(s, select=False)

Insert s at the insertion point.

is_leo_source_file()

Return True if this is one of Leo’s source files.

jedi_warning = False

lookup_functions(prefix)

lookup_methods(aList, prefix)

lookup_modules(aList, prefix)

popTabName()

put(*args, **keys)

Put s to the given tab.

May be overridden in subclasses.

reloadSettings()

setTabName(s)

showAutocompleterStatus()

Show the autocompleter status.

showCalltips(event=None, force=False)

Show the calltips at the cursor.

showCalltipsForce(event=None)

Show the calltips at the cursor, even if calltips are not presently enabled.

showCalltipsStatus()

Show the autocompleter status.

show_completion_list(common_prefix, prefix, tabList)

start(event)

strip_brackets(s)

Return s with all brackets removed.

This (mostly) ensures that eval will not execute function calls, etc.

toggleAutocompleter(event=None)

Toggle whether the autocompleter is enabled.

toggleCalltips(event=None)

Toggle whether calltips are enabled.

class leo.core.leoKeys.ContextSniffer

Bases: object

Class to analyze surrounding context and guess class

For simple dynamic code completion engines.

declare(var, klass)

get_classes(s, varname)

Return a list of classes for string s.

push_declarations(s)

class leo.core.leoKeys.FileNameChooser(c)

Bases: object

A class encapsulation file selection & completion logic.

compute_tab_list()

Compute the list of completions.

do_back_space()

Handle a back space.

do_char(char)

Handle a non-special character.

do_tab()

Handle tab completion.

extend_label(s)

Extend the label by s.

get_file_name(event, callback, filterExt, prompt, tabName)

Get a file name, supporting file completion.

get_label()

Return the label, not including the prompt.

set_label(s)

Set the label after the prompt to s. The prompt never changes.

show_tab_list(tabList)

Show the tab list in the log tab.

class leo.core.leoKeys.GetArg(c, prompt='full-command: ', tabName='Completion')

Bases: object

A class encapsulating all k.getArg logic.

k.getArg maps to ga.get_arg, which gets arguments in the minibuffer.

For details, see the docstring for ga.get_arg

cancel_after_state()

command_source(commandName)

Return the source legend of an @button/@command node. ‘G’ leoSettings.leo ‘M’ myLeoSettings.leo ‘L’ local .leo File ‘ ‘ not an @command or @button node

compute_tab_list(tabList, backspace=False, allow_empty_completion=False)

Compute and show the available completions.

do_back_space(tabList, completion=True)

Handle a backspace and update the completion list.

do_char(event, char)

Handle a non-special character.

do_end(event, char, stroke)

A return or escape has been seen.

do_state_zero(completion, event, handler, oneCharacter, returnKind, returnState, tabList, useMinibuffer)

Do state 0 processing.

do_tab(tabList, completion=True)

Handle tab completion when the user hits a tab.

do_tab_callback()

If the command-name handler has a tab_callback, call handler.tab_callback() and return True.

do_tab_cycling(common_prefix, tabList)

Put the next (or first) completion in the minibuffer.

get_arg(event, returnKind=None, returnState=None, handler=None, tabList=None, completion=True, oneCharacter=False, stroke=None, useMinibuffer=True)

Accumulate an argument. Enter the given return state when done.

Ctrl-G will abort this processing at any time.

All commands needing user input call k.getArg, which just calls ga.get_arg.

The arguments to ga.get_arg are as follows:

event: The event passed to the command.

returnKind=None: A string. returnState=None, An int. handler=None, A function.

When the argument is complete, ga.do_end does:

if kind: k.setState(kind,n,handler)

tabList=[]: A list of possible completions.

completion=True: True if completions are enabled.

oneCharacter=False: True if k.arg should be a single character.

stroke=None: The incoming key stroke.

useMinibuffer=True: True: put focus in the minibuffer while accumulating arguments.

False allows sort-lines, for example, to show the selection range.

get_command(s)

Return the command part of a minibuffer contents s.

get_label()

Return the label, not including the prompt.

get_minibuffer_command_name()

Return the command name in the minibuffer.

is_command(s)

Return False if something, even a blank, follows a command.

reset_tab_cycling()

Reset all tab cycling ivars.

set_label(s)

Set the label after the prompt to s. The prompt never changes.

should_end(char, stroke)

Return True if ga.get_arg should return.

show_tab_list(tabList)

Show the tab list in the log tab.

trace_state(char, completion, handler, state, stroke)

Trace the vars and ivars.

class leo.core.leoKeys.KeyHandlerClass(c)

Bases: object

A class to support emacs-style commands. c.k is an instance of this class.

NEWgeneralModeHandler(event, commandName=None, func=None, modeName=None, nextMode=None, prompt=None)

Handle a mode defined by an @mode node in leoSettings.leo.

addModeCommands()

Add commands created by @mode settings to c.commandsDict.

addToCommandHistory(commandName)

Add a name to the command history.

badMode(modeName)

bindKey(pane, shortcut, callback, commandName, modeFlag=False, tag=None)

Bind the indicated shortcut (a Tk keystroke) to the callback.

No actual gui bindings are made: only entries in k.masterBindingsDict and k.bindingsDict.

tag gives the source of the binding.

Return True if the binding was made successfully.

bindKeyToDict(pane, stroke, bi)

Update k.masterBindingsDict for the stroke.

bindOpenWith(d)

Register an open-with command.

bindShortcut(pane, shortcut, callback, commandName, modeFlag=False, tag=None)

Bind the indicated shortcut (a Tk keystroke) to the callback.

No actual gui bindings are made: only entries in k.masterBindingsDict and k.bindingsDict.

tag gives the source of the binding.

Return True if the binding was made successfully.

callAltXFunction(event)

Call the function whose name is in the minibuffer.

callStateFunction(event)

Call the state handler associated with this event.

checkBindings()

Print warnings if commands do not have any @shortcut entry. The entry may be None, of course.

checkKeyEvent(event)

Perform sanity checks on the incoming event.

check_bind_key(commandName, pane, stroke)

Return True if the binding of stroke to commandName for the given pane can be made.

clearState()

Clear the key handler state.

cmd()

Command decorator for the leoKeys class.

commandExists(commandName)

Return the command handler for the given command name, or None.

commandHistoryBackwd()

Return the previous entry in the Command History - stay at the top if we are there

commandHistoryFwd()

Move down the Command History - fall off the bottom (return empty string) if necessary

completeAllBindings(w=None)

New in 4.4b3: make an actual binding in all the standard places.

The event will go to k.masterKeyHandler as always, so nothing really changes. except that k.masterKeyHandler will know the proper stroke.

completeAllBindingsForWidget(w)

Make all a master gui binding for widget w.

computeInverseBindingDict()

createModeBindings(modeName, d, w)

Create mode bindings for the named mode using dictionary d for w, a text widget.

defineExternallyVisibleIvars()

defineInternalIvars()

Define internal ivars of the KeyHandlerClass class.

defineMultiLineCommands()

defineSingleLineCommands()

doBackSpace(tabList, completion=True)

Convenience method mapping k.doBackSpace to ga.do_back_space.

doBinding(event)

The last phase of k.masertKeyHandler. Execute the command associated with stroke’s binding. Call k.handleUnboundKeys for killed or non-existent bindings.

doControlU(event, stroke)

doDemo(event)

Support the demo.py plugin. Return True if k.masterKeyHandler should return.

doKeyboardQuit(event)

Handle keyboard-quit logic. return True if k.masterKeyHandler should return.

doMode(event)

Handle mode bindings. Return True if k.masterKeyHandler should return.

doTabCompletion(tabList)

Convenience method mapping k.doTabCompletion to ga.do_tab.

doUnboundPlainKey(event)

Handle unbound plain keys. Return True if k.masterKeyHandler should return.

doVim(event)

Handle vim mode. Return True if k.masterKeyHandler should return.

dumpMasterBindingsDict()

Dump k.masterBindingsDict.

editShortcut_do_bind_helper(stroke, cmdname)

endCommand(commandName)

Make sure Leo updates the widget following a command.

Never changes the minibuffer label: individual commands must do that.

endMode()

enterNamedMode(event, commandName)

executeNTimes(event, n)

exitNamedMode(event=None)

Exit an input mode.

extendLabel(s, select=False, protect=False)

finishCreate()

Complete the construction of the keyHandler class. c.commandsDict has been created when this is called.

fullCommand(event, specialStroke=None, specialFunc=None, help=False, helpHandler=None)

Handle ‘full-command’ (alt-x) mode.

generalModeHandler(event, commandName=None, func=None, modeName=None, nextMode=None, prompt=None)

Handle a mode defined by an @mode node in leoSettings.leo.

get1Arg(event, handler, prefix=None, tabList=None, completion=True, oneCharacter=False, stroke=None, useMinibuffer=True)

k.get1Arg: Handle the next character the user types when accumulating a user argument from the minibuffer. Ctrl-G will abort this processing at any time.

Commands should use k.get1Arg to get the first minibuffer argument and k.getNextArg to get all other arguments.

Before going into the many details, let’s look at some examples. This code will work in any class having a ‘c’ ivar bound to a commander.

Example 1: get one argument from the user:

@g.command(‘my-command’) def myCommand(self, event):

k = self.c.k k.setLabelBlue(‘prompt: ‘) k.get1Arg(event, handler=self.myCommand1)

def myCommand1(self, event):

k = self.c.k # k.arg contains the argument. # Finish the command. … # Reset the minibuffer. k.clearState() k.resetLabel() k.showStateAndMode()

Example 2: get two arguments from the user:

@g.command(‘my-command’) def myCommand(self, event):

k = self.c.k k.setLabelBlue(‘first prompt: ‘) k.get1Arg(event, handler=self.myCommand1)

def myCommand1(self, event):

k = self.c.k self.arg1 = k.arg k.extendLabel(‘ second prompt: ‘, select=False, protect=True) k.getNextArg(handler=self.myCommand2)

def myCommand2(self, event):

k = self.c.k # k.arg contains second argument. # Finish the command, using self.arg1 and k.arg. … # Reset the minibuffer. k.clearState() k.resetLabel() k.showStateAndMode()

k.get1Arg and k.getNextArg are a convenience methods. They simply pass their arguments to the get_arg method of the singleton GetArg instance. This docstring describes k.get1arg and k.getNextArg as if they were the corresponding methods of the GetArg class.

k.get1Arg is a state machine. Logically, states are tuples (kind, n, handler) though they aren’t represented that way. When the state machine in the GetArg class is active, the kind is ‘getArg’. This constant has special meaning to Leo’s key-handling code.

The arguments to k.get1Arg are as follows:

event: The event passed to the command.

handler=None, An executable. k.get1arg calls handler(event)

when the user completes the argument by typing <Return> or (sometimes) <tab>.

tabList=[]: A list of possible completions.

completion=True: True if completions are enabled.

oneCharacter=False: True if k.arg should be a single character.

stroke=None: The incoming key stroke.

useMinibuffer=True: True: put focus in the minibuffer while accumulating arguments.

False allows sort-lines, for example, to show the selection range.

getArg(event, returnKind=None, returnState=None, handler=None, prefix=None, tabList=None, completion=True, oneCharacter=False, stroke=None, useMinibuffer=True)

Convenience method mapping k.getArg to ga.get_arg.

getBindingHelper(key, name, stroke, w)

Find a binding for the widget with the given name.

getEditableTextRange()

getFileName(event, callback=None, filterExt=None, prompt='Enter File Name: ', tabName='Dired')

Get a file name from the minibuffer.

getLabel(ignorePrompt=False)

getMinibufferCommandName()

Convenience method mapping k.getMinibufferCommandName to ga.get_minibuffer_command_name.

getNextArg(handler)

Get the next arg. For example, after a Tab in the find commands. See the docstring for k.get1Arg for examples of its use.

getPaneBinding(stroke, w)

getState(kind)

getStateHandler()

getStateKind()

getStrokeForCommandName(commandName)

handleDefaultChar(event, stroke)

Handle an unbound key, based on the event’s widget. Do not assume that stroke exists.

handleInputShortcut(event, stroke)

handleMiniBindings(event, state, stroke)

Find and execute commands bound to the event.

handleMinibufferHelper(event, pane, state, stroke)

Execute a pane binding in the minibuffer.

Return ‘continue’, ‘ignore’, ‘found’

handleUnboundKeys(event)

inState(kind=None)

initAbbrev()

initCommandHistory()

Init command history from @data command-history nodes.

initMode(event, modeName)

initOneAbbrev(commandName, key)

Enter key as an abbreviation for commandName in c.commandsDict.

initSpecialIvars()

Set ivars for special keystrokes from previously-existing bindings.

isAutoCompleteChar(stroke)

Return True if stroke is bound to the auto-complete in the insert or overwrite state.

isEditShortcutSensible()

isFKey(stroke)

isInShortcutBodyLine()

isPlainKey(stroke)

Return true if the shortcut refers to a plain (non-Alt,non-Ctl) key.

isSpecialKey(event)

Return True if char is a special key.

keyboardQuit(event=None, setFocus=True, mouseClick=False)

This method clears the state and the minibuffer label.

k.endCommand handles all other end-of-command chores.

killLine(protect=True)

kill_one_shortcut(stroke)

Update the configuration dicts so that c.config.getShortcut(name) will return None for all names presently bound to the stroke.

makeAllBindings()

Make all key bindings in all of Leo’s panes.

makeBindingsFromCommandsDict()

Add bindings for all entries in c.commandsDict.

makeMasterGuiBinding(stroke, w=None, trace=False)

Make a master gui binding for stroke in pane w, or in all the standard widgets.

manufactureKeyPressForCommandName(w, commandName)

Implement a command by passing a keypress to the gui.

Only unit tests use this method.

masterCommand(commandName=None, event=None, func=None, stroke=None)

This is the central dispatching method. All commands and keystrokes pass through here. This returns None, but may set k.funcReturn.

masterKeyHandler(event)

The master key handler for almost all key bindings.

menuCommandKey(event=None)

modeHelp(event)

The mode-help command.

A possible convention would be to bind <Tab> to this command in most modes, by analogy with tab completion.

modeHelpHelper(d)

oops()

overrideCommand(commandName, func)

prettyPrintKey(stroke, brief=False)

printBindings(event=None)

Print all the bindings presently in effect.

printBindingsHelper(result, data, prefix)

printButtons(event=None)

Print all @button and @command commands, their bindings and their source.

printCommands(event=None)

Print all the known commands and their bindings, if any.

protectLabel()

registerCommand(commandName, func, allowBinding=False, pane='all', shortcut=None, **kwargs)

Make the function available as a minibuffer command.

You can wrap any method in a callback function, so the restriction to functions is not significant.

Ignore the ‘shortcut’ arg unless ‘allowBinding’ is True.

Only k.bindOpenWith and the mod_scripting.py plugin should set allowBinding.

registerCommandShortcut(commandName, func, pane, shortcut)

Register a shortcut for the a command.

Important: Bindings created here from plugins can not be overridden. This includes @command and @button bindings created by mod_scripting.py.

reinitMode(modeName)

reloadSettings()

remove_conflicting_definitions(aList, commandName, pane, shortcut)

repeatComplexCommand(event)

Repeat the previously executed minibuffer command.

repeatComplexCommandHelper(event)

resetCommandHistory()

reset the command history index to indicate that we are pointing ‘past’ the last entry

resetLabel()

Reset the minibuffer label.

searchTree(char)

Search all visible nodes for a headline starting with stroke.

selectAll()

Select all the user-editable text of the minibuffer.

setCommandState(event)

Enter the ‘command’ editing state.

setDefaultEditingAction()

setDefaultInputState()

setDefaultUnboundKeyAction(allowCommandState=True)

setEditingState()

setEventWidget(event)

A hack: redirect the event to the text part of the log.

setInputState(state, set_border=False)

setInsertState(event)

Enter the ‘insert’ editing state.

setLabel(s, protect=False)

Set the label of the minibuffer.

setLabelBlue(label, protect=True)

Set the minibuffer label.

setLabelGray(label=None)

setLabelGrey(label=None)

setLabelRed(label=None, protect=False)

setLossage(ch, stroke)

setOverwriteState(event)

Enter the ‘overwrite’ editing state.

setState(kind, n, handler=None)

setStatusLabel(s)

Set the label to s.

Use k.setStatusLabel, not k.setLael, to report the status of a Leo command. This allows the option to use g.es instead of the minibuffer to report status.

showStateAndMode(w=None, prompt=None, setFocus=True)

Show the state and mode at the start of the minibuffer.

showStateCursor(state, w)

simulateCommand(commandName, event=None)

Execute a Leo command by name.

sortCommandHistory()

Sort the command history.

stroke2char(stroke)

Convert a stroke to an (insertable) char. This method allows Leo to use strokes everywhere.

toggleInputState(event=None)

The toggle-input-state command.

traceVars(event)

universalDispatcher(event)

Handle accumulation of universal argument.

updateLabel(event)

Mimic what would happen with the keyboard and a Text editor instead of plain accumulation.

class leo.core.leoKeys.ModeInfo(c, name, aList)

Bases: object

computeModeName(name)

computeModePrompt(name)

createModeBindings(w)

Create mode bindings for w, a text widget.

createModeCommand()

enterMode()

init(name, dataList)

aList is a list of tuples (commandName,bi).

initMode()

leoMenu Module

Gui-independent menu handling for Leo.

class leo.core.leoMenu.LeoMenu(frame)

Bases: object

The base class for all Leo menus.

activateMenu(menuName)

add_cascade(parent, label, menu, underline)

add_command(menu, **keys)

add_separator(menu)

canonicalizeMenuName(name)

canonicalizeTranslatedMenuName(name)

capitalizeMinibufferMenuName(s, removeHyphens)

clearAccel(menu, name)

computeOldStyleShortcutKey(s)

Compute the old-style shortcut key for @shortcuts entries.

createMasterMenuCallback(dynamicMenu, command, commandName)

createMenuBar(frame)

createMenuEntries(menu, table, dynamicMenu=False)

Create a menu entry from the table. New in 4.4: this method shows the shortcut in the menu, but this method never binds any shortcuts.

createMenuFromConfigList(parentName, aList, level=0)

Build menu based on nested list

List entries are either:

[‘@item’, ‘command-name’, ‘optional-view-name’]

or:

[‘@menu Submenu name’, <nested list>, None]

Parameters:

• parentName (str) – name of menu under which to place this one
• aList (list) – list of entries as described above

createMenuItemsFromTable(menuName, table, dynamicMenu=False)

createMenusFromConfigList(aList)

Create menus from aList. The ‘top’ menu has already been created.

createMenusFromTables()

(leoMenu) Usually over-ridden.

createNewMenu(menuName, parentName='top', before=None)

createOpenWithMenu(parent, label, index, amp_index)

createOpenWithMenuFromTable(table)

Table is a list of dictionaries, created from @openwith settings nodes.

This menu code uses these keys:

‘name’: menu label. ‘shortcut’: optional menu shortcut.

efc.open_temp_file uses these keys:

‘args’: the command-line arguments to be used to open the file. ‘ext’: the file extension. ‘kind’: the method used to open the file, such as subprocess.Popen.

createOpenWithMenuItemsFromTable(menu, table)

Create an entry in the Open with Menu from the table, a list of dictionaries.

Each dictionary d has the following keys:

‘args’: the command-line arguments used to open the file. ‘ext’: not used here: used by efc.open_temp_file. ‘kind’: not used here: used by efc.open_temp_file. ‘name’: menu label. ‘shortcut’: optional menu shortcut.

defineMenuCallback(command, name, minibufferCommand)

defineOpenWithMenuCallback(d)

define_enable_dict()

delete(menu, realItemName)

deleteMenu(menuName)

deleteMenuItem(itemName, menuName='top')

Delete itemName from the menu whose name is menuName.

deleteRecentFilesMenuItems(menu)

Delete recent file menu entries

delete_range(menu, n1, n2)

destroy(menu)

destroyMenu(menuName)

disableMenu(menu, name)

enableMenu(menu, name, val)

error(s)

finishCreate()

getMacHelpMenu(table)

getMenu(menuName)

getMenuEntryBindings(command, dynamicMenu, label)

Compute commandName from command.

getMenuEntryInfo(data, menu)

getMenuLabel(menu, name)

getRealMenuName(menuName)

handleSpecialMenus(name, parentName, alt_name=None, table=None)

Handle a special menu if name is the name of a special menu. return True if this method handles the menu.

hasSelection()

insert(menuName, position, label, command, underline=None)

insert_cascade(parent, index, label, menu, underline)

new_menu(parent, tearoff=0, label='')

oops()

setMenu(menuName, menu)

setMenuLabel(menu, name, label, underline=-1)

setRealMenuName(untrans, trans)

setRealMenuNamesFromTable(table)

traceMenuTable(table)

class leo.core.leoMenu.NullMenu(frame)

Bases: leo.core.leoMenu.LeoMenu

A null menu class for testing and batch execution.

oops()

leoNodes Module

Leo’s fundamental data classes.

class leo.core.leoNodes.NodeIndices(id_)

Bases: object

A class managing global node indices (gnx’s).

check_gnx(c, gnx, v)

Check that no vnode exists with the given gnx in fc.gnxDict.

compute_last_index(c)

Scan the entire leo outline to compute ni.last_index.

getDefaultId()

Return the id to be used by default in all gnx’s

getNewIndex(v, cached=False)

Create a new gnx for v or an empty string if the hold flag is set. Important: the method must allocate a new gnx even if v.fileIndex exists.

new_vnode_helper(c, gnx, v)

Handle all gnx-related tasks for VNode.__init__.

scanGnx(s, i=0)

Create a gnx from its string representation.

setDefaultId(theId)

Set the id to be used by default in all gnx’s

setTimeStamp()

Set the timestamp string to be used by getNewIndex until further notice

setTimestamp()

Set the timestamp string to be used by getNewIndex until further notice

tupleToString(aTuple)

Convert a gnx tuple returned by scanGnx to its string representation.

update()

Update self.timeString and self.lastIndex

updateLastIndex(gnx)

Update ni.lastIndex if the gnx affects it.

class leo.core.leoNodes.PosList

Bases: list

children()

Return a PosList instance containing pointers to all the immediate children of nodes in PosList self.

filter_b(regex, flags=2)

Find all the nodes in PosList self where body matches regex one or more times.

filter_h(regex, flags=2)

Find all the nodes in PosList self where zero or more characters at the beginning of the headline match regex

class leo.core.leoNodes.Position(v, childIndex=0, stack=None)

Bases: object

anyAtFileNodeName()

archivedPosition(root_p=None)

Return a representation of a position suitable for use in .leo files.

atAsisFileNodeName()

atAutoNodeName()

atCleanNodeName()

atEditNodeName()

atFileNodeName()

atNoSentFileNodeName()

atNoSentinelsFileNodeName()

atShadowFileNodeName()

atSilentFileNodeName()

atThinFileNodeName()

b

position body string property

back()

badUnlink(parent_v, n, child)

bodyString()

checkVisBackLimit(limit, limitIsVisible, p)

Return done, p or None

checkVisNextLimit(limit, p)

Return True is p is outside limit of visible nodes.

childIndex()

children()

Yield all child positions of p.

children_iter()

Yield all child positions of p.

cleanHeadString()

clearAllVisitedInTree()

clearDirty()

16. Set p.v dirty.

clearMarked()

clearOrphan()

clearVisited()

clearVisitedInTree()

clone()

Create a clone of back.

Returns the newly created position.

computeIcon()

contract()

Contract p.v and clear p.v.expandedPositions list.

convertTreeToString()

Convert a positions suboutline to a string in MORE format.

copy()

“Return an independent copy of a position.

copyTreeAfter(copyGnxs=False)

Copy p and insert it after itself.

copyTreeFromSelfTo(p2, copyGnxs=False)

copyWithNewVnodes(copyMarked=False)

Return an unliked copy of p with a new vnode v. The new vnode is complete copy of v and all its descendants.

createNodeHierarchy(heads, forcecreate=False)

Create the proper hierarchy of nodes with headlines defined in ‘heads’ as children of the current position

params: heads - list of headlines in order to create, i.e. [‘foo’,’bar’,’baz’]

will create:

self -foo –bar —baz

forcecreate - If False (default), will not create nodes unless they don’t exist

If True, will create nodes regardless of existing nodes

returns the final position (‘baz’ in the above example)

deleteAllChildren()

Delete all children of the receiver.

directParents()

doDelete(newNode=None)

Deletes position p from the outline.

dump(label='')

dumpLink(link)

expand()

findAllPotentiallyDirtyNodes()

findRootPosition()

firstChild()

following_siblings()

Yield all siblings positions that follow p, not including p.

following_siblings_iter()

Yield all siblings positions that follow p, not including p.

getBack()

getFirstChild()

getLastChild()

getLastNode()

getNext()

getNodeAfterTree()

getNthChild(n)

getParent()

getThreadBack()

getThreadNext()

getVisBack(c)

getVisNext(c)

get_UNL(with_file=True, with_proto=False, with_index=True, with_count=False)

with_file=True - include path to Leo file with_proto=False - include ‘file://’ with_index - include ‘,x’ at end where x is child index in parent with_count - include ‘,x,y’ at end where y zero based count of same headlines

gnx

position gnx property

h

position property returning the headline string

hasBack()

hasChildren()

hasFirstChild()

hasNext()

hasParent()

hasThreadBack()

hasThreadNext()

hasVisBack(c)

hasVisNext(c)

headString()

inAtIgnoreRange()

Returns True if position p or one of p’s parents is an @ignore node.

in_at_all_tree()

Return True if p or one of p’s ancestors is an @all node.

in_at_ignore_tree()

Return True if p or one of p’s ancestors is an @ignore node.

initBodyString(s)

initExpandedBit()

initHeadString(s)

initMarkedBit()

initStatus(status)

insertAfter()

Inserts a new position after self.

Returns the newly created position.

insertAsLastChild()

Inserts a new VNode as the last child of self.

Returns the newly created position.

insertAsNthChild(n)

Inserts a new node as the the nth child of self. self must have at least n-1 children.

Returns the newly created position.

insertBefore()

Inserts a new position before self.

Returns the newly created position.

invalidOutline(message)

isAncestorOf(p2)

Return True if p is one of the direct ancestors of p2.

isAnyAtFileNode()

isAtAllNode()

isAtAsisFileNode()

isAtAutoNode()

isAtAutoRstNode()

isAtCleanNode()

isAtEditNode()

isAtFileNode()

isAtIgnoreNode()

isAtNoSentFileNode()

isAtNoSentinelsFileNode()

isAtOthersNode()

isAtRstFileNode()

isAtShadowFileNode()

isAtSilentFileNode()

isAtThinFileNode()

isCloned()

isDirty()

isExpanded()

isMarked()

isOrphan()

isOutsideAnyAtFileTree()

Select the first clone of target that is outside any @file node.

isRoot()

isSelected()

isTopBitSet()

isVisible(c)

Return True if p is visible in c’s outline.

isVisited()

is_at_all()

Return True if p.b contains an @all directive.

is_at_ignore()

Return True if p is an @ignore node.

key()

lastChild()

lastNode()

level()

Return the number of p’s parents.

matchHeadline(pattern)

moreBody()

Returns the body string in MORE format.

Inserts a backslash before any leading plus, minus or backslash.

moreHead(firstLevel, useVerticalBar=False)

Return the headline string in MORE format.

moveAfter(a)

Move a position after position a.

moveToBack()

Move self to its previous sibling.

moveToFirstChild()

Move a position to it’s first child’s position.

moveToFirstChildOf(parent)

Move a position to the first child of parent.

moveToLastChild()

Move a position to it’s last child’s position.

moveToLastChildOf(parent)

Move a position to the last child of parent.

moveToLastNode()

Move a position to last node of its tree.

N.B. Returns p if p has no children.

moveToNext()

Move a position to its next sibling.

moveToNodeAfterTree()

Move a position to the node after the position’s tree.

moveToNthChild(n)

moveToNthChildOf(parent, n)

Move a position to the nth child of parent.

moveToParent()

Move a position to its parent position.

moveToRoot(oldRoot=None)

Moves a position to the root position.

Important: oldRoot must the previous root position if it exists.

moveToThreadBack()

Move a position to it’s threadBack position.

moveToThreadNext()

Move a position to threadNext position.

moveToVisBack(c)

Move a position to the position of the previous visible node.

moveToVisNext(c)

Move a position to the position of the next visible node.

nearest(predicate=None)

A generator yielding all unique root positions “near” p1 = self that satisfy the given predicate. p.isAnyAtFileNode is the default predicate.

The search first proceeds up the p’s tree. If a root is found, this generator yields just that root.

Otherwise, the generator yields all unique nodes in p.subtree() that satisfy the predicate. Once a root is found, the generator skips its subtree.

nearest_roots(predicate=None)

A generator yielding all the root positions “near” p1 = self that satisfy the given predicate. p.isAnyAtFileNode is the default predicate.

The search first proceeds up the p’s tree. If a root is found, this generator yields just that root.

Otherwise, the generator yields all nodes in p.subtree() that satisfy the predicate. Once a root is found, the generator skips its subtree.

nearest_unique_roots(predicate=None)

A generator yielding all unique root positions “near” p1 = self that satisfy the given predicate. p.isAnyAtFileNode is the default predicate.

The search first proceeds up the p’s tree. If a root is found, this generator yields just that root.

Otherwise, the generator yields all unique nodes in p.subtree() that satisfy the predicate. Once a root is found, the generator skips its subtree.

next()

nodeAfterTree()

nodes()

Yield p.v and all vnodes in p’s subtree.

nosentinels

position property returning the body text without sentinels

nthChild(n)

numberOfChildren()

parent()

parents()

Yield all parent positions of p.

parents_iter()

Yield all parent positions of p.

positionAfterDeletedTree()

Return the position corresponding to p.nodeAfterTree() after this node is deleted. This will be p.nodeAfterTree() unless p.next() exists.

This method allows scripts to traverse an outline, deleting nodes during the traversal. The pattern is:

p = c.rootPosition()
while p:
if <delete p?>:
    next = p.positionAfterDeletedTree()
    p.doDelete()
    p = next
else:
    p.moveToThreadNext()

This method also allows scripts to move nodes during a traversal, provided that nodes are moved to a “safe” spot so that moving a node does not change the position of any other nodes.

For example, the move-marked-nodes command first creates a move node, called ‘Clones of marked nodes’. All moved nodes become children of this move node. Inserting these nodes as children of the “move node” does not change the positions of other nodes. Deleting these nodes may change the position of nodes, but the pattern above handles this complication cleanly.

promote()

A low-level promote helper.

restoreCursorAndScroll()

safeMoveToThreadNext()

Move a position to threadNext position. Issue an error if any vnode is an ancestor of itself.

saveCursorAndScroll()

script

position property returning the script formed by p and its descendants

scriptSetBodyString(s)

self_and_parents()

Yield p and all parent positions of p.

self_and_parents_iter()

Yield p and all parent positions of p.

self_and_siblings()

Yield all sibling positions of p including p.

self_and_siblings_iter()

Yield all sibling positions of p including p.

self_and_subtree()

Yield p and all positions in p’s subtree.

self_and_subtree_iter()

Yield p and all positions in p’s subtree.

setAllAncestorAtFileNodesDirty(setDescendentsDirty=False)

setBodyString(s)

setDirty(setDescendentsDirty=True)

Mark a node and all ancestor @file nodes dirty.

Warning: p.setDirty() is expensive because it calls p.setAllAncestorAtFileNodesDirty().

Usually, code should this setter, despite its cost, because it update’s Leo’s outline pane properly. Calling c.redraw() is not enough.

setHeadString(s)

setIcon()

setMarked()

setOrphan()

setSelected()

setSelection(start, length)

setTnodeText(s)

setVisited()

simpleLevel()

Return the number of p’s parents.

sort_key(p)

status()

subtree()

Yield all positions in p’s subtree, but not p.

subtree_iter()

Yield all positions in p’s subtree, but not p.

subtree_with_unique_tnodes_iter()

Yield p and all other unique positions in p’s subtree.

subtree_with_unique_vnodes_iter()

Yield p and all other unique positions in p’s subtree.

textOffset()

Return the fcol offset of self. Return None if p is has no ancestor @<file> node. http://tinyurl.com/5nescw

threadBack()

threadNext()

tnodes_iter()

Yield p.v and all vnodes in p’s subtree.

u

p.u property

unique_nodes()

Yield p.v and all unique vnodes in p’s subtree.

unique_subtree()

Yield p and all other unique positions in p’s subtree.

unique_tnodes_iter()

Yield p.v and all unique vnodes in p’s subtree.

unique_vnodes_iter()

Yield p.v and all unique vnodes in p’s subtree.

validateOutlineWithParent(pv)

visBack(c)

visNext(c)

vnodes_iter()

Yield p.v and all vnodes in p’s subtree.

leo.core.leoNodes.Poslist

alias of leo.core.leoNodes.PosList

leo.core.leoNodes.VNode

alias of leo.core.leoNodes.VNodeBase

class leo.core.leoNodes.VNodeBase(context, gnx=None)

Bases: object

anyAtFileNodeName()

Return the file name following an @file node or an empty string.

atAsisFileNodeName()

atAutoNodeName(h=None)

atAutoRstNodeName(h=None)

atCleanNodeName()

atEditNodeName()

atFileNodeName()

atNoSentFileNodeName()

atNoSentinelsFileNodeName()

atRstFileNodeName()

atShadowFileNodeName()

atSilentFileNodeName()

atThinFileNodeName()

b

VNode body string property

bodyString()

body_unicode_warning = False

childrenModified()

cleanHeadString()

clearClonedBit()

clearDirty()

Clear the vnode dirty bit.

clearMarked()

clearOrphan()

clearVisited()

clearWriteBit()

cloneAsNthChild(parent_v, n)

clonedBit = 1

computeIcon()

contentModified()

contract()

Contract the node.

copyTree(copyMarked=False)

Return an all-new tree of vnodes that are copies of self and all its descendants.

Important: the v.parents ivar must be [] for all nodes. v._addParentLinks will set all parents.

directParents()

(New in 4.2) Return a list of all direct parent vnodes of a VNode.

This is NOT the same as the list of ancestors of the VNode.

dirtyBit = 512

dump(label='')

dumpLink(link)

expand()

Expand the node.

expandedBit = 4

findAllPotentiallyDirtyNodes()

findAtFileName(names, h='')

Return the name following one of the names in nameList or “”

firstChild()

getBody()

gnx

VNode gnx property

h

VNode headline string property

hasBody()

Return True if this VNode contains body text.

hasChildren()

hasFirstChild()

headString()

Return the headline string.

head_unicode_warning = False

initBodyString(s)

initClonedBit(val)

initExpandedBit()

Init self.statusBits.

initHeadString(s)

initMarkedBit()

initStatus(status)

insertAsFirstChild()

insertAsLastChild()

insertAsNthChild(n)

isAnyAtFileNode()

Return True if v is any kind of @file or related node.

isAtAllNode()

Returns True if the receiver contains @others in its body at the start of a line.

isAtAsisFileNode()

isAtAutoNode()

isAtAutoRstNode()

isAtCleanNode()

isAtEditNode()

isAtFileNode()

isAtIgnoreNode()

Returns True if the receiver contains @ignore in its body at the start of a line.

or if the headline starts with @ignore.

isAtNoSentFileNode()

isAtNoSentinelsFileNode()

isAtOthersNode()

Returns True if the receiver contains @others in its body at the start of a line.

isAtRstFileNode()

isAtShadowFileNode()

isAtSilentFileNode()

isAtThinFileNode()

isCloned()

isDirty()

isExpanded()

Return True if the VNode expansion bit is set.

isMarked()

isNthChildOf(n, parent_v)

Return True if v is the n’th child of parent_v.

isOrphan()

isSelected()

isTopBitSet()

isVisited()

isWriteBit()

lastChild()

markedBit = 8

matchHeadline(pattern)

Returns True if the headline matches the pattern ignoring whitespace and case.

The headline may contain characters following the successfully matched pattern.

nthChild(n)

numberOfChildren()

orphanBit = 2048

restoreCursorAndScroll()

Restore the cursor position and scroll so it is visible.

richTextBit = 128

saveCursorAndScroll()

selectedBit = 32

setAllAncestorAtFileNodesDirty()

setBodyString(s)

setClonedBit()

setDirty()

Set the vnode dirty bit.

setHeadString(s)

setHeadText(s)

setIcon()

setMarked()

setOrphan()

Set the vnode’s orphan bit.

setSelected()

setSelection(start, length)

setTnodeText(s)

setVisited()

setWriteBit()

status()

topBit = 64

u

VNode u property

unicode_warning_given = False

visitedBit = 256

writeBit = 1024

leo.core.leoNodes.position

alias of leo.core.leoNodes.Position

leo.core.leoNodes.vnode

alias of leo.core.leoNodes.VNodeBase

leoPlugins Module

Classes relating to Leo’s plugin architecture.

class leo.core.leoPlugins.BaseLeoPlugin(tag, keywords)

Bases: object

A Convenience class to simplify plugin authoring

• import the base class:

  from leoPlugins import leo.core.leoBasePlugin as leoBasePlugin
  

• create a class which inherits from leoBasePlugin:

  class myPlugin(leoBasePlugin):
  

• in the __init__ method of the class, call the parent constructor:

  def __init__(self, tag, keywords):
      leoBasePlugin.__init__(self, tag, keywords)
  

• put the actual plugin code into a method; for this example, the work is done by myPlugin.handler()

• put the class in a file which lives in the <LeoDir>/plugins directory

  for this example it is named myPlugin.py

• add code to register the plugin:

  leoPlugins.registerHandler("after-create-leo-frame", Hello)
  

BaseLeoPlugins has 3 methods for setting commands

• setCommand:

  def setCommand(self, commandName, handler,
          shortcut = None, pane = 'all', verbose = True):
  

• setMenuItem:

  def setMenuItem(self, menu, commandName = None, handler = None):
  

• setButton:

  def setButton(self, buttonText = None, commandName = None, color = None):
  

variables

CommandName:the string typed into minibuffer to execute the handler Handler:the method in the class which actually does the work Shortcut:the key combination to activate the command Menu:a string designating on of the menus (‘File’, Edit’, ‘Outline’, …) ButtonText:the text to put on the button if one is being created.

Contents of file <LeoDir>/plugins/hello.py:

class Hello(BaseLeoPlugin):
    def __init__(self, tag, keywords):

        # call parent __init__
        BaseLeoPlugin.__init__(self, tag, keywords)

        # if the plugin object defines only one command,
        # just give it a name. You can then create a button and menu entry
        self.setCommand('Hello', self.hello)
        self.setButton()
        self.setMenuItem('Cmds')

        # create a command with a shortcut
        self.setCommand('Hola', self.hola, 'Alt-Ctrl-H')

        # create a button using different text than commandName
        self.setButton('Hello in Spanish')

        # create a menu item with default text
        self.setMenuItem('Cmds')

        # define a command using setMenuItem
        self.setMenuItem('Cmds', 'Ciao baby', self.ciao)

    def hello(self, event):
        g.pr("hello from node %s" % self.c.p.h)

    def hola(self, event):
        g.pr("hola from node %s" % self.c.p.h)

    def ciao(self, event):
        g.pr("ciao baby (%s)" % self.c.p.h)

leoPlugins.registerHandler("after-create-leo-frame", Hello)

setButton(buttonText=None, commandName=None, color=None)

Associate an existing command with a ‘button’

setCommand(commandName, handler, shortcut='', pane='all', verbose=True)

Associate a command name with handler code, optionally defining a keystroke shortcut

setMenuItem(menu, commandName=None, handler=None)

Create a menu item in ‘menu’ using text ‘commandName’ calling handler ‘handler’ if commandName and handler are none, use the most recently defined values

class leo.core.leoPlugins.CommandChainDispatcher(commands=None)

Bases: object

Dispatch calls to a chain of commands until some func can handle it

Usage: instantiate, execute “add” to add commands (with optional priority), execute normally via f() calling mechanism.

add(func, priority=0)

Add a func to the cmd chain with given priority

class leo.core.leoPlugins.LeoPluginsController

Bases: object

The global plugins controller, g.app.pluginsController

callTagHandler(bunch, tag, keywords)

Call the event handler.

doHandlersForTag(tag, keywords)

Execute all handlers for a given tag, in alphabetical order. The caller, doHook, catches all exceptions.

doPlugins(tag, keywords)

The default g.app.hookFunction.

finishCreate()

getHandlersForOneTag(tag)

getHandlersForTag(tags)

getLoadedPlugins()

getPluginModule(moduleName)

isLoaded(fn)

loadHandlers(tag, keys)

Load all enabled plugins.

Using a module name (without the trailing .py) allows a plugin to be loaded from outside the leo/plugins directory.

loadOnePlugin(moduleOrFileName, tag='open0', verbose=False)

Load one plugin from a file name or module. Use extensive tracing if –trace-plugins is in effect.

Using a module name allows plugins to be loaded from outside the leo/plugins directory.

on_idle()

Call all idle-time hooks.

plugin_signon(module_name, verbose=False)

Print the plugin signon.

printHandlers(c, moduleName=None)

Print the handlers for each plugin.

printPlugins(c)

Print all enabled plugins.

printPluginsInfo(c)

Print the file name responsible for loading a plugin.

This is the first .leo file containing an @enabled-plugins node that enables the plugin.

registerExclusiveHandler(tags, fn)

Register one or more exclusive handlers

registerHandler(tags, fn)

Register one or more handlers

registerOneExclusiveHandler(tag, fn)

Register one exclusive handler

registerOneHandler(tag, fn)

Register one handler

regularizeName(fn)

Return the name used as a key to this modules dictionaries.

reloadSettings()

setLoaded(fn, m)

unloadOnePlugin(moduleOrFileName, verbose=False)

unregisterHandler(tags, fn)

unregisterOneHandler(tag, fn)

exception leo.core.leoPlugins.TryNext(*args, **kwargs)

Bases: exceptions.Exception

Try next hook exception.

Raise this in your hook function to indicate that the next hook handler should be used to handle the operation. If you pass arguments to the constructor those arguments will be used by the next hook instead of the original ones.

leo.core.leoPlugins.init()

Init g.app.pluginsController.

leo.core.leoPlugins.registerHandler(tags, fn)

A wrapper so plugins can still call leoPlugins.registerHandler.

leoPymacs Module

A module to allow the Pymacs bridge to access Leo data.

All code in this module must be called from Emacs: calling Pymacs.lisp in other situations will hang Leo.

Notes:

• The init method adds the parent directory of leoPymacs.py to Python’s sys.path. This is essential to make imports work from inside Emacs.

• As of Leo 4.5, the following code, when executed from an Emacs buffer, will open trunk/leo/test.leo:

  (pymacs-load "c:\leo.repo\trunk\leo\core\leoPymacs" "leo-")
  (setq c (leo-open "c:\leo.repo\trunk\leo\test\test.leo"))
  

  Note that full path names are required in each case.

leo.core.leoPymacs.dump(anObject)

leo.core.leoPymacs.get_app()

Scripts can use g.app.scriptDict for communication with pymacs.

leo.core.leoPymacs.get_g()

leo.core.leoPymacs.hello()

leo.core.leoPymacs.init()

leo.core.leoPymacs.open(fileName=None)

leo.core.leoPymacs.run_script(c, script, p=None)

leo.core.leoPymacs.script_result()

leoRst Module

leoSessions Module

Support for sessions in Leo.

exception leo.core.leoSessions.LeoSessionException

Bases: exceptions.Exception

class leo.core.leoSessions.SessionManager

Bases: object

clear_session(c)

Close all tabs except the presently selected tab.

get_session()

Return a list of UNLs for open tabs.

get_session_path()

Return the path to the session file.

load_session(c=None, unls=None)

Open a tab for each item in UNLs & select the indicated node in each.

load_snapshot()

Load a snapshot of a session from the leo.session file.

Called when –restore-session is in effect.

save_snapshot(c=None)

Save a snapshot of the present session to the leo.session file.

Called automatically during shutdown when –session-save is in effect.

leo.core.leoSessions.session_clear_command(event)

Close all tabs except the presently selected tab.

leo.core.leoSessions.session_create_command(event)

Create a new @session node.

leo.core.leoSessions.session_refresh_command(event)

Refresh the current @session node.

leo.core.leoSessions.session_restore_command(event)

Open a tab for each item in the @session node & select the indicated node in each.

leo.core.leoSessions.session_snapshot_load_command(event)

Load a snapshot of a session from the leo.session file.

leo.core.leoSessions.session_snapshot_save_command(event)

Save a snapshot of the present session to the leo.session file.

leoShadow Module

leoShadow.py

This code allows users to use Leo with files which contain no sentinels and still have information flow in both directions between outlines and derived files.

Private files contain sentinels: they live in the Leo-shadow subdirectory. Public files contain no sentinels: they live in the parent (main) directory.

When Leo first reads an @shadow we create a file without sentinels in the regular directory.

The slightly hard thing to do is to pick up changes from the file without sentinels, and put them into the file with sentinels.

Settings: - @string shadow_subdir (default: .leo_shadow): name of the shadow directory.

• @string shadow_prefix (default: x): prefix of shadow files. This prefix allows the shadow file and the original file to have different names. This is useful for name-based tools like py.test.

class leo.core.leoShadow.ShadowController(c, trace=False, trace_writers=False)

Bases: object

A class to manage @shadow files

class AtShadowTestCase(c, p, shadowController, delims=None, trace=False)

Bases: unittest.case.TestCase

Support @shadow-test nodes.

These nodes should have two descendant nodes: ‘before’ and ‘after’.

createSentinelNode(root, p)

Write p’s tree to a string, as if to a file.

fail(msg=None)

Mark an AtShadowTestCase as having failed.

findNode(c, p, headline)

Return the node in p’s subtree with given headline.

makePrivateLines(p)

Return a list of the lines of p containing sentinels.

makePublicLines(lines)

Return the public lines in lines.

mungePrivateLines(lines, find, replace)

Change the ‘find’ the ‘replace’ pattern in sentinel lines.

runTest(define_g=True)

AtShadowTestCase.runTest.

setUp()

AtShadowTestCase.setup.

shortDescription()

AtShadowTestCase.shortDescription.

tearDown()

AtShadowTestCase.tearDown.

class Marker(delims)

Bases: object

A class representing comment delims in @shadow files.

getDelims()

Return the pair of delims to be used in sentinel lines.

isSentinel(s, suffix='')

Return True is line s contains a valid sentinel comment.

isVerbatimSentinel(s)

Return True if s is an @verbatim sentinel.

baseDirName()

check_output()

Check that we produced a valid output.

dirName(filename)

Return the directory for filename.

dump_args()

Dump the argument lines.

dump_lines(lines, title)

Dump the given lines.

error(s, silent=False)

findLeoLine(lines)

Return the @+leo line, or ‘’.

init_data()

Init x.sentinels and x.trailing_sentinels arrays. Return the list of non-sentinel lines in x.old_sent_lines.

init_ivars(new_public_lines, old_private_lines, marker)

Init all ivars used by propagate_changed_lines & its helpers.

isSignificantPublicFile(fn)

This tells the AtFile.read logic whether to import a public file or use an existing public file.

makeShadowDirectory(fn)

Make a shadow directory for the public fn.

markerFromFileLines(lines, fn)

Return the sentinel delimiter comment to be used for filename.

markerFromFileName(filename)

Return the sentinel delimiter comment to be used for filename.

message(s)

op_bad(tag, ai, aj, bi, bj)

Report an unexpected opcode.

op_delete(tag, ai, aj, bi, bj)

Handle the ‘delete’ opcode.

op_equal(tag, ai, aj, bi, bj)

Handle the ‘equal’ opcode.

op_insert(tag, ai, aj, bi, bj)

Handle the ‘insert’ opcode.

op_replace(tag, ai, aj, bi, bj)

Handle the ‘replace’ opcode.

pathName(filename)

Return the full path name of filename.

preprocess(lines)

Preprocess public lines, adding newlines as needed. This happens before the diff.

propagate_changed_lines(new_public_lines, old_private_lines, marker, p=None)

The Mulder update algorithm, revised by EKR.

Use the diff between the old and new public lines to insperse sentinels from old_private_lines into the result.

The algorithm never deletes or rearranges sentinels. However, verbatim sentinels may be inserted or deleted as needed.

propagate_changes(old_public_file, old_private_file)

Propagate the changes from the public file (without_sentinels) to the private file (with_sentinels)

put_plain_line(line)

Put a plain line to x.results, inserting verbatim lines if necessary.

put_sentinels(i)

Put all the sentinels to the results

reloadSettings()

ShadowController.reloadSettings.

replaceFileWithString(fn, s)

Replace the file with s if s is different from theFile’s contents.

Return True if theFile was changed.

separate_sentinels(lines, marker)

Separates regular lines from sentinel lines. Do not return @verbatim sentinels.

Returns (regular_lines, sentinel_lines)

shadowDirName(filename)

Return the directory for the shadow file corresponding to filename.

shadowPathName(filename)

Return the full path name of filename, resolved using c.fileName()

show_error(lines1, lines2, message, lines1_message, lines2_message)

show_error_lines(lines, fileName)

unlink(filename, silent=False)

Unlink filename from the file system. Give an error on failure.

updatePublicAndPrivateFiles(root, fn, shadow_fn)

handle crucial @shadow read logic.

This will be called only if the public and private files both exist.

verbatim_error()

leoTangle Module

Support for @root and Leo’s tangle and untangle commands.

Everything in this file is deprecated, but will remain “forever”.

class leo.core.leoTangle.BaseTangleCommands(c)

Bases: object

The base class for Leo’s tangle and untangle commands.

class RegexpForLanguageOrComment

Bases: object

re = <module 're' from '/home/docs/checkouts/readthedocs.org/user_builds/leo-editor/envs/latest/lib/python2.7/re.pyc'>

regex = <_sre.SRE_Pattern object>

cleanup()

compare_comments(s1, s2)

compare_section_names(s1, s2)

copy(s)

error(s)

forgiving_compare(name, part, s1, s2)

handle_newline(s, i, delims)

initTangleCommand()

initUntangleCommand()

init_directive_ivars()

init_ivars()

is_end_of_directive(s, i)

is_end_of_string(s, i, delim)

is_escaped(s, i)

is_section_name(s, i)

is_sentinel_line(s, i)

is_sentinel_line_with_data(s, i)

mismatch(message)

oblank()

oblanks(n)

onl()

os(s)

otab()

otabs(n)

parent_language_comment_settings(p, lang_dict)

pathError(s)

push_new_DefNode(name, indent, part, of, nl_flag)

push_parts(reflist)

put_PartNode(part, no_first_lws_flag)

put_all_roots()

put_code(s, no_first_lws_flag, delims)

put_doc(s, delims)

put_leading_ws(n)

put_newline(s, i, no_first_lws_flag)

put_section(s, i, name, name_end, delims)

refpart_stack_dump()

reloadSettings()

reload_settings()

scanAllDirectives(p)

Scan VNode p and p’s ancestors looking for directives, setting corresponding tangle ivars and globals.

scan_derived_file(s)

scan_short_val(s, i)

section_check(name)

select_next_sentinel(part_start_flag=True)

The next sentinel will be either (a) a section part reference, using the “before” comment style for that part - when there are section references yet to interpolate for this part - when we’re followed by another part for this section (b) an end sentinel using the “after” comment style for the current part - when we’ve exhausted the parts for this section or (c) end of file for the root section The above requires that the parts in the tst be aware of the section interpolations each part will make

setRootFromHeadline(p)

setRootFromText(s, report_errors=True)

skip_body(p, delims)

The following subsections contain the interface between the Tangle and Untangle commands. This interface is an important hack, and allows Untangle to avoid duplicating the logic in skip_tree and its allies.

The aha is this: just at the time the Tangle command enters a definition into the symbol table, all the information is present that Untangle needs to update that definition.

To get whitespace exactly right we retain the outline’s leading whitespace and remove leading whitespace from the updated definition.

skip_code(s, i, delims)

skip_doc(s, i, delims)

skip_headline(p)

skip_section_name(s, i)

st_check()

Checks the given symbol table for defined but never referenced sections.

st_dump(verbose_flag=True)

st_dump_node(section)

st_enter(name, code, doc, delims_begin, delims_end, is_root_flag=False)

Enters names and their associated code and doc parts into the given symbol table.

st_enter_root_name(name, code, doc, delims_begin, delims_end)

st_enter_section_name(name, code, doc, delims_begin, delims_end)

Enters a section name into the given symbol table.

The code and doc pointers are None for references.

st_lookup(name, is_root_flag=False)

Looks up name in the symbol table and creates a TstNode for it if it does not exist.

standardize_name(name)

Removes leading and trailing brackets, converts white space to a single blank and converts to lower case.

tangle(event=None, p=None)

tangleAll(event=None)

tangleMarked(event=None)

tanglePass1(p_in, delims)

The main routine of tangle pass 1

tanglePass2()

tangleTree(p, report_errors)

Tangles all nodes in the tree whose root is p.

Reports on its results if report_errors is True.

token_type(s, i, report_errors=True)

This method returns a code indicating the apparent kind of token at the position i.

The caller must determine whether section definiton tokens are valid.

returns (kind, end) and sets global root_name using setRootFromText(). end is only valid for kind in (section_ref, section_def, at_root).

untangle(event=None, p=None)

untangleAll(event=None)

untangleMarked(event=None)

untangleRoot(root, begin, end)

untangleTree(p, report_errors)

update_current_vnode(s)

Called from within the Untangle logic to update the body text of self.p.

update_def(name, part_number, head, code, tail, is_root_flag=False)

ust_dump()

ust_enter(name, part, of, code, nl_flag, is_root_flag=False)

This routine enters names and their code parts into the given table. The ‘part’ and ‘of’ parameters are taken from the “(part n of m)” portion of the line that introduces the section definition in the C code.

If no part numbers are given the caller should set the ‘part’ and ‘of’ parameters to zero. The caller is reponsible for checking for duplicate parts.

This function handles names scanned from a source file; the corresponding st_enter routine handles names scanned from outlines.

ust_lookup(name, part_number, is_root_flag=False, update_flag=False)

Search the given table for a part matching the name and part number.

ust_warn_about_orphans()

Issues a warning about any sections in the derived file for which no corresponding section has been seen in the outline.

warning(s)

class leo.core.leoTangle.DefNode(name, indent, part, of, nl_flag, code)

Bases: object

class leo.core.leoTangle.PartNode(name, code, doc, is_root, is_dirty, delims)

Bases: object

reflist(refs=False)

class leo.core.leoTangle.RootAttributes(tangle_state)

Bases: object

class leo.core.leoTangle.TangleCommands(c)

Bases: leo.core.leoTangle.BaseTangleCommands

A class that implements Leo’ tangle and untangle commands.

class leo.core.leoTangle.TstNode(name, root_flag)

Bases: object

dump()

class leo.core.leoTangle.UstNode(name, code, part, of, nl_flag, update_flag)

Bases: object

dump()

leoTest Module

leoUndo Module

Leo’s undo/redo manager.

class leo.core.leoUndo.Undoer(c)

Bases: object

A class that implements unlimited undo and redo.

afterChangeGroup(p, undoType, reportFlag=False, dirtyVnodeList=None)

Create an undo node for general tree operations using d created by beforeChangeGroup

afterChangeNodeContents(p, command, bunch, dirtyVnodeList=None, inHead=False)

Create an undo node using d created by beforeChangeNode.

afterChangeTree(p, command, bunch)

Create an undo node for general tree operations using d created by beforeChangeTree

afterClearRecentFiles(bunch)

afterCloneMarkedNodes(p)

afterCloneNode(p, command, bunch, dirtyVnodeList=None)

afterCopyMarkedNodes(p)

afterDehoist(p, command)

afterDeleteMarkedNodes(data, p)

afterDeleteNode(p, command, bunch, dirtyVnodeList=None)

afterDemote(p, followingSibs, dirtyVnodeList)

Create an undo node for demote operations.

afterHoist(p, command)

afterInsertNode(p, command, bunch, dirtyVnodeList=None)

afterMark(p, command, bunch, dirtyVnodeList=None)

Create an undo node for mark and unmark commands.

afterMoveNode(p, command, bunch, dirtyVnodeList=None)

afterPromote(p, children, dirtyVnodeList)

Create an undo node for demote operations.

afterSort(p, bunch, dirtyVnodeList)

Create an undo node for sort operations

beforeChangeGroup(p, command, verboseUndoGroup=True)

Prepare to undo a group of undoable operations.

beforeChangeNodeContents(p, oldBody=None, oldHead=None, oldYScroll=None)

Return data that gets passed to afterChangeNode

beforeChangeTree(p)

beforeClearRecentFiles()

beforeCloneNode(p)

beforeDeleteNode(p)

beforeInsertNode(p, pasteAsClone=False, copiedBunchList=None)

beforeMark(p, command)

beforeMoveNode(p)

beforeSort(p, undoType, oldChildren, newChildren, sortChildren)

Create an undo node for sort operations.

canRedo()

canUndo()

clearOptionalIvars()

clearUndoState()

Clears then entire Undo state.

All non-undoable commands should call this method.

cmd()

Command decorator for the Undoer class.

createCommonBunch(p)

Return a bunch containing all common undo info. This is mostly the info for recreating an empty node at position p.

createTnodeUndoInfo(v)

Create a bunch containing all info needed to recreate a VNode.

createVnodeUndoInfo(v)

Create a bunch containing all info needed to recreate a VNode for undo.

cutStack()

dumpBead(n)

dumpTopBead()

enableMenuItems()

getBead(n)

Set Undoer ivars from the bunch at the top of the undo stack.

onSelect(old_p, p)

peekBead(n)

pushBead(bunch)

putIvarsToVnode(p)

recognizeStartOfTypingWord(old_lines, old_row, old_col, old_ch, new_lines, new_row, new_col, new_ch, prev_row, prev_col)

A potentially user-modifiable method that should return True if the typing indicated by the params starts a new ‘word’ for the purposes of undo with ‘word’ granularity.

u.setUndoTypingParams calls this method only when the typing could possibly continue a previous word. In other words, undo will work safely regardless of the value returned here.

old_ch is the char at the given (Tk) row, col of old_lines. new_ch is the char at the given (Tk) row, col of new_lines.

The present code uses only old_ch and new_ch. The other arguments are given for use by more sophisticated algorithms.

redo(event=None)

Redo the operation undone by the last undo.

redoClearRecentFiles()

redoCloneMarkedNodes()

redoCloneNode()

redoCopyMarkedNodes()

redoDehoistNode()

redoDeleteMarkedNodes()

redoDeleteNode()

redoDemote()

redoGroup()

Process beads until the matching ‘afterGroup’ bead is seen.

redoHelper()

redoHoistNode()

redoInsertNode()

redoMark()

redoMenuName(name)

redoMove()

redoNodeContents()

redoPromote()

redoSort()

redoTree()

Redo replacement of an entire tree.

redoTyping()

reloadSettings()

Undoer.reloadSettings.

restoreTnodeUndoInfo(bunch)

restoreTree(treeInfo)

Use the tree info to restore all VNode data, including all links.

restoreVnodeUndoInfo(bunch)

Restore all ivars saved in the bunch.

saveTree(p, treeInfo=None)

Return a list of tuples with all info needed to handle a general undo operation.

setIvarsFromBunch(bunch)

setIvarsFromVnode(p)

setRedoType(theType)

setUndoType(theType)

setUndoTypes()

setUndoTypingParams(p, undo_type, oldText, newText, oldSel=None, newSel=None, oldYview=None)

Save enough information to undo or redo typing operation.

Do nothing when called from the undo/redo logic because the Undo and Redo commands merely reset the bead pointer.

trace()

undo(event=None)

Undo the operation described by the undo parameters.

undoClearRecentFiles()

undoCloneMarkedNodes()

undoCloneNode()

undoCopyMarkedNodes()

undoDehoistNode()

undoDeleteMarkedNodes()

undoDeleteNode()

undoDemote()

undoGroup()

Process beads until the matching ‘beforeGroup’ bead is seen.

undoHelper()

undoHoistNode()

undoInsertNode()

undoMark()

undoMenuName(name)

undoMove()

undoNodeContents()

Undo all changes to the contents of a node, including headline and body text, and marked bits.

undoPromote()

undoRedoText(p, leading, trailing, oldMidLines, newMidLines, oldNewlines, newNewlines, tag='undo', undoType=None)

Handle text undo and redo: converts _new_ text into _old_ text.

undoRedoTree(p, new_data, old_data)

Replace p and its subtree using old_data during undo.

undoSort()

undoTree()

Redo replacement of an entire tree.

undoTyping()

updateMarks(oldOrNew)

Update dirty and marked bits.

leoVersion Module

A module holding the following version-related info:

leoVersion.branch: The git branch name, or ‘’. leoVersion.build: The timestamp field from commit_timestamp.json. leoVersion.date: The asctime field from commit_timestamp.json. leoVersion.version: Leo’s version number, set below.

runLeo Module