From 8314d8ba5e37b52afad8b1b993895b6effe26560 Mon Sep 17 00:00:00 2001 From: Griatch Date: Sat, 20 Dec 2014 17:03:34 +0100 Subject: [PATCH] Now solving issues with faulty imports. Still nothing functional. --- src/comms/comms.py | 14 +++++++++++++- src/objects/objects.py | 18 +++++++++++++++--- src/players/models.py | 5 ----- src/players/player.py | 18 ++++++++++++++---- src/scripts/scripts.py | 19 ++++++++++++++++--- src/typeclasses/managers.py | 2 +- src/typeclasses/models.py | 35 +++++++++++++++++------------------ src/utils/idmapper/base.py | 3 +-- 8 files changed, 77 insertions(+), 37 deletions(-) diff --git a/src/comms/comms.py b/src/comms/comms.py index c7284b7401..8965555153 100644 --- a/src/comms/comms.py +++ b/src/comms/comms.py @@ -14,7 +14,19 @@ class Channel(ChannelDB): This is the base class for all Comms. Inherit from this to create different types of communication channels. """ - __metaclass__ = TypeclassBase + + def __new__(cls, *args, **kwargs): + """ + We must define our Typeclasses as proxies. We also store the path + directly on the class, this is useful for managers. + """ + if hasattr(cls, "Meta"): + cls.Meta.proxy = True + else: + class Meta: + proxy = True + cls.Meta = Meta + return super(TypeclassBase, cls).__new__(*args, **kwargs) # helper methods, for easy overloading diff --git a/src/objects/objects.py b/src/objects/objects.py index 990c83d109..32b7848af4 100644 --- a/src/objects/objects.py +++ b/src/objects/objects.py @@ -37,9 +37,21 @@ class Object(ObjectDB): This is the base class for all in-game objects. Inherit from this to create different types of objects in the game. """ - __metaclass__ = TypeclassBase + def __new__(cls, *args, **kwargs): + """ + We must define our Typeclasses as proxies. We also store the path + directly on the class, this is useful for managers. + """ + if hasattr(cls, "Meta"): + cls.Meta.proxy = True + else: + class Meta: + proxy = True + cls.Meta = Meta + return super(Object, cls).__new__(*args, **kwargs) + # __init__ is only defined here in order to present docstring to API. - def __init__(self, dbobj): + def __init__(self): """ This is the root typeclass object, representing all entities that have an actual presence in-game. Objects generally have a @@ -190,7 +202,7 @@ class Object(ObjectDB): this object speaks """ - super(Object, self).__init__(dbobj) + super(Object, self).__init__() ## methods inherited from the database object (overload them here) diff --git a/src/players/models.py b/src/players/models.py index d8c341b814..86d63831c5 100644 --- a/src/players/models.py +++ b/src/players/models.py @@ -162,11 +162,6 @@ class PlayerDB(TypedObject, AbstractUser): _GA(self, "save")() cmdset_storage = property(cmdset_storage_get, cmdset_storage_set, cmdset_storage_del) - class Meta: - "Define Django meta options" - verbose_name = "Player" - verbose_name_plural = "Players" - # # PlayerDB main class properties and methods # diff --git a/src/players/player.py b/src/players/player.py index 30e566aeec..52fa9c7dac 100644 --- a/src/players/player.py +++ b/src/players/player.py @@ -14,7 +14,6 @@ instead for most things). import datetime from django.conf import settings from src.players.models import PlayerDB -from src.typeclasses.models import TypeclassBase from src.comms.models import ChannelDB from src.utils import logger __all__ = ("Player",) @@ -28,9 +27,20 @@ class Player(PlayerDB): """ Base typeclass for all Players. """ - __metaclass__ = TypeclassBase + def __new__(cls, *args, **kwargs): + """ + We must define our Typeclasses as proxies. We also store the path + directly on the class, this is useful for managers. + """ + if hasattr(cls, "Meta"): + cls.Meta.proxy = True + else: + class Meta: + proxy = True + cls.Meta = Meta + return super(Player, cls).__new__(*args, **kwargs) - def __init__(self, dbobj): + def __init__(self): """ This is the base Typeclass for all Players. Players represent the person playing the game and tracks account info, password @@ -104,7 +114,7 @@ class Player(PlayerDB): at_server_shutdown() """ - super(Player, self).__init__(dbobj) + super(Player, self).__init__() ## methods inherited from database model diff --git a/src/scripts/scripts.py b/src/scripts/scripts.py index 78e79bf81a..e33987389b 100644 --- a/src/scripts/scripts.py +++ b/src/scripts/scripts.py @@ -113,9 +113,22 @@ class ScriptBase(ScriptDB): Base class for scripts. Don't inherit from this, inherit from the class 'Script' instead. """ - __metaclass__ = TypeclassBase + #__metaclass__ = TypeclassBase # private methods + def __new__(cls, *args, **kwargs): + """ + We must define our Typeclasses as proxies. We also store the path + directly on the class, this is useful for managers. + """ + if hasattr(cls, "Meta"): + cls.Meta.proxy = True + else: + class Meta: + proxy = True + cls.Meta = Meta + return super(ScriptBase, cls).__new__(*args, **kwargs) + def __eq__(self, other): """ This has to be located at this level, having it in the @@ -355,7 +368,7 @@ class Script(ScriptBase): the hooks called by the script machinery. """ - def __init__(self, dbobj): + def __init__(self): """ This is the base TypeClass for all Scripts. Scripts describe events, timers and states in game, they can have a time component or describe @@ -442,7 +455,7 @@ class Script(ScriptBase): """ - super(Script, self).__init__(dbobj) + super(Script, self).__init__() def at_script_creation(self): """ diff --git a/src/typeclasses/managers.py b/src/typeclasses/managers.py index fd07bdd853..1fa7bd88b3 100644 --- a/src/typeclasses/managers.py +++ b/src/typeclasses/managers.py @@ -8,7 +8,7 @@ from django.db.models import Q from src.utils import idmapper from src.utils.utils import make_iter, variable_from_module -__all__ = ("AttributeManager", "TypedObjectManager") +__all__ = ("TypedObjectManager", ) _GA = object.__getattribute__ _Tag = None diff --git a/src/typeclasses/models.py b/src/typeclasses/models.py index 961e4a0b20..cd373be79b 100644 --- a/src/typeclasses/models.py +++ b/src/typeclasses/models.py @@ -742,24 +742,23 @@ class PermissionHandler(TagHandler): # imported for access by other from src.utils.idmapper.base import SharedMemoryModelBase -class TypeclassBase(SharedMemoryModelBase): - """ - Metaclass which should be set for the root of model proxies - that don't define any new fields, like Object, Script etc. - """ - def __init__(cls, *args, **kwargs): - """ - We must define our Typeclasses as proxies. We also store the path - directly on the class, this is useful for managers. - """ - super(TypeclassBase, cls).__init__(*args, **kwargs) - class Meta: - # this is the important bit - proxy = True - cls.Meta = Meta - # convenience for manager methods - #cls.typename = cls.__name__ - #cls.path = "%s.%s" % (cls.__module__, cls.__name__) +#class TypeclassBase(SharedMemoryModelBase): +# """ +# Metaclass which should be set for the root of model proxies +# that don't define any new fields, like Object, Script etc. +# """ +# def __new__(cls, name, bases, attrs): +# """ +# We must define our Typeclasses as proxies. We also store the path +# directly on the class, this is useful for managers. +# """ +# if hasattr(cls, "Meta"): +# cls.Meta.proxy = True +# else: +# class Meta: +# proxy = True +# cls.Meta = Meta +# return super(TypeclassBase, cls).__new__(name, bases, attrs) class TypedObject(SharedMemoryModel): diff --git a/src/utils/idmapper/base.py b/src/utils/idmapper/base.py index 231f005831..259d38721e 100755 --- a/src/utils/idmapper/base.py +++ b/src/utils/idmapper/base.py @@ -95,7 +95,6 @@ class SharedMemoryModelBase(ModelBase): already has a wrapper of the given name, the automatic creation is skipped. Note: Remember to document this auto-wrapping in the class header, this could seem very much like magic to the user otherwise. """ - def create_wrapper(cls, fieldname, wrappername, editable=True, foreignkey=False): "Helper method to create property wrappers with unique names (must be in separate call)" def _get(cls, fname): @@ -190,7 +189,6 @@ class SharedMemoryModelBase(ModelBase): #print "wrapping %s -> %s" % (fieldname, wrappername) create_wrapper(cls, fieldname, wrappername, editable=field.editable, foreignkey=foreignkey) - # django patch # Evennia mod, based on Django Ticket #11560: https://code.djangoproject.com/ticket/11560 # The actual patch is small and further down. @@ -432,6 +430,7 @@ class SharedMemoryModelBase(ModelBase): super(SharedMemoryModelBase, cls).__init__(*args, **kwargs) cls.typename = cls.__name__ cls.path = "%s.%s" % (cls.__module__, cls.__name__) + print "shared __init__", cls class SharedMemoryModel(Model): # CL: setting abstract correctly to allow subclasses to inherit the default