Further cleanup of source; making class methods _private for clarity in the API.

src/comms/models.py

@@ -808,4 +808,3 @@ class ExternalChannelConnection(SharedMemoryModel):
             exec(to_str(self.external_send_code))
         except Exception:
             logger.log_trace("Channel %s could not send to External %s" % (self.channel, self.external_key))
-            

src/help/manager.py

@@ -3,6 +3,7 @@ Custom manager for HelpEntry objects.
 """
 from django.db import models
 from src.utils import logger, utils
+__all__ = ("HelpEntryManager",)
 
 class HelpEntryManager(models.Manager):
     """

src/help/models.py

@@ -15,6 +15,7 @@ from src.help.manager import HelpEntryManager
 from src.utils import ansi
 from src.locks.lockhandler import LockHandler
 from src.utils.utils import is_iter
+__all__ = ("HelpEntry",)
 
 #------------------------------------------------------------
 #
@@ -32,6 +33,9 @@ class HelpEntry(SharedMemoryModel):
       entrytext - the actual help text
       permissions - perm strings
 
+    Method:
+      access
+
     """
 
     #
@@ -78,88 +82,88 @@ class HelpEntry(SharedMemoryModel):
 
     # key property (wraps db_key)
     #@property
-    def key_get(self):
+    def __key_get(self):
         "Getter. Allows for value = self.key"
         return self.db_key
     #@key.setter
-    def key_set(self, value):
+    def __key_set(self, value):
         "Setter. Allows for self.key = value"
         self.db_key = value
         self.save()
     #@key.deleter
-    def key_del(self):
+    def __key_del(self):
         "Deleter. Allows for del self.key. Deletes entry."
         self.delete()
-    key = property(key_get, key_set, key_del)
+    key = property(__key_get, __key_set, __key_del)
 
     # help_category property (wraps db_help_category)
     #@property
-    def help_category_get(self):
+    def __help_category_get(self):
         "Getter. Allows for value = self.help_category"
         return self.db_help_category
     #@help_category.setter
-    def help_category_set(self, value):
+    def __help_category_set(self, value):
         "Setter. Allows for self.help_category = value"
         self.db_help_category = value
         self.save()
     #@help_category.deleter
-    def help_category_del(self):
+    def __help_category_del(self):
         "Deleter. Allows for del self.help_category"
         self.db_help_category = "General"
         self.save()
-    help_category = property(help_category_get, help_category_set, help_category_del)
+    help_category = property(__help_category_get, __help_category_set, __help_category_del)
 
     # entrytext property (wraps db_entrytext)
     #@property
-    def entrytext_get(self):
+    def __entrytext_get(self):
         "Getter. Allows for value = self.entrytext"
         return self.db_entrytext
     #@entrytext.setter
-    def entrytext_set(self, value):
+    def __entrytext_set(self, value):
         "Setter. Allows for self.entrytext = value"
         self.db_entrytext = value
         self.save()
     #@entrytext.deleter
-    def entrytext_del(self):
+    def __entrytext_del(self):
         "Deleter. Allows for del self.entrytext"
         self.db_entrytext = ""
         self.save()
-    entrytext = property(entrytext_get, entrytext_set, entrytext_del)
+    entrytext = property(__entrytext_get, __entrytext_set, __entrytext_del)
 
     # permissions property
     #@property
-    def permissions_get(self):
+    def __permissions_get(self):
         "Getter. Allows for value = self.permissions. Returns a list of permissions."
         return [perm.strip() for perm in self.db_permissions.split(',')]
     #@permissions.setter
-    def permissions_set(self, value):
+    def __permissions_set(self, value):
         "Setter. Allows for self.permissions = value. Stores as a comma-separated string."
         if is_iter(value):
             value = ",".join([str(val).strip().lower() for val in value])
         self.db_permissions = value
         self.save()
     #@permissions.deleter
-    def permissions_del(self):
+    def __permissions_del(self):
         "Deleter. Allows for del self.permissions"
         self.db_permissions = ""
         self.save()
-    permissions = property(permissions_get, permissions_set, permissions_del)
+    permissions = property(__permissions_get, __permissions_set, __permissions_del)
 
         # lock_storage property (wraps db_lock_storage)
     #@property
-    def lock_storage_get(self):
+    def __lock_storage_get(self):
         "Getter. Allows for value = self.lock_storage"
         return self.db_lock_storage
     #@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()"""
         self.db_lock_storage = value
         self.save()
     #@nick.deleter
