equals = re.compile('\s*=\s*')

ws = re.compile('\s+')

objend = re.compile('^\s*<\s*object')

weight = re.compile('\{weight=(\d+)\}')

inherit = re.compile('\{inherits=(\d+)\}')

wilds = re.compile('[\s\*\#\_]+')

nasties = re.compile('[^A-Za-z0-9 ]')

crlf = re.compile('<crlf>')

literal_w = re.compile(r'\\w')

array = re.compile(r'\@(.+?)\b')

def_syntax = re.compile(r'^.+(?:\s+.+|)\s*=\s*.+?$')

name_syntax = re.compile(r'[^a-z0-9_\-\s]')

utf8_trig = re.compile(r'[A-Z\\.]')

trig_syntax = re.compile(r'[^a-z0-9(\|)\[\]*_#@{}<>=\s]')

cond_syntax = re.compile(r'^.+?\s*(?:==|eq|!=|ne|<>|<|<=|>|>=)\s*.+?=>.+?$')

utf8_meta = re.compile(r'[\\<>]')

utf8_punct = re.compile(r'[.?,!;:@#$%^&*()]')

cond_split = re.compile(r'\s*=>\s*')

cond_parse = re.compile(r'^(.+?)\s+(==|eq|!=|ne|<>|<|<=|>|>=)\s+(.+?)$')

topic_tag = re.compile(r'\{topic=(.+?)\}')

set_tag = re.compile(r'<set (.+?)=(.+?)>')

bot_tag = re.compile(r'<bot (.+?)>')

get_tag = re.compile(r'<get (.+?)>')

star_tags = re.compile(r'<star(\d+)>')

botstars = re.compile(r'<botstar(\d+)>')

input_tags = re.compile(r'<input([1-9])>')

reply_tags = re.compile(r'<reply([1-9])>')

random_tags = re.compile(r'\{random\}(.+?)\{/random\}')

redir_tag = re.compile(r'\{@(.+?)\}')

tag_search = re.compile(r'<([^<]+?)>')

placeholder = re.compile(r'\x00(\d+)\x00')

zero_star = re.compile(r'^\*$')

"""A RiveScript interpreter for Python 2 and 3."""

# Concatenation mode characters.

_concat_modes = dict(

none="",

space=" ",

newline="\n",

)

############################################################################

# Initialization and Utility Methods #

############################################################################

def __init__(self, debug=False, strict=True, depth=50, log="", utf8=False):

"""Initialize a new RiveScript interpreter.

# Instance variables.

self._debug = debug # Debug mode

self._log = log # Debug log file

self._utf8 = utf8 # UTF-8 mode

self._strict = strict # Strict mode

self._depth = depth # Recursion depth limit

self._gvars = {} # 'global' variables

self._bvars = {} # 'bot' variables

self._subs = {} # 'sub' variables

self._person = {} # 'person' variables

self._arrays = {} # 'array' variables

self._users = {} # 'user' variables

self._freeze = {} # frozen 'user' variables

self._includes = {} # included topics

self._lineage = {} # inherited topics

self._handlers = {} # Object handlers

self._objlangs = {} # Languages of objects used

self._topics = {} # Main reply structure

self._thats = {} # %Previous reply structure

self._sorted = {} # Sorted buffers

self._syntax = {} # Syntax tracking (filenames & line no.'s)

self._regexc = { # Precomputed regexes for speed optimizations.

"trigger": {},

"subs": {},

"person": {},

}

# "Current request" variables.

self._current_user = None # The current user ID.

# Define the default Python language handler.

self._handlers["python"] = python.PyRiveObjects()

self._say("Interpreter initialized.")

@classmethod

def VERSION(self=None):

"""Return the version number of the RiveScript library.

return __version__

def _say(self, message):

if self._debug:

print("[RS] {}".format(message))

if self._log:

# Log it to the file.

fh = open(self._log, 'a')

fh.write("[RS] " + message + "\n")

fh.close()

def _warn(self, message, fname='', lineno=0):

header = "[RS]"

if self._debug:

header = "[RS::Warning]"

if len(fname) and lineno > 0:

print(header, message, "at", fname, "line", lineno)

else:

print(header, message)

############################################################################

# Loading and Parsing Methods #

############################################################################

def load_directory(self, directory, ext=None):

