Annikka/evennia
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Continuing to make more methods _private to simplify API.

Browse source
This commit is contained in:
Griatch 2012-03-31 16:09:48 +02:00
parent c8df141e89
commit d44dd92b5f
6 changed files with 277 additions and 268 deletions
Download patch file Download diff file Expand all files Collapse all files

38
src/commands/cmdhandler.py
View file

@ -44,25 +44,29 @@ from src.commands.cmdsethandler import import_cmdset
from src.utils import logger, utils from src.utils import logger, utils
from src.commands.cmdparser import at_multimatch_cmd from src.commands.cmdparser import at_multimatch_cmd
#This switches the command parser to a user-defined one. __all__ = ("cmdhandler",)
# You have to restart the server for this to take effect.
COMMAND_PARSER = utils.mod_import(*settings.COMMAND_PARSER.rsplit('.', 1))
# There are a few system-hardcoded command names. These # This decides which command parser is to be used.
# allow for custom behaviour when the command handler hits # You have to restart the server for changes to take effect.
# special situations -- it then calls a normal Command _COMMAND_PARSER = utils.mod_import(*settings.COMMAND_PARSER.rsplit('.', 1))
# that you can customize!
# Import these variables and use them rather than trying
# to remember the actual string constants.
# System command names - import these variables rather than trying to
# remember the actual string constants. If not defined, Evennia
# hard-coded defaults are used instead.
# command to call if user just presses <return> with no input
CMD_NOINPUT = "__noinput_command" CMD_NOINPUT = "__noinput_command"
# command to call if no command match was found
CMD_NOMATCH = "__nomatch_command" CMD_NOMATCH = "__nomatch_command"
# command to call if multiple command matches were found
CMD_MULTIMATCH = "__multimatch_command" CMD_MULTIMATCH = "__multimatch_command"
# command to call if found command is the name of a channel
CMD_CHANNEL = "__send_to_channel_command" CMD_CHANNEL = "__send_to_channel_command"
# this is the name of the command the engine calls when the player # command to call as the very first one when the user connects.
# connects. It is expected to show the login screen. # (is expected to display the login screen)
CMD_LOGINSTART = "__unloggedin_look_command" CMD_LOGINSTART = "__unloggedin_look_command"
# custom Exceptions
class NoCmdSets(Exception): class NoCmdSets(Exception):
"No cmdsets found. Critical error." "No cmdsets found. Critical error."
@ -74,11 +78,15 @@ class ExecSystemCommand(Exception):
self.syscmd = syscmd self.syscmd = syscmd
self.sysarg = sysarg self.sysarg = sysarg
# Helper function
@inlineCallbacks @inlineCallbacks
def get_and_merge_cmdsets(caller): def _get_and_merge_cmdsets(caller):
""" """
Gather all relevant cmdsets and merge them. Note Gather all relevant cmdsets and merge them. Note
that this is only relevant for logged-in callers. that this is only relevant for logged-in callers.
Note that this function returns a deferred!
""" """
# The calling object's cmdset # The calling object's cmdset
try: try:
@ -163,7 +171,7 @@ def cmdhandler(caller, raw_string, testing=False):
try: # catch bugs in cmdhandler itself try: # catch bugs in cmdhandler itself
try: # catch special-type commands try: # catch special-type commands
cmdset = yield get_and_merge_cmdsets(caller) cmdset = yield _get_and_merge_cmdsets(caller)
if not cmdset: if not cmdset:
# this is bad and shouldn't happen. # this is bad and shouldn't happen.
raise NoCmdSets raise NoCmdSets
@ -177,7 +185,7 @@ def cmdhandler(caller, raw_string, testing=False):
# Parse the input string and match to available cmdset. # Parse the input string and match to available cmdset.
# This also checks for permissions, so all commands in match # This also checks for permissions, so all commands in match
# are commands the caller is allowed to call. # are commands the caller is allowed to call.
matches = yield COMMAND_PARSER(raw_string, cmdset, caller) matches = yield _COMMAND_PARSER(raw_string, cmdset, caller)
# Deal with matches # Deal with matches
if not matches: if not matches:
# No commands match our entered command # No commands match our entered command
@ -302,5 +310,3 @@ def cmdhandler(caller, raw_string, testing=False):
string += " Please contact an admin and/or file a bug report." string += " Please contact an admin and/or file a bug report."
logger.log_trace(string) logger.log_trace(string)
caller.msg(string % format_exc()) caller.msg(string % format_exc())
#----------------------------------------------------- end cmdhandler

326
src/commands/cmdset.py
View file