-    def lock_storage_del(self):
+    def __lock_storage_del(self):
         "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)
-    lock_storage = property(lock_storage_get, lock_storage_set, lock_storage_del)
+    lock_storage = property(__lock_storage_get, __lock_storage_set, __lock_storage_del)
 
 
     #

src/locks/lockfuncs.py

@@ -85,7 +85,7 @@ from django.conf import settings
 from src.utils import search
 from src.utils import utils
 
-PERMISSION_HIERARCHY = [p.lower() for p in settings.PERMISSION_HIERARCHY]
+_PERMISSION_HIERARCHY = [p.lower() for p in settings.PERMISSION_HIERARCHY]
 
 def _to_player(accessing_obj):
     "Helper function. Makes sure an accessing object is a player object"
@@ -117,7 +117,7 @@ def perm(accessing_obj, accessed_obj, *args, **kwargs):
 
     where <permission> is the permission accessing_obj must
     have in order to pass the lock. If the given permission
-    is part of PERMISSION_HIERARCHY, permission is also granted
+    is part of _PERMISSION_HIERARCHY, permission is also granted
     to all ranks higher up in the hierarchy.
     """
     try:
@@ -129,10 +129,10 @@ def perm(accessing_obj, accessed_obj, *args, **kwargs):
     if perm in permissions:
         # simplest case - we have a direct match
         return True
-    if perm in PERMISSION_HIERARCHY:
+    if perm in _PERMISSION_HIERARCHY:
         # check if we have a higher hierarchy position
-        ppos = PERMISSION_HIERARCHY.index(perm)
+        ppos = _PERMISSION_HIERARCHY.index(perm)
-        return any(1 for hpos, hperm in enumerate(PERMISSION_HIERARCHY)
+        return any(1 for hpos, hperm in enumerate(_PERMISSION_HIERARCHY)
                    if hperm in permissions and hpos > ppos)
     return False
 
@@ -148,9 +148,9 @@ def perm_above(accessing_obj, accessed_obj, *args, **kwargs):
     except IndexError:
         return False
 
-    if perm in PERMISSION_HIERARCHY:
+    if perm in _PERMISSION_HIERARCHY:
-        ppos = PERMISSION_HIERARCHY.index(perm)
+        ppos = _PERMISSION_HIERARCHY.index(perm)
-        return any(1 for hpos, hperm in enumerate(PERMISSION_HIERARCHY)
+        return any(1 for hpos, hperm in enumerate(_PERMISSION_HIERARCHY)
                    if hperm in [p.lower() for p in accessing_obj.permissions] and hpos > ppos)
     return False
 
@@ -163,7 +163,7 @@ def pperm(accessing_obj, accessed_obj, *args, **kwargs):
 
     where <permission> is the permission accessing_obj must
     have in order to pass the lock. If the given permission
-    is part of PERMISSION_HIERARCHY, permission is also granted
+    is part of _PERMISSION_HIERARCHY, permission is also granted
     to all ranks higher up in the hierarchy.
     """
     return perm(_to_player(accessing_obj), accessed_obj, *args, **kwargs)

src/locks/lockhandler.py

@@ -107,7 +107,7 @@ to any other identifier you can use.
 import re, inspect
 from django.conf import settings
 from src.utils import logger, utils
-
+__all__ = ("LockHandler", )
 #
 # Exception class
 #
@@ -120,17 +120,17 @@ class LockException(Exception):
 # Cached lock functions
 #
 
