"""A RiveScript object handler for Python code."""

_objects = {} # The cache of objects loaded

def __init__(self):

pass

def load(self, name, code):

"""Prepare a Python code object given by the RiveScript interpreter."""

# We need to make a dynamic Python method.

source = "def RSOBJ(rs, args):\n"

for line in code:

source = source + "\t" + line + "\n"

try:

exec source

self._objects[name] = RSOBJ

except:

print "Failed to load code from object " + name

def call(self, rs, name, fields):

"""Invoke a previously loaded object."""

# Call the dynamic method.

func = self._objects[name]

reply = ''

try:

reply = func(rs, fields)

except:

reply = '[ERR: Error when executing Python object]'

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

_debug = False # Debug mode

_strict = True # Strict mode

_logf = '' # Log file for debugging

_depth = 50 # Recursion depth limit

_gvars = {} # 'global' variables

_bvars = {} # 'bot' variables

_subs = {} # 'sub' variables

_person = {} # 'person' variables

_arrays = {} # 'array' variables

_users = {} # 'user' variables

_freeze = {} # frozen 'user' variables

_includes = {} # included topics

_lineage = {} # inherited topics

_handlers = {} # Object handlers

_objlangs = {} # Languages of objects used

_topics = {} # Main reply structure

_thats = {} # %Previous reply structure

_sorted = {} # Sorted buffers

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

# Initialization and Utility Methods #

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

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