@ -16,10 +16,9 @@ together to create interesting in-game effects.
import copy import copy
from src.utils.utils import inherits_from, is_iter from src.utils.utils import inherits_from, is_iter
__all__ = ("CmdSet",)
RECURSIVE_PROTECTION = False class _CmdSetMeta(type):
class CmdSetMeta(type):
""" """
This metaclass makes some minor on-the-fly convenience fixes to This metaclass makes some minor on-the-fly convenience fixes to
the cmdset class. the cmdset class.
@ -37,55 +36,7 @@ class CmdSetMeta(type):
if not type(mcs.key_mergetypes) == dict: if not type(mcs.key_mergetypes) == dict:
mcs.key_mergetypes = {} mcs.key_mergetypes = {}
super(CmdSetMeta, mcs).__init__(*args, **kwargs) super(_CmdSetMeta, mcs).__init__(*args, **kwargs)
# Some priority-sensitive merge operations for cmdsets
def union(cmdset_a, cmdset_b, duplicates=False):
"C = A U B. CmdSet A is assumed to have higher priority"
cmdset_c = cmdset_a.copy_this()
# we make copies, not refs by use of [:]
cmdset_c.commands = cmdset_a.commands[:]
if duplicates and cmdset_a.priority == cmdset_b.priority:
cmdset_c.commands.extend(cmdset_b.commands)
else:
cmdset_c.commands.extend([cmd for cmd in cmdset_b if not cmd in cmdset_a])
return cmdset_c
def intersect(cmdset_a, cmdset_b, duplicates=False):
"C = A (intersect) B. A is assumed higher priority"
cmdset_c = cmdset_a.copy_this()
if duplicates and cmdset_a.priority == cmdset_b.priority:
for cmd in [cmd for cmd in cmdset_a if cmd in cmdset_b]:
cmdset_c.add(cmd)
cmdset_c.add(cmdset_b.get(cmd))
else:
cmdset_c.commands = [cmd for cmd in cmdset_a if cmd in cmdset_b]
return cmdset_c
def replace(cmdset_a, cmdset_b, cmdset_c):
"C = A + B where the result is A."
cmdset_c = cmdset_a.copy_this()
cmdset_c.commands = cmdset_a.commands[:]
return cmdset_c
def remove(cmdset_a, cmdset_b, cmdset_c):
"C = A + B, where B is filtered by A"
cmdset_c = cmdset_a.copy_this()
cmdset_c.commands = [cmd for cmd in cmdset_b if not cmd in cmdset_a]
return cmdset_c
def instantiate(cmd):
"""
checks so that object is an instantiated command
and not, say a cmdclass. If it is, instantiate it.
Other types, like strings, are passed through.
"""
try:
return cmd()
except TypeError:
return cmd
class CmdSet(object): class CmdSet(object):
""" """
@ -166,7 +117,7 @@ class CmdSet(object):
""" """
__metaclass__ = CmdSetMeta __metaclass__ = _CmdSetMeta
key = "Unnamed CmdSet" key = "Unnamed CmdSet"
mergetype = "Union" mergetype = "Union"
@ -177,6 +128,9 @@ class CmdSet(object):
no_objs = False no_objs = False
no_channels = False no_channels = False
permanent = False permanent = False
# pre-store properties to duplicate straight off
to_duplicate = ("key", "cmdsetobj", "no_exits", "no_objs", "no_channels", "permanent",
"mergetype", "priority", "duplicates")
def __init__(self, cmdsetobj=None, key=None): def __init__(self, cmdsetobj=None, key=None):
""" """
@ -194,127 +148,63 @@ class CmdSet(object):
# initialize system # initialize system
self.at_cmdset_creation() self.at_cmdset_creation()
def at_cmdset_creation(self): # Priority-sensitive merge operations for cmdsets
"""
Hook method - this should be overloaded in the inheriting
class, and should take care of populating the cmdset
by use of self.add().
"""
pass
def add(self, cmd): def _union(self, cmdset_a, cmdset_b, duplicates=False):
""" "C = A U B. CmdSet A is assumed to have higher priority"
Add a command, a list of commands or a cmdset to this cmdset. cmdset_c = cmdset_a._duplicate()
# we make copies, not refs by use of [:]
Note that if cmd already exists in set, cmdset_c.commands = cmdset_a.commands[:]
it will replace the old one (no priority checking etc if duplicates and cmdset_a.priority == cmdset_b.priority:
at this point; this is often used to overload cmdset_c.commands.extend(cmdset_b.commands)
default commands).
If cmd is another cmdset class or -instance, the commands
of that command set is added to this one, as if they were part
of the original cmdset definition. No merging or priority checks
are made, rather later added commands will simply replace
existing ones to make a unique set.
"""
if inherits_from(cmd, "src.commands.cmdset.CmdSet"):
# cmd is a command set so merge all commands in that set
# to this one. We raise a visible error if we created
# an infinite loop (adding cmdset to itself somehow)
try:
cmd = instantiate(cmd)
except RuntimeError, e:
string = "Adding cmdset %s to %s lead to an infinite loop. When adding a cmdset to another, "
string += "make sure they are not themself cyclically added to the new cmdset somewhere in the chain."
raise RuntimeError(string % (cmd, self.__class__))
cmds = cmd.commands
elif is_iter(cmd):
cmds = [instantiate(c) for c in cmd]
else: else:
cmds = [instantiate(cmd)] cmdset_c.commands.extend([cmd for cmd in cmdset_b if not cmd in cmdset_a])
for cmd in cmds: return cmdset_c
# add all commands
if not hasattr(cmd, 'obj'):
cmd.obj = self.cmdsetobj
try:
ic = self.commands.index(cmd)
self.commands[ic] = cmd # replace
except ValueError:
self.commands.append(cmd)
# extra run to make sure to avoid doublets
self.commands = list(set(self.commands))
#print "In cmdset.add(cmd):", self.key, cmd
def remove(self, cmd): def _intersect(self, cmdset_a, cmdset_b, duplicates=False):
""" "C = A (intersect) B. A is assumed higher priority"
Remove a command instance from the cmdset. cmdset_c = cmdset_a._duplicate()
cmd can be either a cmd instance or a key string. if duplicates and cmdset_a.priority == cmdset_b.priority:
""" for cmd in [cmd for cmd in cmdset_a if cmd in cmdset_b]:
cmd = instantiate(cmd) cmdset_c.add(cmd)
self.commands = [oldcmd for oldcmd in self.commands if oldcmd != cmd] cmdset_c.add(cmdset_b.get(cmd))
else:
cmdset_c.commands = [cmd for cmd in cmdset_a if cmd in cmdset_b]
return cmdset_c
def get(self, cmd): def _replace(self, cmdset_a, cmdset_b, cmdset_c):
""" "C = A + B where the result is A."
Return the command in this cmdset that matches the cmdset_c = cmdset_a._duplicate()
given command. cmd may be either a command instance or cmdset_c.commands = cmdset_a.commands[:]
a key string. return cmdset_c
"""
cmd = instantiate(cmd)
for thiscmd in self.commands:
if thiscmd == cmd:
return thiscmd
def count(self): def _remove(self, cmdset_a, cmdset_b, cmdset_c):
"Return number of commands in set" "C = A + B, where B is filtered by A"
return len(self.commands) cmdset_c = cmdset_a._duplicate()
cmdset_c.commands = [cmd for cmd in cmdset_b if not cmd in cmdset_a]
return cmdset_c
def get_system_cmds(self): def _instantiate(self, cmd):
""" """
Return system commands in the cmdset, defined as checks so that object is an instantiated command
commands starting with double underscore __. and not, say a cmdclass. If it is, instantiate it.
These are excempt from merge operations. Other types, like strings, are passed through.
""" """
return [cmd for cmd in self.commands if cmd.key.startswith('__')] try:
return cmd()
except TypeError:
return cmd
def copy_this(self): def _duplicate(self):
""" """
Returns a new cmdset with the same settings as this one Returns a new cmdset with the same settings as this one
(no commands are copied over) (no actual commands are copied over)
""" """
cmdset = CmdSet() cmdset = CmdSet()
cmdset.key = self.key cmdset.__dict__.update(dict((key, val) for key, val in self.__dict__.items() if key in self.to_duplicate))
cmdset.cmdsetobj = self.cmdsetobj
cmdset.no_exits = self.no_exits
cmdset.no_objs = self.no_objs
cmdset.no_channels = self.no_channels
cmdset.mergetype = self.mergetype
cmdset.priority = self.priority
cmdset.duplicates = self.duplicates
cmdset.key_mergetypes = self.key_mergetypes.copy() #copy.deepcopy(self.key_mergetypes) cmdset.key_mergetypes = self.key_mergetypes.copy() #copy.deepcopy(self.key_mergetypes)
return cmdset return cmdset
def make_unique(self, caller):
"""
This is an unsafe command meant to clean out a cmdset of
doublet commands after it has been created. It is useful
for commands inheriting cmdsets from the cmdhandler where
obj-based cmdsets always are added double. Doublets will
be weeded out with preference to commands defined on caller,
otherwise just by first-come-first-served.
"""
unique = {}
for cmd in self.commands:
if cmd.key in unique:
ocmd = unique[cmd.key]
if (hasattr(cmd, 'obj') and cmd.obj == caller) and not \
(hasattr(ocmd, 'obj') and ocmd.obj == caller):
unique[cmd.key] = cmd
else:
unique[cmd.key] = cmd
self.commands = unique.values()
def __str__(self): def __str__(self):
""" """
Show all commands in cmdset when printing it. Show all commands in cmdset when printing it.
@ -360,24 +250,24 @@ class CmdSet(object):
# A higher or equal priority than B # A higher or equal priority than B
mergetype = self.key_mergetypes.get(cmdset_b.key, self.mergetype) mergetype = self.key_mergetypes.get(cmdset_b.key, self.mergetype)
if mergetype == "Intersect": if mergetype == "Intersect":
cmdset_c = intersect(self, cmdset_b, cmdset_b.duplicates) cmdset_c = self._intersect(self, cmdset_b, cmdset_b.duplicates)
elif mergetype == "Replace": elif mergetype == "Replace":
cmdset_c = replace(self, cmdset_b, cmdset_b.duplicates) cmdset_c = self._replace(self, cmdset_b, cmdset_b.duplicates)
elif mergetype == "Remove": elif mergetype == "Remove":
cmdset_c = remove(self, cmdset_b, cmdset_b.duplicates) cmdset_c = self._remove(self, cmdset_b, cmdset_b.duplicates)
else: # Union else: # Union
cmdset_c = union(self, cmdset_b, cmdset_b.duplicates) cmdset_c = self._union(self, cmdset_b, cmdset_b.duplicates)
else: else:
# B higher priority than A # B higher priority than A
mergetype = cmdset_b.key_mergetypes.get(self.key, cmdset_b.mergetype) mergetype = cmdset_b.key_mergetypes.get(self.key, cmdset_b.mergetype)
if mergetype == "Intersect": if mergetype == "Intersect":
cmdset_c = intersect(cmdset_b, self, self.duplicates) cmdset_c = self._intersect(cmdset_b, self, self.duplicates)
elif mergetype == "Replace": elif mergetype == "Replace":
cmdset_c = replace(cmdset_b, self, self.duplicates) cmdset_c = self._replace(cmdset_b, self, self.duplicates)
elif mergetype == "Remove": elif mergetype == "Remove":
cmdset_c = remove(self, cmdset_b, self.duplicates) cmdset_c = self._remove(self, cmdset_b, self.duplicates)
else: # Union else: # Union
cmdset_c = union(cmdset_b, self, self.duplicates) cmdset_c = self._union(cmdset_b, self, self.duplicates)
# we store actual_mergetype since key_mergetypes # we store actual_mergetype since key_mergetypes
# might be different from the main mergetype. # might be different from the main mergetype.
@ -388,3 +278,107 @@ class CmdSet(object):
cmdset_c.add(sys_commands) cmdset_c.add(sys_commands)
return cmdset_c return cmdset_c
def add(self, cmd):
"""
Add a command, a list of commands or a cmdset to this cmdset.
Note that if cmd already exists in set,
it will replace the old one (no priority checking etc
at this point; this is often used to overload
default commands).
If cmd is another cmdset class or -instance, the commands
of that command set is added to this one, as if they were part
of the original cmdset definition. No merging or priority checks
are made, rather later added commands will simply replace
existing ones to make a unique set.
"""
if inherits_from(cmd, "src.commands.cmdset.CmdSet"):
# cmd is a command set so merge all commands in that set
# to this one. We raise a visible error if we created
# an infinite loop (adding cmdset to itself somehow)
try:
cmd = self._instantiate(cmd)
except RuntimeError, e:
string = "Adding cmdset %s to %s lead to an infinite loop. When adding a cmdset to another, "
string += "make sure they are not themself cyclically added to the new cmdset somewhere in the chain."
raise RuntimeError(string % (cmd, self.__class__))
cmds = cmd.commands
elif is_iter(cmd):
cmds = [self._instantiate(c) for c in cmd]
else:
cmds = [self._instantiate(cmd)]
for cmd in cmds:
# add all commands
if not hasattr(cmd, 'obj'):
cmd.obj = self.cmdsetobj
try:
ic = self.commands.index(cmd)
self.commands[ic] = cmd # replace
except ValueError:
self.commands.append(cmd)
# extra run to make sure to avoid doublets
self.commands = list(set(self.commands))
#print "In cmdset.add(cmd):", self.key, cmd
def remove(self, cmd):
"""
Remove a command instance from the cmdset.
cmd can be either a cmd instance or a key string.
"""
cmd = self._instantiate(cmd)
self.commands = [oldcmd for oldcmd in self.commands if oldcmd != cmd]
def get(self, cmd):
"""
Return the command in this cmdset that matches the
given command. cmd may be either a command instance or
a key string.
"""
cmd = self._instantiate(cmd)
for thiscmd in self.commands:
if thiscmd == cmd:
return thiscmd
def count(self):
"Return number of commands in set"
return len(self.commands)
def get_system_cmds(self):
"""
Return system commands in the cmdset, defined as
commands starting with double underscore __.
These are excempt from merge operations.
"""
return [cmd for cmd in self.commands if cmd.key.startswith('__')]
def make_unique(self, caller):
"""
This is an unsafe command meant to clean out a cmdset of
doublet commands after it has been created. It is useful
for commands inheriting cmdsets from the cmdhandler where
obj-based cmdsets always are added double. Doublets will
be weeded out with preference to commands defined on caller,
otherwise just by first-come-first-served.
"""
unique = {}
for cmd in self.commands:
if cmd.key in unique:
ocmd = unique[cmd.key]
if (hasattr(cmd, 'obj') and cmd.obj == caller) and not \
(hasattr(ocmd, 'obj') and ocmd.obj == caller):
unique[cmd.key] = cmd
else:
unique[cmd.key] = cmd
self.commands = unique.values()
def at_cmdset_creation(self):
"""
Hook method - this should be overloaded in the inheriting
class, and should take care of populating the cmdset
by use of self.add().
"""
pass