-LOCKFUNCS = {}
+_LOCKFUNCS = {}
-def cache_lockfuncs():
+def _cache_lockfuncs():
     "Updates the cache."
-    global LOCKFUNCS
+    global _LOCKFUNCS
-    LOCKFUNCS = {}
+    _LOCKFUNCS = {}
     for modulepath in settings.LOCK_FUNC_MODULES:
         modulepath = utils.pypath_to_realpath(modulepath)
         mod = utils.mod_import(modulepath)
         if mod:
             for tup in (tup for tup in inspect.getmembers(mod) if callable(tup[1])):
-                LOCKFUNCS[tup[0]] = tup[1]
+                _LOCKFUNCS[tup[0]] = tup[1]
         else:
             logger.log_errmsg("Couldn't load %s from PERMISSION_FUNC_MODULES." % modulepath)
 
@@ -138,9 +138,9 @@ def cache_lockfuncs():
 # pre-compiled regular expressions
 #
 
-RE_FUNCS = re.compile(r"\w+\([^)]*\)")
+_RE_FUNCS = re.compile(r"\w+\([^)]*\)")
-RE_SEPS = re.compile(r"(?<=[ )])AND(?=\s)|(?<=[ )])OR(?=\s)|(?<=[ )])NOT(?=\s)")
+_RE_SEPS = re.compile(r"(?<=[ )])AND(?=\s)|(?<=[ )])OR(?=\s)|(?<=[ )])NOT(?=\s)")
-RE_OK = re.compile(r"%s|and|or|not")
+_RE_OK = re.compile(r"%s|and|or|not")
 
 
 #
@@ -160,8 +160,8 @@ class LockHandler(object):
         Loads and pre-caches all relevant locks and their
         functions.
         """
-        if not LOCKFUNCS:
+        if not _LOCKFUNCS:
-            cache_lockfuncs()
+            _cache_lockfuncs()
         self.obj = obj
         self.locks = {}
         self.log_obj = None
@@ -206,12 +206,12 @@ class LockHandler(object):
                 return locks
 
             # parse the lock functions and separators
-            funclist = RE_FUNCS.findall(rhs)                                           
+            funclist = _RE_FUNCS.findall(rhs)
             evalstring = rhs.replace('AND','and').replace('OR','or').replace('NOT','not')
             nfuncs = len(funclist)
             for funcstring in funclist:
                 funcname, rest = (part.strip().strip(')') for part in funcstring.split('(', 1))
-                func = LOCKFUNCS.get(funcname, None)                    
+                func = _LOCKFUNCS.get(funcname, None)
                 if not callable(func):
                     elist.append("Lock: function '%s' is not available." % funcstring)
                     continue
@@ -223,7 +223,7 @@ class LockHandler(object):
                 continue
             try:
                 # purge the eval string of any superfluos items, then test it
-                evalstring = " ".join(RE_OK.findall(evalstring))
+                evalstring = " ".join(_RE_OK.findall(evalstring))
                 eval(evalstring % tuple(True for func in funclist))
             except Exception:
                 elist.append("Lock: definition '%s' has syntax errors." % raw_lockstring)
@@ -273,7 +273,7 @@ class LockHandler(object):
             if rhs.count('(') != rhs.count(')'):
                 self._log_error("Lock: '%s' has mismatched parentheses." % lockdef)
                 return False
-            if not RE_FUNCS.findall(rhs):
+            if not _RE_FUNCS.findall(rhs):
                 self._log_error("Lock: '%s' has no valid lock functions." % lockdef)
                 return False
         # get the lock string
@@ -381,7 +381,7 @@ class LockHandler(object):
             true_false = tuple(tup[0](accessing_obj, self.obj, *tup[1], **tup[2]) for tup in func_tup)
             return eval(evalstring % true_false)
 
-def test():
+def _test():
     # testing
 
     class TestObj(object):

src/objects/manager.py

@@ -10,9 +10,11 @@ from src.utils import utils
 from src.utils.utils import to_unicode
 from src.utils import logger
 
+__all__ = ("ObjectManager",)
+
 # Try to use a custom way to parse id-tagged multimatches.
 
-AT_MULTIMATCH_INPUT = utils.mod_import(*settings.SEARCH_AT_MULTIMATCH_INPUT.rsplit('.', 1))
+_AT_MULTIMATCH_INPUT = utils.mod_import(*settings.SEARCH_AT_MULTIMATCH_INPUT.rsplit('.', 1))
 
 class ObjectManager(TypedObjectManager):
     """