"""Load RiveScript documents from a directory.

self._say("Loading from directory: " + directory)

if ext is None:

# Use the default extensions - .rive is preferable.

ext = ['.rive', '.rs']

elif type(ext) == str:

# Backwards compatibility for ext being a string value.

ext = [ext]

if not os.path.isdir(directory):

self._warn("Error: " + directory + " is not a directory.")

return

for item in os.listdir(directory):

for extension in ext:

if item.lower().endswith(extension):

# Load this file.

self.load_file(os.path.join(directory, item))

break

def load_file(self, filename):

"""Load and parse a RiveScript document."""

self._say("Loading file: " + filename)

fh = codecs.open(filename, 'r', 'utf-8')

lines = fh.readlines()

fh.close()

self._say("Parsing " + str(len(lines)) + " lines of code from " + filename)

self._parse(filename, lines)

def stream(self, code):

"""Stream in RiveScript source code dynamically.

self._say("Streaming code.")

if type(code) in [str, text_type]:

code = code.split("\n")

self._parse("stream()", code)

def _parse(self, fname, code):

"""Parse RiveScript code into memory."""

self._say("Parsing code")

# Track temporary variables.

topic = 'random' # Default topic=random

lineno = 0 # Line numbers for syntax tracking

comment = False # In a multi-line comment

inobj = False # In an object

objname = '' # The name of the object we're in

objlang = '' # The programming language of the object

objbuf = [] # Object contents buffer

ontrig = '' # The current trigger

repcnt = 0 # Reply counter

concnt = 0 # Condition counter

isThat = '' # Is a %Previous trigger

# Local (file scoped) parser options.

local_options = dict(

concat="none", # Concat mode for ^Continue command

)

# Read each line.

for lp, line in enumerate(code):

lineno += 1

self._say("Line: " + line + " (topic: " + topic + ") incomment: " + str(inobj))

if len(line.strip()) == 0: # Skip blank lines

continue

# In an object?

if inobj:

if re.match(RE.objend, line):

# End the object.

if len(objname):

# Call the object's handler.

if objlang in self._handlers:

self._objlangs[objname] = objlang

self._handlers[objlang].load(objname, objbuf)

else:

self._warn("Object creation failed: no handler for " + objlang, fname, lineno)

objname = ''

objlang = ''

objbuf = []

inobj = False

else:

objbuf.append(line)

continue

line = line.strip() # Trim excess space. We do it down here so we

# don't mess up python objects!

# Look for comments.

if line[:2] == '//': # A single-line comment.

continue

elif line[0] == '#':

self._warn("Using the # symbol for comments is deprecated", fname, lineno)

elif line[:2] == '/*': # Start of a multi-line comment.

if '*/' not in line: # Cancel if the end is here too.

comment = True

continue

elif '*/' in line:

comment = False

continue

if comment:

continue

# Separate the command from the data.

if len(line) < 2:

self._warn("Weird single-character line '" + line + "' found.", fname, lineno)

continue

cmd = line[0]

line = line[1:].strip()

# Ignore inline comments if there's a space before and after

# the // symbols.

if " // " in line:

line = line.split(" // ")[0].strip()

# Run a syntax check on this line.

syntax_error = self.check_syntax(cmd, line)

if syntax_error:

# There was a syntax error! Are we enforcing strict mode?

syntax_error = "Syntax error in " + fname + " line " + str(lineno) + ": " \

+ syntax_error + " (near: " + cmd + " " + line + ")"

if self._strict:

raise Exception(syntax_error)

else:

self._warn(syntax_error)

return # Don't try to continue

# Reset the %Previous state if this is a new +Trigger.

if cmd == '+':

isThat = ''

# Do a lookahead for ^Continue and %Previous commands.

for i in range(lp + 1, len(code)):

lookahead = code[i].strip()

if len(lookahead) < 2:

continue

lookCmd = lookahead[0]

lookahead = lookahead[1:].strip()

# Only continue if the lookahead line has any data.

if len(lookahead) != 0:

# The lookahead command has to be either a % or a ^.

if lookCmd != '^' and lookCmd != '%':

break

# If the current command is a +, see if the following is

# a %.

if cmd == '+':

if lookCmd == '%':

isThat = lookahead

break

else:

isThat = ''

# If the current command is a ! and the next command(s) are

# ^, we'll tack each extension on as a line break (which is

# useful information for arrays).

if cmd == '!':

if lookCmd == '^':

line += "<crlf>" + lookahead

continue

# If the current command is not a ^ and the line after is

# not a %, but the line after IS a ^, then tack it on to the

# end of the current line.

if cmd != '^' and lookCmd != '%':