47
src/commands/cmdsethandler.py
View file

@ -67,8 +67,9 @@ import traceback
from src.utils import logger, utils from src.utils import logger, utils
from src.commands.cmdset import CmdSet from src.commands.cmdset import CmdSet
from src.server.models import ServerConfig from src.server.models import ServerConfig
__all__ = ("import_cmdset", "CmdSetHandler")
CACHED_CMDSETS = {} _CACHED_CMDSETS = {}
def import_cmdset(python_path, cmdsetobj, emit_to_obj=None, no_logging=False): def import_cmdset(python_path, cmdsetobj, emit_to_obj=None, no_logging=False):
""" """
@ -87,9 +88,9 @@ def import_cmdset(python_path, cmdsetobj, emit_to_obj=None, no_logging=False):
try: try:
try: try:
#print "importing %s: CACHED_CMDSETS=%s" % (python_path, CACHED_CMDSETS) #print "importing %s: _CACHED_CMDSETS=%s" % (python_path, _CACHED_CMDSETS)
wanted_cache_key = python_path wanted_cache_key = python_path
cmdsetclass = CACHED_CMDSETS.get(wanted_cache_key, None) cmdsetclass = _CACHED_CMDSETS.get(wanted_cache_key, None)
errstring = "" errstring = ""
if not cmdsetclass: if not cmdsetclass:
#print "cmdset '%s' not in cache. Reloading %s on %s." % (wanted_cache_key, python_path, cmdsetobj) #print "cmdset '%s' not in cache. Reloading %s on %s." % (wanted_cache_key, python_path, cmdsetobj)
@ -97,7 +98,7 @@ def import_cmdset(python_path, cmdsetobj, emit_to_obj=None, no_logging=False):
modulepath, classname = python_path.rsplit('.', 1) modulepath, classname = python_path.rsplit('.', 1)
module = __import__(modulepath, fromlist=[True]) module = __import__(modulepath, fromlist=[True])
cmdsetclass = module.__dict__[classname] cmdsetclass = module.__dict__[classname]
CACHED_CMDSETS[wanted_cache_key] = cmdsetclass _CACHED_CMDSETS[wanted_cache_key] = cmdsetclass
#instantiate the cmdset (and catch its errors) #instantiate the cmdset (and catch its errors)
if callable(cmdsetclass): if callable(cmdsetclass):
cmdsetclass = cmdsetclass(cmdsetobj) cmdsetclass = cmdsetclass(cmdsetobj)
@ -115,13 +116,15 @@ def import_cmdset(python_path, cmdsetobj, emit_to_obj=None, no_logging=False):
errstring = "\n%s\nCompile/Run error when loading cmdset '%s'." errstring = "\n%s\nCompile/Run error when loading cmdset '%s'."
errstring = errstring % (traceback.format_exc(), python_path) errstring = errstring % (traceback.format_exc(), python_path)
raise raise
except Exception: except Exception, e:
if errstring and not no_logging: if errstring and not no_logging:
print errstring print errstring
logger.log_trace() logger.log_trace()
if emit_to_obj and not ServerConfig.objects.conf("server_starting_mode"): if emit_to_obj and not ServerConfig.objects.conf("server_starting_mode"):
object.__getattribute__(emit_to_obj, "msg")(errstring) object.__getattribute__(emit_to_obj, "msg")(errstring)
logger.log_errmsg("Error: %s" % errstring) if not errstring:
errstring = "Error in import cmdset: %s" % e
logger.log_errmsg(errstring)
#cannot raise - it kills the server if no base cmdset exists! #cannot raise - it kills the server if no base cmdset exists!
# classes # classes
@ -198,6 +201,17 @@ class CmdSetHandler(object):
", ".join(cmd.key for cmd in sorted(self.current, key=lambda o:o.key))) ", ".join(cmd.key for cmd in sorted(self.current, key=lambda o:o.key)))
return string.strip() return string.strip()
def _import_cmdset(self, cmdset_path, emit_to_obj=None):
"""
Method wrapper for import_cmdset.
load a cmdset from a module.
cmdset_path - the python path to an cmdset object.
emit_to_obj - object to send error messages to
"""
if not emit_to_obj:
emit_to_obj = self.obj
return import_cmdset(cmdset_path, self.obj, emit_to_obj)
def update(self, init_mode=False): def update(self, init_mode=False):
""" """
Re-adds all sets in the handler to have an updated Re-adds all sets in the handler to have an updated
@ -216,7 +230,7 @@ class CmdSetHandler(object):
if pos == 0 and not path: if pos == 0 and not path:
self.cmdset_stack = [CmdSet(cmdsetobj=self.obj, key="Empty")] self.cmdset_stack = [CmdSet(cmdsetobj=self.obj, key="Empty")]
elif path: elif path:
cmdset = self.import_cmdset(path) cmdset = self._import_cmdset(path)
if cmdset: if cmdset:
cmdset.permanent = True cmdset.permanent = True
self.cmdset_stack.append(cmdset) self.cmdset_stack.append(cmdset)
@ -233,17 +247,6 @@ class CmdSetHandler(object):
self.mergetype_stack.append(new_current.actual_mergetype) self.mergetype_stack.append(new_current.actual_mergetype)
self.current = new_current self.current = new_current
def import_cmdset(self, cmdset_path, emit_to_obj=None):
"""
Method wrapper for import_cmdset.
load a cmdset from a module.
cmdset_path - the python path to an cmdset object.
emit_to_obj - object to send error messages to
"""
if not emit_to_obj:
emit_to_obj = self.obj
return import_cmdset(cmdset_path, self.obj, emit_to_obj)
def add(self, cmdset, emit_to_obj=None, permanent=False): def add(self, cmdset, emit_to_obj=None, permanent=False):
""" """
Add a cmdset to the handler, on top of the old ones. Add a cmdset to the handler, on top of the old ones.
@ -271,7 +274,7 @@ class CmdSetHandler(object):
cmdset = cmdset(self.obj) cmdset = cmdset(self.obj)
elif isinstance(cmdset, basestring): elif isinstance(cmdset, basestring):
# this is (maybe) a python path. Try to import from cache. # this is (maybe) a python path. Try to import from cache.
cmdset = self.import_cmdset(cmdset) cmdset = self._import_cmdset(cmdset)
if cmdset: if cmdset:
if permanent: if permanent:
# store the path permanently # store the path permanently
@ -303,7 +306,7 @@ class CmdSetHandler(object):
cmdset = cmdset(self.obj) cmdset = cmdset(self.obj)
elif isinstance(cmdset, basestring): elif isinstance(cmdset, basestring):
# this is (maybe) a python path. Try to import from cache. # this is (maybe) a python path. Try to import from cache.
cmdset = self.import_cmdset(cmdset) cmdset = self._import_cmdset(cmdset)
if cmdset: if cmdset:
if self.cmdset_stack: if self.cmdset_stack:
self.cmdset_stack[0] = cmdset self.cmdset_stack[0] = cmdset
@ -430,7 +433,7 @@ class CmdSetHandler(object):
def reset(self): def reset(self):
""" """
Force reload of all cmdsets in handler. This should be called Force reload of all cmdsets in handler. This should be called
after CACHED_CMDSETS have been cleared (normally by @reload). after _CACHED_CMDSETS have been cleared (normally by @reload).
""" """
new_cmdset_stack = [] new_cmdset_stack = []
new_mergetype_stack = [] new_mergetype_stack = []
@ -439,7 +442,7 @@ class CmdSetHandler(object):
new_cmdset_stack.append(cmdset) new_cmdset_stack.append(cmdset)
new_mergetype_stack.append("Union") new_mergetype_stack.append("Union")
else: else:
new_cmdset_stack.append(self.import_cmdset(cmdset.path)) new_cmdset_stack.append(self._import_cmdset(cmdset.path))
new_mergetype_stack.append(cmdset.mergetype) new_mergetype_stack.append(cmdset.mergetype)
self.cmdset_stack = new_cmdset_stack self.cmdset_stack = new_cmdset_stack
self.mergetype_stack = new_mergetype_stack self.mergetype_stack = new_mergetype_stack