@@ -288,7 +290,7 @@ class ObjectManager(TypedObjectManager):
         matches = local_and_global_search(ostring, exact=True)
         if not matches:
             # if we have no match, check if we are dealing with an "N-keyword" query - if so, strip it.
-            match_number, ostring = AT_MULTIMATCH_INPUT(ostring)
+            match_number, ostring = _AT_MULTIMATCH_INPUT(ostring)
             if match_number != None and ostring:
                 # Run search again, without match number:
                 matches = local_and_global_search(ostring, exact=True)

src/objects/models.py

@@ -32,7 +32,8 @@ from src.scripts.scripthandler import ScriptHandler
 from src.utils import logger
 from src.utils.utils import make_iter, to_unicode, to_str, mod_import
 
-#PlayerDB = ContentType.objects.get(app_label="players", model="playerdb").model_class()
+#__all__ = ("ObjAttribute", "Alias", "ObjectNick", "ObjectDB")
+
 
 _AT_SEARCH_RESULT = mod_import(*settings.SEARCH_AT_RESULT.rsplit('.', 1))
 
@@ -211,7 +212,7 @@ class ObjectDB(TypedObject):
 
     # aliases property (wraps (db_aliases)
     #@property
-    def aliases_get(self):
+    def __aliases_get(self):
         "Getter. Allows for value = self.aliases"
         try:
             return _GA(self, "_cached_aliases")
@@ -220,23 +221,23 @@ class ObjectDB(TypedObject):
             _SA(self, "_cached_aliases", aliases)
             return aliases
     #@aliases.setter
-    def aliases_set(self, aliases):
+    def __aliases_set(self, aliases):
         "Setter. Allows for self.aliases = value"
         for alias in make_iter(aliases):
             new_alias = Alias(db_key=alias, db_obj=self)
             new_alias.save()
         _SA(self, "_cached_aliases", aliases)
     #@aliases.deleter
-    def aliases_del(self):
+    def __aliases_del(self):
         "Deleter. Allows for del self.aliases"
         for alias in Alias.objects.filter(db_obj=self):
             alias.delete()
         _DA(self, "_cached_aliases")
-    aliases = property(aliases_get, aliases_set, aliases_del)
+    aliases = property(__aliases_get, __aliases_set, __aliases_del)
 
     # player property (wraps db_player)
     #@property
-    def player_get(self):
+    def __player_get(self):
         """
         Getter. Allows for value = self.player.
         We have to be careful here since Player is also
@@ -244,29 +245,29 @@ class ObjectDB(TypedObject):
         """
         return _get_cache(self, "player")
     #@player.setter
-    def player_set(self, player):
+    def __player_set(self, player):
         "Setter. Allows for self.player = value"
         if isinstance(player, TypeClass):
             player = player.dbobj
         _set_cache(self, "player", player)
     #@player.deleter
-    def player_del(self):
+    def __player_del(self):
         "Deleter. Allows for del self.player"
         self.db_player = None
         self.save()
         _del_cache(self, "player")
-    player = property(player_get, player_set, player_del)
+    player = property(__player_get, __player_set, __player_del)
 
     # location property (wraps db_location)
     #@property
-    def location_get(self):
+    def __location_get(self):
         "Getter. Allows for value = self.location."
         loc = _get_cache(self, "location")
         if loc:
             return loc.typeclass
         return None
     #@location.setter