if lookCmd == '^':

line += self._concat_modes.get(

local_options["concat"], ""

) + lookahead

else:

break

self._say("Command: " + cmd + "; line: " + line)

# Handle the types of RiveScript commands.

if cmd == '!':

# ! DEFINE

halves = re.split(RE.equals, line, 2)

left = re.split(RE.ws, halves[0].strip(), 2)

value, type, var = '', '', ''

if len(halves) == 2:

value = halves[1].strip()

if len(left) >= 1:

type = left[0].strip()

if len(left) >= 2:

var = ' '.join(left[1:]).strip()

# Remove 'fake' line breaks unless this is an array.

if type != 'array':

value = re.sub(RE.crlf, '', value)

# Handle version numbers.

if type == 'version':

# Verify we support it.

try:

if float(value) > rs_version:

self._warn("Unsupported RiveScript version. We only support " + rs_version, fname, lineno)

return

except:

self._warn("Error parsing RiveScript version number: not a number", fname, lineno)

continue

# All other types of defines require a variable and value name.

if len(var) == 0:

self._warn("Undefined variable name", fname, lineno)

continue

elif len(value) == 0:

self._warn("Undefined variable value", fname, lineno)

continue

# Handle the rest of the types.

if type == 'local':

# Local file-scoped parser options.

self._say("\tSet parser option " + var + " = " + value)

local_options[var] = value

elif type == 'global':

# 'Global' variables

self._say("\tSet global " + var + " = " + value)

if value == '<undef>':

try:

del(self._gvars[var])

except:

self._warn("Failed to delete missing global variable", fname, lineno)

else:

self._gvars[var] = value

# Handle flipping debug and depth vars.

if var == 'debug':

if value.lower() == 'true':

value = True

else:

value = False

self._debug = value

elif var == 'depth':

try:

self._depth = int(value)

except:

self._warn("Failed to set 'depth' because the value isn't a number!", fname, lineno)

elif var == 'strict':

if value.lower() == 'true':

self._strict = True

else:

self._strict = False

elif type == 'var':

# Bot variables

self._say("\tSet bot variable " + var + " = " + value)

if value == '<undef>':

try:

del(self._bvars[var])

except:

self._warn("Failed to delete missing bot variable", fname, lineno)

else:

self._bvars[var] = value

elif type == 'array':

# Arrays

self._say("\tArray " + var + " = " + value)

if value == '<undef>':

try:

del(self._arrays[var])

except:

self._warn("Failed to delete missing array", fname, lineno)

continue

# Did this have multiple parts?

parts = value.split("<crlf>")

# Process each line of array data.

fields = []

for val in parts:

if '|' in val:

fields.extend(val.split('|'))

else:

fields.extend(re.split(RE.ws, val))

# Convert any remaining '\s' escape codes into spaces.

for f in fields:

f = f.replace('\s', ' ')

self._arrays[var] = fields

elif type == 'sub':

# Substitutions

self._say("\tSubstitution " + var + " => " + value)

if value == '<undef>':

try:

del(self._subs[var])

except:

self._warn("Failed to delete missing substitution", fname, lineno)

else:

self._subs[var] = value

# Precompile the regexp.

self._precompile_substitution("subs", var)

elif type == 'person':

# Person Substitutions

self._say("\tPerson Substitution " + var + " => " + value)

if value == '<undef>':

try:

del(self._person[var])

except:

self._warn("Failed to delete missing person substitution", fname, lineno)

else:

self._person[var] = value

# Precompile the regexp.

self._precompile_substitution("person", var)

else:

self._warn("Unknown definition type '" + type + "'", fname, lineno)

elif cmd == '>':

# > LABEL

temp = re.split(RE.ws, line)

type = temp[0]

name = ''

fields = []

if len(temp) >= 2:

name = temp[1]

if len(temp) >= 3:

fields = temp[2:]

# Handle the label types.

if type == 'begin':

# The BEGIN block.

self._say("\tFound the BEGIN block.")

type = 'topic'

name = '__begin__'

if type == 'topic':

# Starting a new topic.

self._say("\tSet topic to " + name)

ontrig = ''

topic = name

# Does this topic include or inherit another one?

mode = '' # or 'inherits' or 'includes'

if len(fields) >= 2:

for field in fields:

if field == 'includes':

mode = 'includes'

elif field == 'inherits':

mode = 'inherits'

elif mode != '':

# This topic is either inherited or included.

if mode == 'includes':

if name not in self._includes:

self._includes[name] = {}

self._includes[name][field] = 1

else:

if name not in self._lineage:

self._lineage[name] = {}

self._lineage[name][field] = 1

elif type == 'object':

# If a field was provided, it should be the programming

# language.

lang = None

if len(fields) > 0:

lang = fields[0].lower()

# Only try to parse a language we support.

ontrig = ''

if lang is None:

self._warn("Trying to parse unknown programming language", fname, lineno)

lang = 'python' # Assume it's Python.

# See if we have a defined handler for this language.

if lang in self._handlers:

# We have a handler, so start loading the code.

objname = name

objlang = lang

objbuf = []

inobj = True

else:

# We don't have a handler, just ignore it.

objname = ''

objlang = ''

objbuf = []

inobj = True

else:

self._warn("Unknown label type '" + type + "'", fname, lineno)

elif cmd == '<':

# < LABEL

type = line

if type == 'begin' or type == 'topic':

self._say("\tEnd topic label.")

topic = 'random'

elif type == 'object':

self._say("\tEnd object label.")

inobj = False

elif cmd == '+':

# + TRIGGER

self._say("\tTrigger pattern: " + line)

if len(isThat):

self._initTT('thats', topic, isThat, line)

self._initTT('syntax', topic, line, 'thats')

self._syntax['thats'][topic][line]['trigger'] = (fname, lineno)

else:

self._initTT('topics', topic, line)

self._initTT('syntax', topic, line, 'topic')

self._syntax['topic'][topic][line]['trigger'] = (fname, lineno)

ontrig = line

repcnt = 0

concnt = 0

# Pre-compile the trigger's regexp if possible.

self._precompile_regexp(ontrig)

elif cmd == '-':

# - REPLY

if ontrig == '':

self._warn("Response found before trigger", fname, lineno)

continue

self._say("\tResponse: " + line)

if len(isThat):

self._thats[topic][isThat][ontrig]['reply'][repcnt] = line

self._syntax['thats'][topic][ontrig]['reply'][repcnt] = (fname, lineno)

else:

self._topics[topic][ontrig]['reply'][repcnt] = line

self._syntax['topic'][topic][ontrig]['reply'][repcnt] = (fname, lineno)

repcnt += 1

elif cmd == '%':

# % PREVIOUS

pass # This was handled above.

elif cmd == '^':

# ^ CONTINUE

pass # This was handled above.

elif cmd == '@':

# @ REDIRECT

self._say("\tRedirect response to " + line)

if len(isThat):

self._thats[topic][isThat][ontrig]['redirect'] = line

self._syntax['thats'][topic][ontrig]['redirect'] = (fname, lineno)

else:

self._topics[topic][ontrig]['redirect'] = line

self._syntax['topic'][topic][ontrig]['redirect'] = (fname, lineno)

elif cmd == '*':

# * CONDITION

self._say("\tAdding condition: " + line)

if len(isThat):

self._thats[topic][isThat][ontrig]['condition'][concnt] = line

self._syntax['thats'][topic][ontrig]['condition'][concnt] = (fname, lineno)

else:

self._topics[topic][ontrig]['condition'][concnt] = line

self._syntax['topic'][topic][ontrig]['condition'][concnt] = (fname, lineno)

concnt += 1

else:

self._warn("Unrecognized command \"" + cmd + "\"", fname, lineno)

continue

def check_syntax(self, cmd, line):