"""Initialize a new RiveScript interpreter.

self._debug = debug

self._strict = strict

self._depth = depth

self._log = log

# Define the default Python language handler.

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

self._say("Interpreter initialized.")

def _say(self, message):

if self._debug:

print "[RS]", 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):

if self._debug:

print "[RS::Warning]",

else:

print "[RS]",

if len(fname) and lineno > 0:

print message, "at", fname, "line", lineno

else:

print message

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

# Loading and Parsing Methods #

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

def load_directory(self, directory, ext='.rs'):

"""Load RiveScript documents from a directory."""

self._say("Loading from directory: " + directory + "/*" + ext)

if not os.path.isdir(directory):

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

return

for item in glob.glob( os.path.join(directory, '*'+ext) ):

self.load_file( item )

def load_file(self, filename):

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

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

fh = open(filename, 'r')

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.")

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

lastcmd = '' # Last command code

isThat = '' # Is a %Previous trigger

# Read each line.

for lp, line in enumerate(code):

lineno = 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 += 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(r'<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 == '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(r'\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

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

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 not name in self._includes:

self._includes[name] = {}

self._includes[name][field] = 1

else:

if not name 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 == None:

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

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)

else:

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

ontrig = line

repcnt = 0

concnt = 0

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

else:

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

repcnt = 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

else:

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

elif cmd == '*':

# * CONDITION

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

if len(isThat):

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

else:

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

concnt = 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(r'^.+(?:\s+.+|)\s*=\s*.+?$', 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":

rest = ' '.join(parts)

match = re.match(r'[^a-z0-9_\-\s]', line)

if match:

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

elif parts[0] == "object":

rest = ' '.join(parts)

match = re.match(r'[^A-Za-z0-9_\-\s]', 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

# Look for obvious errors.

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

if match:

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

# Count brackets.

for char in line:

if char == '(':

parens = parens + 1

elif char == ')':

parens = parens - 1

elif char == '[':

square = square + 1

elif char == ']':

square = square - 1

elif char == '{':

curly = curly + 1

elif char == '}':

curly = curly - 1

elif char == '<':

angle = angle + 1

elif char == '>':

angle = 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"

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(r'^.+?\s*(?:==|eq|!=|ne|<>|<|<=|>|>=)\s*.+?=>.+?$', line)

if not match:

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

return None

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

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

if toplevel == 'topics':

if not topic in self._topics:

self._topics[topic] = {}

if not trigger in self._topics[topic]:

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

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

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

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

elif toplevel == 'thats':

if not topic in self._thats:

self._thats[topic] = {}

if not trigger in self._thats[topic]:

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

if not what in self._thats[topic][trigger]:

self._thats[topic][trigger][what] = {}

self._thats[topic][trigger][what]['reply'] = {}

self._thats[topic][trigger][what]['condition'] = {}

self._thats[topic][trigger][what]['redirect'] = {}

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

# Sorting Methods #

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

def sort_replies(self, thats=False):

"""Sort the loaded triggers."""

# This method can sort both triggers and that's.

triglvl = None

sortlvl = None

if thats:

triglvl = self._thats

sortlvl = 'thats'

else:

triglvl = self._topics

sortlvl = 'topics'

# (Re)Initialize the sort cache.

self._sorted[sortlvl] = {}

self._say("Sorting triggers...")

# Loop through all the topics.

for topic in triglvl:

self._say("Analyzing topic " + topic)

# Collect a list of all the triggers we're going to need to worry

# about. If this topic inherits another topic, we need to

# recursively add those to the list.

alltrig = self._topic_triggers(topic, triglvl)

# Keep in mind here that there is a difference between 'includes'

# and 'inherits' -- topics that inherit other topics are able to

# OVERRIDE triggers that appear in the inherited topic. This means

# that if the top topic has a trigger of simply '*', then *NO*

# triggers are capable of matching in ANY inherited topic, because

# even though * has the lowest sorting priority, it has an automatic

# priority over all inherited topics.

#

# The _topic_triggers method takes this into account. All topics

# that inherit other topics will have their triggers prefixed with

# a fictional {inherits} tag, which would start at {inherits=0} and

# increment if the topic tree has other inheriting topics. So we can

# use this tag to make sure topics that inherit things will have

# their triggers always be on top of the stack, from inherits=0 to

# inherits=n.

# Sort these triggers.

running = self._sort_trigger_set(alltrig)

# Save this topic's sorted list.

if not sortlvl in self._sorted:

self._sorted[sortlvl] = {}

self._sorted[sortlvl][topic] = running

# And do it all again for %Previous!

if thats != True:

# This will sort the %Previous lines to best match the bot's last reply.

self.sort_replies(True)

# If any of those %Previous's had more than one +trigger for them,

# this will sort all those +triggers to pair back the best human

# interaction.

self._sort_that_triggers()

# Also sort both kinds of substitutions.

self._sort_list('subs', self._subs)

self._sort_list('person', self._person)

def _sort_that_triggers(self):

"""Make a sorted list of triggers that correspond to %Previous groups."""

self._say("Sorting reverse triggers for %Previous groups...")

if not "that_trig" in self._sorted:

self._sorted["that_trig"] = {}

for topic in self._thats:

if not topic in self._sorted["that_trig"]:

self._sorted["that_trig"][topic] = {}

for bottrig in self._thats[topic]:

if not bottrig in self._sorted["that_trig"][topic]:

self._sorted["that_trig"][topic][bottrig] = []

triggers = self._sort_trigger_set(self._thats[topic][bottrig].keys())

self._sorted["that_trig"][topic][bottrig] = triggers

def _sort_trigger_set(self, triggers):

"""Sort a group of triggers in optimal sorting order."""

# Create a priority map.

prior = {

0: [] # Default priority=0

}

for trig in triggers:

match, weight = re.search(re_weight, trig), 0

if match:

weight = int(match.group(1))

if not weight in prior:

prior[weight] = []

prior[weight].append(trig)

# Keep a running list of sorted triggers for this topic.

running = []

# Sort them by priority.

for p in sorted(prior.keys(), reverse=True):

self._say("\tSorting triggers with priority " + str(p))

# So, some of these triggers may include {inherits} tags, if they

# came form a topic which inherits another topic. Lower inherits

# values mean higher priority on the stack.

inherits = -1 # -1 means no {inherits} tag

highest_inherits = -1 # highest inheritence number seen

# Loop through and categorize these triggers.

track = {

inherits: self._init_sort_track()

}

for trig in prior[p]:

self._say("\t\tLooking at trigger: " + trig)

# See if it has an inherits tag.

match = re.search(re_inherit, trig)

if match:

inherits = int(match.group(1))

if inherits > highest_inherits:

highest_inherits = inherits

self._say("\t\t\tTrigger belongs to a topic which inherits other topics: level=" + str(inherits))

trig = re.sub(re_inherit, "", trig)

else:

inherits = -1

# If this is the first time we've seen this inheritence level,

# initialize its track structure.

if not inherits in track:

track[inherits] = self._init_sort_track()

# Start inspecting the trigger's contents.

if '_' in trig:

# Alphabetic wildcard included.

cnt = self._word_count(trig)

self._say("\t\t\tHas a _ wildcard with " + str(cnt) + " words.")

if cnt > 1:

if not cnt in track[inherits]['alpha']:

track[inherits]['alpha'][cnt] = []

track[inherits]['alpha'][cnt].append(trig)

else:

track[inherits]['under'].append(trig)

elif '#' in trig:

# Numeric wildcard included.

cnt = self._word_count(trig)

self._say("\t\t\tHas a # wildcard with " + str(cnt) + " words.")

if cnt > 1:

if not cnt in track[inherits]['number']:

track[inherits]['number'][cnt] = []

track[inherits]['number'][cnt].append(trig)

else:

track[inherits]['pound'].append(trig)

elif '*' in trig:

# Wildcard included.

cnt = self._word_count(trig)

self._say("\t\t\tHas a * wildcard with " + str(cnt) + " words.")

if cnt > 1:

if not cnt in track[inherits]['wild']:

track[inherits]['wild'][cnt] = []

track[inherits]['wild'][cnt].append(trig)

else:

track[inherits]['star'].append(trig)

elif '[' in trig:

# Optionals included.

cnt = self._word_count(trig)

self._say("\t\t\tHas optionals and " + str(cnt) + " words.")

if not cnt in track[inherits]['option']:

track[inherits]['option'][cnt] = []

track[inherits]['option'][cnt].append(trig)

else:

# Totally atomic.

cnt = self._word_count(trig)

self._say("\t\t\tTotally atomic and " + str(cnt) + " words.")

if not cnt in track[inherits]['atomic']:

track[inherits]['atomic'][cnt] = []

track[inherits]['atomic'][cnt].append(trig)

# Move the no-{inherits} triggers to the bottom of the stack.

track[ (highest_inherits + 1) ] = track[-1]

del(track[-1])

# Add this group to the sort list.

for ip in sorted(track.keys()):

self._say("ip=" + str(ip))

for kind in [ 'atomic', 'option', 'alpha', 'number', 'wild' ]:

for i in sorted(track[ip][kind], reverse=True):

running.extend( track[ip][kind][i] )

running.extend( sorted(track[ip]['under'], key=len, reverse=True) )

running.extend( sorted(track[ip]['pound'], key=len, reverse=True) )

running.extend( sorted(track[ip]['star'], key=len, reverse=True) )

return running

def _sort_list(self, name, items):

"""Sort a simple list by number of words and length."""

def by_length(word1, word2):

return len(word2)-len(word1)

# Initialize the list sort buffer.

if not "lists" in self._sorted:

self._sorted["lists"] = {}

self._sorted["lists"][name] = []

# Track by number of words.

track = {}

# Loop through each item.

for item in items:

# Count the words.

cword = self._word_count(item, all=True)

if not cword in track:

track[cword] = []

track[cword].append(item)

# Sort them.

output = []

for count in sorted(track.keys(), reverse=True):

sort = sorted(track[count], cmp=by_length)

output.extend(sort)

self._sorted["lists"][name] = output

def _init_sort_track(self):

"""Returns a new dict for keeping track of triggers for sorting."""

return {

'atomic': {}, # Sort by number of whole words

'option': {}, # Sort optionals by number of words

'alpha': {}, # Sort alpha wildcards by no. of words

'number': {}, # Sort number wildcards by no. of words

'wild': {}, # Sort wildcards by no. of words

'pound': [], # Triggers of just #

'under': [], # Triggers of just _

'star': [] # Triggers of just *

}

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

# Public Configuration Methods #

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

def set_handler(self, language, obj):

"""Define a custom language handler for RiveScript objects.