-    def location_set(self, location):
+    def __location_set(self, location):
         "Setter. Allows for self.location = location"
         try:
             if location == None or type(location) == ObjectDB:
@@ -289,23 +290,23 @@ class ObjectDB(TypedObject):
             logger.log_trace(string)
             raise
     #@location.deleter
-    def location_del(self):
+    def __location_del(self):
         "Deleter. Allows for del self.location"
         self.db_location = None
         self.save()
         _del_cache(self, "location")
-    location = property(location_get, location_set, location_del)
+    location = property(__location_get, __location_set, __location_del)
 
     # home property (wraps db_home)
     #@property
-    def home_get(self):
+    def __home_get(self):
         "Getter. Allows for value = self.home"
         home = _get_cache(self, "home")
         if home:
             return home.typeclass
         return None
     #@home.setter
-    def home_set(self, home):
+    def __home_set(self, home):
         "Setter. Allows for self.home = value"
         try:
             if home == None or type(home) == ObjectDB:
@@ -326,23 +327,23 @@ class ObjectDB(TypedObject):
             logger.log_trace(string)
             #raise
     #@home.deleter
-    def home_del(self):
+    def __home_del(self):
         "Deleter. Allows for del self.home."
         self.db_home = None
         self.save()
         _del_cache(self, "home")
-    home = property(home_get, home_set, home_del)
+    home = property(__home_get, __home_set, __home_del)
 
     # destination property (wraps db_destination)
     #@property
-    def destination_get(self):
+    def __destination_get(self):
         "Getter. Allows for value = self.destination."
         dest = _get_cache(self, "destination")
         if dest:
             return dest.typeclass
         return None
     #@destination.setter
-    def destination_set(self, destination):
+    def __destination_set(self, destination):
         "Setter. Allows for self.destination = destination"
         try:
             if destination == None or type(destination) == ObjectDB:
@@ -365,33 +366,33 @@ class ObjectDB(TypedObject):
             logger.log_trace(string)
             raise
     #@destination.deleter
-    def destination_del(self):
+    def __destination_del(self):
         "Deleter. Allows for del self.destination"
         self.db_destination = None
         self.save()
         _del_cache(self, "destination")
-    destination = property(destination_get, destination_set, destination_del)
+    destination = property(__destination_get, __destination_set, __destination_del)
 
     # cmdset_storage property.
     # This seems very sensitive to caching, so leaving it be for now. /Griatch
     #@property
-    def cmdset_storage_get(self):
+    def __cmdset_storage_get(self):
         "Getter. Allows for value = self.name. Returns a list of cmdset_storage."
         if self.db_cmdset_storage:
             return [path.strip() for path  in self.db_cmdset_storage.split(',')]
         return []
     #@cmdset_storage.setter
-    def cmdset_storage_set(self, value):
+    def __cmdset_storage_set(self, value):
         "Setter. Allows for self.name = value. Stores as a comma-separated string."
         value = ",".join(str(val).strip() for val in make_iter(value))
         self.db_cmdset_storage = value
         self.save()
     #@cmdset_storage.deleter
-    def cmdset_storage_del(self):
+    def __cmdset_storage_del(self):
         "Deleter. Allows for del self.name"
         self.db_cmdset_storage = ""
         self.save()
-    cmdset_storage = property(cmdset_storage_get, cmdset_storage_set, cmdset_storage_del)
+    cmdset_storage = property(__cmdset_storage_get, __cmdset_storage_set, __cmdset_storage_del)
 
     class Meta:
         "Define Django meta options"
@@ -409,7 +410,7 @@ class ObjectDB(TypedObject):
     _default_typeclass_path = settings.BASE_OBJECT_TYPECLASS or "src.objects.objects.Object"
 
     #@property
-    def sessions_get(self):
+    def __sessions_get(self):
         """
         Retrieve sessions connected to this object.
         """
@@ -417,42 +418,43 @@ class ObjectDB(TypedObject):
         if self.player:
             return self.player.sessions
         return []