112
src/comms/models.py
View file

@ -21,7 +21,7 @@ from src.locks.lockhandler import LockHandler
from src.utils import logger from src.utils import logger
from src.utils.utils import is_iter, to_str from src.utils.utils import is_iter, to_str
from src.utils.utils import dbref as is_dbref from src.utils.utils import dbref as is_dbref
__all__ = ("Msg", "TempMsg", "Channel", "PlayerChannelConnection", "ExternalChannelConnection")
#------------------------------------------------------------ #------------------------------------------------------------
# #
@ -29,7 +29,7 @@ from src.utils.utils import dbref as is_dbref
# #
#------------------------------------------------------------ #------------------------------------------------------------
def obj_to_id(inp): def _obj_to_id(inp):
""" """
Converts input object to an id string. Converts input object to an id string.
""" """
@ -42,7 +42,7 @@ def obj_to_id(inp):
return str(inp.dbobj.id) return str(inp.dbobj.id)
return str(inp) return str(inp)
def id_to_obj(dbref, db_model='PlayerDB'): def _id_to_obj(dbref, db_model='PlayerDB'):
""" """
loads from dbref to object. Uses the db_model to search loads from dbref to object. Uses the db_model to search
for the id. for the id.
@ -140,186 +140,186 @@ class Msg(SharedMemoryModel):
# sender property (wraps db_sender) # sender property (wraps db_sender)
#@property #@property
def sender_get(self): def __sender_get(self):
"Getter. Allows for value = self.sender" "Getter. Allows for value = self.sender"
return self.db_sender return self.db_sender
#@sender.setter #@sender.setter
def sender_set(self, value): def __sender_set(self, value):
"Setter. Allows for self.sender = value" "Setter. Allows for self.sender = value"
self.db_sender = value self.db_sender = value
self.save() self.save()
#@sender.deleter #@sender.deleter
def sender_del(self): def __sender_del(self):
"Deleter. Allows for del self.sender" "Deleter. Allows for del self.sender"
raise Exception("You cannot delete the sender of a message!") raise Exception("You cannot delete the sender of a message!")
sender = property(sender_get, sender_set, sender_del) sender = property(__sender_get, __sender_set, __sender_del)
# sender_external property (wraps db_sender_external) # sender_external property (wraps db_sender_external)
#@property #@property
def sender_external_get(self): def __sender_external_get(self):
"Getter. Allows for value = self.sender_external" "Getter. Allows for value = self.sender_external"
return self.db_sender_external return self.db_sender_external
#@sender_external.setter #@sender_external.setter
def sender_external_set(self, value): def __sender_external_set(self, value):
"Setter. Allows for self.sender_external = value" "Setter. Allows for self.sender_external = value"
self.db_sender_external = value self.db_sender_external = value
self.save() self.save()
#@sender_external.deleter #@sender_external.deleter
def sender_external_del(self): def __sender_external_del(self):
"Deleter. Allows for del self.sender_external" "Deleter. Allows for del self.sender_external"
raise Exception("You cannot delete the sender_external of a message!") raise Exception("You cannot delete the sender_external of a message!")
sender_external = property(sender_external_get, sender_external_set, sender_external_del) sender_external = property(__sender_external_get, __sender_external_set, __sender_external_del)
# receivers property # receivers property
#@property #@property
def receivers_get(self): def __receivers_get(self):
"Getter. Allows for value = self.receivers. Returns a list of receivers." "Getter. Allows for value = self.receivers. Returns a list of receivers."
if self.db_receivers: if self.db_receivers:
return [id_to_obj(dbref) for dbref in self.db_receivers.split(',')] return [_id_to_obj(dbref) for dbref in self.db_receivers.split(',')]
return [] return []
#@receivers.setter #@receivers.setter
def receivers_set(self, value): def __receivers_set(self, value):
"Setter. Allows for self.receivers = value. Stores as a comma-separated string." "Setter. Allows for self.receivers = value. Stores as a comma-separated string."
if is_iter(value): if is_iter(value):
value = ",".join([obj_to_id(val) for val in value]) value = ",".join([_obj_to_id(val) for val in value])
self.db_receivers = obj_to_id(value) self.db_receivers = _obj_to_id(value)
self.save() self.save()
#@receivers.deleter #@receivers.deleter
def receivers_del(self): def __receivers_del(self):
"Deleter. Allows for del self.receivers" "Deleter. Allows for del self.receivers"
self.db_receivers = "" self.db_receivers = ""
self.save() self.save()
receivers = property(receivers_get, receivers_set, receivers_del) receivers = property(__receivers_get, __receivers_set, __receivers_del)
# channels property # channels property
#@property #@property
def channels_get(self): def __channels_get(self):
"Getter. Allows for value = self.channels. Returns a list of channels." "Getter. Allows for value = self.channels. Returns a list of channels."
if self.db_channels: if self.db_channels:
return [id_to_obj(dbref, 'Channel') for dbref in self.db_channels.split(',')] return [_id_to_obj(dbref, 'Channel') for dbref in self.db_channels.split(',')]
return [] return []
#@channels.setter #@channels.setter
def channels_set(self, value): def __channels_set(self, value):
"Setter. Allows for self.channels = value. Stores as a comma-separated string." "Setter. Allows for self.channels = value. Stores as a comma-separated string."
if is_iter(value): if is_iter(value):
value = ",".join([obj_to_id(val) for val in value]) value = ",".join([_obj_to_id(val) for val in value])
self.db_channels = obj_to_id(value) self.db_channels = _obj_to_id(value)
self.save() self.save()
#@channels.deleter #@channels.deleter
def channels_del(self): def __channels_del(self):
"Deleter. Allows for del self.channels" "Deleter. Allows for del self.channels"
self.db_channels = "" self.db_channels = ""
self.save() self.save()
channels = property(channels_get, channels_set, channels_del) channels = property(__channels_get, __channels_set, __channels_del)
# message property (wraps db_message) # message property (wraps db_message)
#@property #@property
def message_get(self): def __message_get(self):
"Getter. Allows for value = self.message" "Getter. Allows for value = self.message"
return self.db_message return self.db_message
#@message.setter #@message.setter
def message_set(self, value): def __message_set(self, value):
"Setter. Allows for self.message = value" "Setter. Allows for self.message = value"
self.db_message = value self.db_message = value
self.save() self.save()
#@message.deleter #@message.deleter
def message_del(self): def __message_del(self):
"Deleter. Allows for del self.message" "Deleter. Allows for del self.message"
self.db_message = "" self.db_message = ""
self.save() self.save()
message = property(message_get, message_set, message_del) message = property(__message_get, __message_set, __message_del)
# date_sent property (wraps db_date_sent) # date_sent property (wraps db_date_sent)
#@property #@property
def date_sent_get(self): def __date_sent_get(self):
"Getter. Allows for value = self.date_sent" "Getter. Allows for value = self.date_sent"
return self.db_date_sent return self.db_date_sent
#@date_sent.setter #@date_sent.setter
def date_sent_set(self, value): def __date_sent_set(self, value):
"Setter. Allows for self.date_sent = value" "Setter. Allows for self.date_sent = value"
raise Exception("You cannot edit date_sent!") raise Exception("You cannot edit date_sent!")
#@date_sent.deleter #@date_sent.deleter
def date_sent_del(self): def __date_sent_del(self):
"Deleter. Allows for del self.date_sent" "Deleter. Allows for del self.date_sent"
raise Exception("You cannot delete the date_sent property!") raise Exception("You cannot delete the date_sent property!")
date_sent = property(date_sent_get, date_sent_set, date_sent_del) date_sent = property(__date_sent_get, __date_sent_set, __date_sent_del)
# hide_from_sender property # hide_from_sender property
#@property #@property
def hide_from_sender_get(self): def __hide_from_sender_get(self):
"Getter. Allows for value = self.hide_from_sender." "Getter. Allows for value = self.hide_from_sender."
return self.db_hide_from_sender return self.db_hide_from_sender
#@hide_from_sender.setter #@hide_from_sender.setter
def hide_from_sender_set(self, value): def __hide_from_sender_set(self, value):
"Setter. Allows for self.hide_from_senders = value." "Setter. Allows for self.hide_from_senders = value."
self.db_hide_from_sender = value self.db_hide_from_sender = value
self.save() self.save()
#@hide_from_sender.deleter #@hide_from_sender.deleter
def hide_from_sender_del(self): def __hide_from_sender_del(self):
"Deleter. Allows for del self.hide_from_senders" "Deleter. Allows for del self.hide_from_senders"
self.db_hide_from_sender = False self.db_hide_from_sender = False
self.save() self.save()
hide_from_sender = property(hide_from_sender_get, hide_from_sender_set, hide_from_sender_del) hide_from_sender = property(__hide_from_sender_get, __hide_from_sender_set, __hide_from_sender_del)
# hide_from_receivers property # hide_from_receivers property
#@property #@property
def hide_from_receivers_get(self): def __hide_from_receivers_get(self):
"Getter. Allows for value = self.hide_from_receivers. Returns a list of hide_from_receivers." "Getter. Allows for value = self.hide_from_receivers. Returns a list of hide_from_receivers."
if self.db_hide_from_receivers: if self.db_hide_from_receivers:
return [id_to_obj(dbref) for dbref in self.db_hide_from_receivers.split(',')] return [_id_to_obj(dbref) for dbref in self.db_hide_from_receivers.split(',')]
return [] return []
#@hide_from_receivers.setter #@hide_from_receivers.setter
def hide_from_receivers_set(self, value): def __hide_from_receivers_set(self, value):
"Setter. Allows for self.hide_from_receivers = value. Stores as a comma-separated string." "Setter. Allows for self.hide_from_receivers = value. Stores as a comma-separated string."
if is_iter(value): if is_iter(value):
value = ",".join([obj_to_id(val) for val in value]) value = ",".join([_obj_to_id(val) for val in value])
self.db_hide_from_receivers = obj_to_id(value) self.db_hide_from_receivers = _obj_to_id(value)
self.save() self.save()
#@hide_from_receivers.deleter #@hide_from_receivers.deleter
def hide_from_receivers_del(self): def __hide_from_receivers_del(self):
"Deleter. Allows for del self.hide_from_receivers" "Deleter. Allows for del self.hide_from_receivers"
self.db_hide_from_receivers = "" self.db_hide_from_receivers = ""
self.save() self.save()
hide_from_receivers = property(hide_from_receivers_get, hide_from_receivers_set, hide_from_receivers_del) hide_from_receivers = property(__hide_from_receivers_get, __hide_from_receivers_set, __hide_from_receivers_del)
# hide_from_channels property # hide_from_channels property
#@property #@property
def hide_from_channels_get(self): def __hide_from_channels_get(self):
"Getter. Allows for value = self.hide_from_channels. Returns a list of hide_from_channels." "Getter. Allows for value = self.hide_from_channels. Returns a list of hide_from_channels."
if self.db_hide_from_channels: if self.db_hide_from_channels:
return [id_to_obj(dbref) for dbref in self.db_hide_from_channels.split(',')] return [_id_to_obj(dbref) for dbref in self.db_hide_from_channels.split(',')]
return [] return []
#@hide_from_channels.setter #@hide_from_channels.setter
def hide_from_channels_set(self, value): def __hide_from_channels_set(self, value):
"Setter. Allows for self.hide_from_channels = value. Stores as a comma-separated string." "Setter. Allows for self.hide_from_channels = value. Stores as a comma-separated string."
if is_iter(value): if is_iter(value):
value = ",".join([obj_to_id(val) for val in value]) value = ",".join([_obj_to_id(val) for val in value])
self.db_hide_from_channels = obj_to_id(value) self.db_hide_from_channels = _obj_to_id(value)
self.save() self.save()
#@hide_from_channels.deleter #@hide_from_channels.deleter
def hide_from_channels_del(self): def __hide_from_channels_del(self):
"Deleter. Allows for del self.hide_from_channels" "Deleter. Allows for del self.hide_from_channels"
self.db_hide_from_channels = "" self.db_hide_from_channels = ""
self.save() self.save()
hide_from_channels = property(hide_from_channels_get, hide_from_channels_set, hide_from_channels_del) hide_from_channels = property(__hide_from_channels_get, __hide_from_channels_set, __hide_from_channels_del)
# lock_storage property (wraps db_lock_storage) # lock_storage property (wraps db_lock_storage)
#@property #@property
def lock_storage_get(self): def __lock_storage_get(self):
"Getter. Allows for value = self.lock_storage" "Getter. Allows for value = self.lock_storage"
return self.db_lock_storage return self.db_lock_storage
#@nick.setter #@nick.setter
def lock_storage_set(self, value): def __lock_storage_set(self, value):
"""Saves the lock_storagetodate. This is usually not called directly, but through self.lock()""" """Saves the lock_storagetodate. This is usually not called directly, but through self.lock()"""
self.db_lock_storage = value self.db_lock_storage = value
self.save() self.save()
#@nick.deleter #@nick.deleter
def lock_storage_del(self): def __lock_storage_del(self):
"Deleter is disabled. Use the lockhandler.delete (self.lock.delete) instead""" "Deleter is disabled. Use the lockhandler.delete (self.lock.delete) instead"""
logger.log_errmsg("Lock_Storage (on %s) cannot be deleted. Use obj.lock.delete() instead." % self) logger.log_errmsg("Lock_Storage (on %s) cannot be deleted. Use obj.lock.delete() instead." % self)
lock_storage = property(lock_storage_get, lock_storage_set, lock_storage_del) lock_storage = property(__lock_storage_get, __lock_storage_set, __lock_storage_del)
db_model_name = "msg" # used by attributes to safely store objects _db_model_name = "msg" # used by attributes to safely store objects
# #
# Msg class methods # Msg class methods