"""Syntax check a RiveScript command and line.

# Run syntax checks based on the type of command.

if cmd == '!':

# ! Definition

# - Must be formatted like this:

# ! type name = value

# OR

# ! type = value

match = re.match(RE.def_syntax, line)

if not match:

return "Invalid format for !Definition line: must be '! type name = value' OR '! type = value'"

elif cmd == '>':

# > Label

# - The "begin" label must have only one argument ("begin")

# - "topic" labels must be lowercased but can inherit other topics (a-z0-9_\s)

# - "object" labels must follow the same rules as "topic", but don't need to be lowercase

parts = re.split(" ", line, 2)

if parts[0] == "begin" and len(parts) > 1:

return "The 'begin' label takes no additional arguments, should be verbatim '> begin'"

elif parts[0] == "topic":

match = re.match(RE.name_syntax, line)

if match:

return "Topics should be lowercased and contain only numbers and letters"

elif parts[0] == "object":

match = re.match(RE.name_syntax, line)

if match:

return "Objects can only contain numbers and letters"

elif cmd == '+' or cmd == '%' or cmd == '@':

# + Trigger, % Previous, @ Redirect

# This one is strict. The triggers are to be run through the regexp engine,

# therefore it should be acceptable for the regexp engine.

# - Entirely lowercase

# - No symbols except: ( | ) [ ] * _ # @ { } < > =

# - All brackets should be matched

parens = 0 # Open parenthesis

square = 0 # Open square brackets

curly = 0 # Open curly brackets

angle = 0 # Open angled brackets

# Count brackets.

for char in line:

if char == '(':

parens += 1

elif char == ')':

parens -= 1

elif char == '[':

square += 1

elif char == ']':

square -= 1

elif char == '{':

curly += 1

elif char == '}':

curly -= 1

elif char == '<':

angle += 1

elif char == '>':

angle -= 1

# Any mismatches?

if parens != 0:

return "Unmatched parenthesis brackets"

elif square != 0:

return "Unmatched square brackets"

elif curly != 0:

return "Unmatched curly brackets"

elif angle != 0:

return "Unmatched angle brackets"

# In UTF-8 mode, most symbols are allowed.

if self._utf8:

match = re.match(RE.utf8_trig, line)

if match:

return "Triggers can't contain uppercase letters, backslashes or dots in UTF-8 mode."

else:

match = re.match(RE.trig_syntax, line)

if match:

return "Triggers may only contain lowercase letters, numbers, and these symbols: ( | ) [ ] * _ # @ { } < > ="

elif cmd == '-' or cmd == '^' or cmd == '/':

# - Trigger, ^ Continue, / Comment

# These commands take verbatim arguments, so their syntax is loose.

pass

elif cmd == '*':

# * Condition

# Syntax for a conditional is as follows:

# * value symbol value => response

match = re.match(RE.cond_syntax, line)

if not match:

return "Invalid format for !Condition: should be like '* value symbol value => response'"

return None

def deparse(self):

"""Return the in-memory RiveScript document as a Python data structure.

# Data to return.

result = {

"begin": {

"global": {},

"var": {},

"sub": {},

"person": {},

"array": {},

"triggers": {},

"that": {},

},

"topic": {},

"that": {},

"inherit": {},

"include": {},

}

# Populate the config fields.

if self._debug:

result["begin"]["global"]["debug"] = self._debug

if self._depth != 50:

result["begin"]["global"]["depth"] = 50

# Definitions

result["begin"]["var"] = self._bvars.copy()

result["begin"]["sub"] = self._subs.copy()

result["begin"]["person"] = self._person.copy()

result["begin"]["array"] = self._arrays.copy()

result["begin"]["global"].update(self._gvars.copy())

# Topic Triggers.

for topic in self._topics:

dest = {} # Where to place the topic info

if topic == "__begin__":

# Begin block.

dest = result["begin"]["triggers"]

else:

# Normal topic.

if topic not in result["topic"]:

result["topic"][topic] = {}

dest = result["topic"][topic]

# Copy the triggers.

for trig, data in self._topics[topic].iteritems():

dest[trig] = self._copy_trigger(trig, data)

# %Previous's.

for topic in self._thats:

dest = {} # Where to place the topic info

if topic == "__begin__":

# Begin block.

dest = result["begin"]["that"]

else:

# Normal topic.

if topic not in result["that"]:

result["that"][topic] = {}

dest = result["that"][topic]

# The "that" structure is backwards: bot reply, then trigger, then info.

for previous, pdata in self._thats[topic].iteritems():

for trig, data in pdata.iteritems():

dest[trig] = self._copy_trigger(trig, data, previous)

# Inherits/Includes.

for topic, data in self._lineage.iteritems():

result["inherit"][topic] = []

for inherit in data:

result["inherit"][topic].append(inherit)

for topic, data in self._includes.iteritems():

result["include"][topic] = []

for include in data:

result["include"][topic].append(include)

return result

def write(self, fh, deparsed=None):