-    sessions = property(sessions_get)
+    sessions = property(__sessions_get)
 
     #@property
-    def has_player_get(self):
+    def __has_player_get(self):
         """
         Convenience function for checking if an active player is
         currently connected to this object
         """
         return any(self.sessions)
-    has_player = property(has_player_get)
+    has_player = property(__has_player_get)
-    is_player = property(has_player_get)
+    is_player = property(__has_player_get)
 
     #@property
-    def is_superuser_get(self):
+    def __is_superuser_get(self):
         "Check if user has a player, and if so, if it is a superuser."
         return any(self.sessions) and self.player.is_superuser
-    is_superuser = property(is_superuser_get)
+    is_superuser = property(__is_superuser_get)
 
     #@property
     def contents_get(self, exclude=None):
         """
         Returns the contents of this object, i.e. all
         objects that has this object set as its location.
+        This should be publically available.
         """
         return ObjectDB.objects.get_contents(self, excludeobj=exclude)
     contents = property(contents_get)
 
     #@property
-    def exits_get(self):
+    def __exits_get(self):
         """
         Returns all exits from this object, i.e. all objects
         at this location having the property destination != None.
         """
         return [exi for exi in self.contents
                 if exi.destination]
-    exits = property(exits_get)
+    exits = property(__exits_get)
 
 
     #

src/objects/objects.py

@@ -17,6 +17,7 @@ they control by simply linking to a new object's user property.
 
 from src.typeclasses.typeclass import TypeClass
 from src.commands import cmdset, command
+__all__ = ("Object", "Character", "Room", "Exit")
 
 #
 # Base class to inherit from.
@@ -24,11 +25,10 @@ from src.commands import cmdset, command
 
 class Object(TypeClass):
     """
-    This is the base class for all in-game objects.
+    This is the base class for all in-game objects.  Inherit from this
-    Inherit from this to create different types of
+    to create different types of objects in the game.
-    objects in the game.
     """
-
+    # __init__ is only defined here in order to present docstring to API.
     def __init__(self, dbobj):
         """
         This is the root typeclass object, implementing an in-game Evennia

src/players/manager.py

@@ -8,6 +8,7 @@ from django.db import models
 from django.contrib.auth.models import User
 from src.typeclasses.managers import returns_typeclass_list, returns_typeclass, TypedObjectManager
 from src.utils import logger
+__all__ = ("PlayerManager",)
 
 #
 # Player Manager
@@ -206,4 +207,3 @@ class PlayerManager(TypedObjectManager):
         if delete_old_character:
             old_character.delete()
         return True
-        

src/players/models.py

@@ -53,6 +53,8 @@ from src.utils import logger, utils
 from src.commands.cmdsethandler import CmdSetHandler
 from src.commands import cmdhandler
 
+__all__  = ("PlayerAttribute", "PlayerNick", "PlayerDB")
+
 _AT_SEARCH_RESULT = utils.mod_import(*settings.SEARCH_AT_RESULT.rsplit('.', 1))
 
 #------------------------------------------------------------

src/players/player.py

@@ -12,7 +12,7 @@ instead for most things).
 """
 from django.conf import settings
 from src.typeclasses.typeclass import TypeClass
-
+__all__ = ("Player",)
 CMDSET_OOC = settings.CMDSET_OOC
 
 class Player(TypeClass):

src/scripts/manager.py

@@ -4,6 +4,7 @@ The custom manager for Scripts.
 
 from src.typeclasses.managers import TypedObjectManager
 from src.typeclasses.managers import returns_typeclass_list
+__all__ = ("ScriptManager",)
 
 VALIDATE_ITERATION = 0
 

src/scripts/models.py

@@ -30,6 +30,8 @@ from src.typeclasses.models import Attribute, TypedObject
 from django.contrib.contenttypes.models import ContentType
 from src.scripts.manager import ScriptManager
 