3
src/help/models.py
View file

@ -72,6 +72,9 @@ class HelpEntry(SharedMemoryModel):
verbose_name = "Help Entry" verbose_name = "Help Entry"
verbose_name_plural = "Help Entries" verbose_name_plural = "Help Entries"
# used by Attributes to safely retrieve stored object
_db_model_name = "helpentry"
# Wrapper properties to easily set database fields. These are # Wrapper properties to easily set database fields. These are
# @property decorators that allows to access these fields using # @property decorators that allows to access these fields using
# normal python operations (without having to remember to save() # normal python operations (without having to remember to save()

19
src/server/models.py
View file

@ -51,6 +51,9 @@ class ServerConfig(SharedMemoryModel):
objects = ServerConfigManager() objects = ServerConfigManager()
# used by Attributes eventually storing this safely
_db_model_name = "serverconfig"
# Wrapper properties to easily set database fields. These are # Wrapper properties to easily set database fields. These are
# @property decorators that allows to access these fields using # @property decorators that allows to access these fields using
# normal python operations (without having to remember to save() # normal python operations (without having to remember to save()
@ -61,27 +64,27 @@ class ServerConfig(SharedMemoryModel):
# key property (wraps db_key) # key property (wraps db_key)
#@property #@property
def key_get(self): def __key_get(self):
"Getter. Allows for value = self.key" "Getter. Allows for value = self.key"
return self.db_key return self.db_key
#@key.setter #@key.setter
def key_set(self, value): def __key_set(self, value):
"Setter. Allows for self.key = value" "Setter. Allows for self.key = value"
self.db_key = value self.db_key = value
self.save() self.save()
#@key.deleter #@key.deleter
def key_del(self): def __key_del(self):
"Deleter. Allows for del self.key. Deletes entry." "Deleter. Allows for del self.key. Deletes entry."
self.delete() self.delete()
key = property(key_get, key_set, key_del) key = property(__key_get, __key_set, __key_del)
# value property (wraps db_value) # value property (wraps db_value)
#@property #@property
def value_get(self): def __value_get(self):
"Getter. Allows for value = self.value" "Getter. Allows for value = self.value"
return pickle.loads(str(self.db_value)) return pickle.loads(str(self.db_value))
#@value.setter #@value.setter
def value_set(self, value): def __value_set(self, value):
"Setter. Allows for self.value = value" "Setter. Allows for self.value = value"
if utils.has_parent('django.db.models.base.Model', value): if utils.has_parent('django.db.models.base.Model', value):
# we have to protect against storing db objects. # we have to protect against storing db objects.
@ -90,10 +93,10 @@ class ServerConfig(SharedMemoryModel):
self.db_value = pickle.dumps(value) self.db_value = pickle.dumps(value)
self.save() self.save()
#@value.deleter #@value.deleter
def value_del(self): def __value_del(self):
"Deleter. Allows for del self.value. Deletes entry." "Deleter. Allows for del self.value. Deletes entry."
self.delete() self.delete()
value = property(value_get, value_set, value_del) value = property(__value_get, __value_set, __value_del)
class Meta: class Meta:
"Define Django meta options" "Define Django meta options"