"""Write the currently parsed RiveScript data into a file.

# Passed a string instead of a file handle?

if type(fh) is str:

fh = codecs.open(fh, "w", "utf-8")

# Deparse the loaded data.

if deparsed is None:

deparsed = self.deparse()

# Start at the beginning.

fh.write("// Written by rivescript.deparse()\n")

fh.write("! version = 2.0\n\n")

# Variables of all sorts!

for kind in ["global", "var", "sub", "person", "array"]:

if len(deparsed["begin"][kind].keys()) == 0:

continue

for var in sorted(deparsed["begin"][kind].keys()):

# Array types need to be separated by either spaces or pipes.

data = deparsed["begin"][kind][var]

if type(data) not in [str, text_type]:

needs_pipes = False

for test in data:

if " " in test:

needs_pipes = True

break

# Word-wrap the result, target width is 78 chars minus the

# kind, var, and spaces and equals sign.

width = 78 - len(kind) - len(var) - 4

if needs_pipes:

data = self._write_wrapped("|".join(data), sep="|")

else:

data = " ".join(data)

fh.write("! {kind} {var} = {data}\n".format(

kind=kind,

var=var,

data=data,

))

fh.write("\n")

# Begin block.

if len(deparsed["begin"]["triggers"].keys()):

fh.write("> begin\n\n")

self._write_triggers(fh, deparsed["begin"]["triggers"], indent="\t")

fh.write("< begin\n\n")

# The topics. Random first!

topics = ["random"]

topics.extend(sorted(deparsed["topic"].keys()))

done_random = False

for topic in topics:

if topic not in deparsed["topic"]: continue

if topic == "random" and done_random: continue

if topic == "random": done_random = True

tagged = False # Used > topic tag

if topic != "random" or topic in deparsed["include"] or topic in deparsed["inherit"]:

tagged = True

fh.write("> topic " + topic)

if topic in deparsed["inherit"]:

fh.write(" inherits " + " ".join(deparsed["inherit"][topic]))

if topic in deparsed["include"]:

fh.write(" includes " + " ".join(deparsed["include"][topic]))

fh.write("\n\n")

indent = "\t" if tagged else ""

self._write_triggers(fh, deparsed["topic"][topic], indent=indent)

# Any %Previous's?

if topic in deparsed["that"]:

self._write_triggers(fh, deparsed["that"][topic], indent=indent)

if tagged:

fh.write("< topic\n\n")

return True

def _copy_trigger(self, trig, data, previous=None):

"""Make copies of all data below a trigger."""

# Copied data.

dest = {}

if previous:

dest["previous"] = previous

if "redirect" in data and data["redirect"]:

# @Redirect

dest["redirect"] = data["redirect"]

if "condition" in data and len(data["condition"].keys()):

# *Condition

dest["condition"] = []

for i in sorted(data["condition"].keys()):

dest["condition"].append(data["condition"][i])

if "reply" in data and len(data["reply"].keys()):

# -Reply

dest["reply"] = []

for i in sorted(data["reply"].keys()):

dest["reply"].append(data["reply"][i])

return dest

def _write_triggers(self, fh, triggers, indent=""):

"""Write triggers to a file handle."""

for trig in sorted(triggers.keys()):

fh.write(indent + "+ " + self._write_wrapped(trig, indent=indent) + "\n")

d = triggers[trig]

if "previous" in d:

fh.write(indent + "% " + self._write_wrapped(d["previous"], indent=indent) + "\n")

if "condition" in d:

for cond in d["condition"]:

fh.write(indent + "* " + self._write_wrapped(cond, indent=indent) + "\n")

if "redirect" in d:

fh.write(indent + "@ " + self._write_wrapped(d["redirect"], indent=indent) + "\n")

if "reply" in d:

for reply in d["reply"]:

fh.write(indent + "- " + self._write_wrapped(reply, indent=indent) + "\n")

fh.write("\n")

def _write_wrapped(self, line, sep=" ", indent="", width=78):

"""Word-wrap a line of RiveScript code for being written to a file."""

words = line.split(sep)

lines = []

line = ""

buf = []

while len(words):

buf.append(words.pop(0))

line = sep.join(buf)

if len(line) > width:

# Need to word wrap!

words.insert(0, buf.pop()) # Undo

lines.append(sep.join(buf))

buf = []

line = ""

# Straggler?

if line:

lines.append(line)

# Returned output

result = lines.pop(0)

if len(lines):

eol = ""

if sep == " ":

eol = "\s"

for item in lines:

result += eol + "\n" + indent + "^ " + item

return result

def _initTT(self, toplevel, topic, trigger, what=''):

"""Initialize a Topic Tree data structure."""

if toplevel == 'topics':

if topic not in self._topics:

self._topics[topic] = {}

if trigger not in self._topics[topic]:

self._topics[topic][trigger] = {}

self._topics[topic][trigger]['reply'] = {}

self._topics[topic][trigger]['condition'] = {}

self._topics[topic][trigger]['redirect'] = None