+__all__ = ("ScriptAttribute", "ScriptDB")
+
 #------------------------------------------------------------
 #
 # ScriptAttribute
@@ -121,122 +123,122 @@ class ScriptDB(TypedObject):
 
     # desc property (wraps db_desc)
     #@property
-    def desc_get(self):
+    def __desc_get(self):
         "Getter. Allows for value = self.desc"
         return self.db_desc
     #@desc.setter
-    def desc_set(self, value):
+    def __desc_set(self, value):
         "Setter. Allows for self.desc = value"
         self.db_desc = value
         self.save()
     #@desc.deleter
-    def desc_del(self):
+    def __desc_del(self):
         "Deleter. Allows for del self.desc"
         self.db_desc = ""
         self.save()
-    desc = property(desc_get, desc_set, desc_del)
+    desc = property(__desc_get, __desc_set, __desc_del)
 
     # obj property (wraps db_obj)
     #@property
-    def obj_get(self):
+    def __obj_get(self):
         "Getter. Allows for value = self.obj"
         return self.db_obj
     #@obj.setter
-    def obj_set(self, value):
+    def __obj_set(self, value):
         "Setter. Allows for self.obj = value"
         self.db_obj = value
         self.save()
     #@obj.deleter
-    def obj_del(self):
+    def __obj_del(self):
         "Deleter. Allows for del self.obj"
         self.db_obj = None
         self.save()
-    obj = property(obj_get, obj_set, obj_del)
+    obj = property(__obj_get, __obj_set, __obj_del)
 
     # interval property (wraps db_interval)
     #@property
-    def interval_get(self):
+    def __interval_get(self):
         "Getter. Allows for value = self.interval"
         return self.db_interval
     #@interval.setter
-    def interval_set(self, value):
+    def __interval_set(self, value):
         "Setter. Allows for self.interval = value"
         self.db_interval = int(value)
         self.save()
     #@interval.deleter
-    def interval_del(self):
+    def __interval_del(self):
         "Deleter. Allows for del self.interval"
         self.db_interval = 0
         self.save()
-    interval = property(interval_get, interval_set, interval_del)
+    interval = property(__interval_get, __interval_set, __interval_del)
 
     # start_delay property (wraps db_start_delay)
     #@property
-    def start_delay_get(self):
+    def __start_delay_get(self):
         "Getter. Allows for value = self.start_delay"
         return self.db_start_delay
     #@start_delay.setter
-    def start_delay_set(self, value):
+    def __start_delay_set(self, value):
         "Setter. Allows for self.start_delay = value"
         self.db_start_delay = value
         self.save()
     #@start_delay.deleter
-    def start_delay_del(self):
+    def __start_delay_del(self):
         "Deleter. Allows for del self.start_delay"
         self.db_start_delay = False
         self.save()
-    start_delay = property(start_delay_get, start_delay_set, start_delay_del)
+    start_delay = property(__start_delay_get, __start_delay_set, __start_delay_del)
 
     # repeats property (wraps db_repeats)
     #@property
-    def repeats_get(self):
+    def __repeats_get(self):
         "Getter. Allows for value = self.repeats"
         return self.db_repeats
     #@repeats.setter
-    def repeats_set(self, value):
+    def __repeats_set(self, value):
         "Setter. Allows for self.repeats = value"
         self.db_repeats = int(value)
         self.save()
     #@repeats.deleter
-    def repeats_del(self):
+    def __repeats_del(self):
         "Deleter. Allows for del self.repeats"
         self.db_repeats = 0
         self.save()
-    repeats = property(repeats_get, repeats_set, repeats_del)
+    repeats = property(__repeats_get, __repeats_set, __repeats_del)
 
     # persistent property (wraps db_persistent)
     #@property
-    def persistent_get(self):
+    def __persistent_get(self):
         "Getter. Allows for value = self.persistent"
         return self.db_persistent
     #@persistent.setter