# Allow them to delete a handler too.

if obj == None:

if language in self._handlers:

del self._handlers[language]

else:

self._handlers[language] = obj

def set_subroutine(self, name, code):

"""Define a Python object from your program.

# Do we have a Python handler?

if 'python' in self._handlers:

self._handlers['python']._objects[name] = code

else:

self._warn("Can't set_subroutine: no Python object handler!")

def set_global(self, name, value):

"""Set a global variable.

if value == None:

# Unset the variable.

if name in self._gvars:

del self._gvars[name]

self._gvars[name] = value

def set_variable(self, name, value):

"""Set a bot variable.

if value == None:

# Unset the variable.

if name in self._bvars:

del self._bvars[name]

self._bvars[name] = value

def set_substitution(self, what, rep):

"""Set a substitution.

if rep == None:

# Unset the variable.

if what in self._subs:

del self._subs[what]

self._subs[what] = rep

def set_person(self, what, rep):

"""Set a person substitution.

if rep == None:

# Unset the variable.

if what in self._person:

del self._person[what]

self._person[what] = rep

def set_uservar(self, user, name, value):

"""Set a variable for a user."""

if not user in self._users:

self._users[user] = {"topic": "random"}

self._users[user][name] = value

def get_uservar(self, user, name):

"""Get a variable about a user.