-    def persistent_set(self, value):
+    def __persistent_set(self, value):
         "Setter. Allows for self.persistent = value"
         self.db_persistent = value
         self.save()
     #@persistent.deleter
-    def persistent_del(self):
+    def __persistent_del(self):
         "Deleter. Allows for del self.persistent"
         self.db_persistent = False
         self.save()
-    persistent = property(persistent_get, persistent_set, persistent_del)
+    persistent = property(__persistent_get, __persistent_set, __persistent_del)
 
     # is_active property (wraps db_is_active)
     #@property
-    def is_active_get(self):
+    def __is_active_get(self):
         "Getter. Allows for value = self.is_active"
         return self.db_is_active
     #@is_active.setter
-    def is_active_set(self, value):
+    def __is_active_set(self, value):
         "Setter. Allows for self.is_active = value"
         self.db_is_active = value
         self.save()
     #@is_active.deleter
-    def is_active_del(self):
+    def __is_active_del(self):
         "Deleter. Allows for del self.is_active"
         self.db_is_active = False
         self.save()
-    is_active = property(is_active_get, is_active_set, is_active_del)
+    is_active = property(__is_active_get, __is_active_set, __is_active_del)
 
     #
     #

src/scripts/scripts.py

@@ -15,6 +15,8 @@ from src.scripts.models import ScriptDB
 from src.comms import channelhandler
 from src.utils import logger
 
+__all__ = ("Script", "DoNothing", "CheckSessions", "ValidateScripts", "ValidateChannelHandler", "AddCmdSet")
+
 #
 # Base script, inherit from Script below instead.
 #
@@ -272,9 +274,9 @@ class Script(ScriptClass):
 
          desc (string)      - optional description of script, shown in listings
          obj (Object)       - optional object that this script is connected to and acts on (set automatically by obj.scripts.add())
-         interval (int)     - how often script should run, in seconds. <0 turns off ticker
+         interval (int)     - how often script should run, in seconds. <=0 turns off ticker
          start_delay (bool) - if the script should start repeating right away or wait self.interval seconds
-         repeats (int)      - how many times the script should repeat before stopping. 0 means infinite repeats
+         repeats (int)      - how many times the script should repeat before stopping. <=0 means infinite repeats
          persistent (bool)  - if script should survive a server shutdown or not
          is_active (bool)   - if script is currently running
 
@@ -309,7 +311,7 @@ class Script(ScriptClass):
           at_repeat() - Called every self.interval seconds. It will be called immediately
                       upon launch unless self.delay_start is True, which will delay
                       the first call of this method by self.interval seconds. If
-                      self.interval==0, this method will never be called. 
+                      self.interval<=0, this method will never be called.
           at_stop() - Called as the script object is stopped and is about to be removed from
                       the game, e.g. because is_valid() returned False.
           at_server_reload() - Called when server reloads. Can be used to save temporary

src/typeclasses/managers.py

@@ -7,7 +7,7 @@ from functools import update_wrapper
 from django.db import models
 from src.utils import idmapper
 from src.utils.utils import make_iter
-#from src.typeclasses import idmap
+__all__ = ("AttributeManager", "TypedObjectManager")
 
 # Managers
 

src/typeclasses/models.py

@@ -43,6 +43,8 @@ from src.locks.lockhandler import LockHandler
 from src.utils import logger, utils
 from src.utils.utils import make_iter, is_iter, has_parent, to_unicode, to_str
 
+__all__ = ("Attribute", "TypeNick", "TypedObject")
+
 _PERMISSION_HIERARCHY = [p.lower() for p in settings.PERMISSION_HIERARCHY]
 
 _CTYPEGET = ContentType.objects.get

src/typeclasses/typeclass.py

@@ -13,6 +13,8 @@ used by the typesystem or django itself.
 from src.utils.logger import log_trace, log_errmsg
 from django.conf import settings
 
+__all__ = ("TypeClass",)
+
 # these are called so many times it's worth to avoid lookup calls
 _GA = object.__getattribute__
 _SA = object.__setattr__