Astron: Remove MsgType wildcard imports

Author: Snowy

direct/src/distributed/AstronClientRepository.py

@@ -2,10 +2,11 @@
 
 from direct.directnotify import DirectNotifyGlobal
 from .ClientRepositoryBase import ClientRepositoryBase
-from .MsgTypes import *
+from . import MsgTypes
 from direct.distributed.PyDatagram import PyDatagram
 from panda3d.direct import STUint16, STUint32
 
+
 class AstronClientRepository(ClientRepositoryBase):
     """
     The Astron implementation of a clients repository for
@@ -22,7 +23,7 @@ class AstronClientRepository(ClientRepositoryBase):
     * LOST_CONNECTION ()
     """
 
-    notify = DirectNotifyGlobal.directNotify.newCategory("ClientRepository")
+    notify = DirectNotifyGlobal.directNotify.newCategory("AstronClientRepository")
 
     # This is required by DoCollectionManager, even though it's not
     # used by this implementation.
@@ -31,37 +32,35 @@ class AstronClientRepository(ClientRepositoryBase):
     def __init__(self, *args, **kwargs):
         ClientRepositoryBase.__init__(self, *args, **kwargs)
         base.finalExitCallbacks.append(self.shutdown)
-        self.message_handlers = {CLIENT_HELLO_RESP: self.handleHelloResp,
-                                 CLIENT_EJECT: self.handleEject,
-                                 CLIENT_ENTER_OBJECT_REQUIRED: self.handleEnterObjectRequired,
-                                 CLIENT_ENTER_OBJECT_REQUIRED_OWNER: self.handleEnterObjectRequiredOwner,
-                                 CLIENT_OBJECT_SET_FIELD: self.handleUpdateField,
-                                 CLIENT_OBJECT_SET_FIELDS: self.handleUpdateFields,
-                                 CLIENT_OBJECT_LEAVING: self.handleObjectLeaving,
-                                 CLIENT_OBJECT_LOCATION: self.handleObjectLocation,
-                                 CLIENT_ADD_INTEREST: self.handleAddInterest,
-                                 CLIENT_ADD_INTEREST_MULTIPLE: self.handleAddInterestMultiple,
-                                 CLIENT_REMOVE_INTEREST: self.handleRemoveInterest,
-                                 CLIENT_DONE_INTEREST_RESP: self.handleInterestDoneMessage,
-                                 }
+        self.message_handlers = {
+            MsgTypes.CLIENT_HELLO_RESP: self.handleHelloResp,
+            MsgTypes.CLIENT_EJECT: self.handleEject,
+            MsgTypes.CLIENT_ENTER_OBJECT_REQUIRED: self.handleEnterObjectRequired,
+            MsgTypes.CLIENT_ENTER_OBJECT_REQUIRED_OWNER: self.handleEnterObjectRequiredOwner,
+            MsgTypes.CLIENT_OBJECT_SET_FIELD: self.handleUpdateField,
+            MsgTypes.CLIENT_OBJECT_SET_FIELDS: self.handleUpdateFields,
+            MsgTypes.CLIENT_OBJECT_LEAVING: self.handleObjectLeaving,
+            MsgTypes.CLIENT_OBJECT_LOCATION: self.handleObjectLocation,
+            MsgTypes.CLIENT_ADD_INTEREST: self.handleAddInterest,
+            MsgTypes.CLIENT_ADD_INTEREST_MULTIPLE: self.handleAddInterestMultiple,
+            MsgTypes.CLIENT_REMOVE_INTEREST: self.handleRemoveInterest,
+            MsgTypes.CLIENT_DONE_INTEREST_RESP: self.handleInterestDoneMessage,
+        }
 
     #
     # Message Handling
     #
 
     def handleDatagram(self, di):
         msgType = self.getMsgType()
-    #    self.handleMessageType(msgType, di)
-    #
-    #def handleMessageType(self, msgType, di):
         if msgType in self.message_handlers:
             self.message_handlers[msgType](di)
         else:
             self.notify.error("Got unknown message type %d!" % (msgType,))
 
         self.considerHeartbeat()
 
-    def handleHelloResp(self, di):
+    def handleHelloResp(self, _):
         messenger.send("CLIENT_HELLO_RESP", [])
 
     def handleEject(self, di):
@@ -127,19 +126,7 @@ def generateWithRequiredFieldsOwner(self, dclass, doId, di):
         return distObj
 
     def handleUpdateFields(self, di):
-        # Can't test this without the server actually sending it.
         self.notify.error("CLIENT_OBJECT_SET_FIELDS not implemented!")
-        # # Here's some tentative code and notes:
-        # do_id = di.getUint32()
-        # field_count = di.getUint16()
-        # for i in range(0, field_count):
-        #     field_id = di.getUint16()
-        #     field = self.get_dc_file().get_field_by_index(field_id)
-        #     # print(type(field))
-        #     # print(field)
-        #     # FIXME: Get field type, unpack value, create and send message.
-        #     # value = di.get?()
-        #     # Assemble new message
 
     def handleObjectLeaving(self, di):
         do_id = di.get_uint32()
@@ -201,35 +188,33 @@ def deleteObject(self, doId):
                 self.freeDoId(doId)
         else:
             # Otherwise, ignore it
-            self.notify.warning(
-                "Asked to delete non-existent DistObj " + str(doId))
+            self.notify.warning("Asked to delete non-existent DistObj " + str(doId))
 
     #
     # Sending messages
     #
 
     def sendUpdate(self, distObj, fieldName, args):
         """ Sends a normal update for a single field. """
-        dg = distObj.dclass.clientFormatUpdate(
-            fieldName, distObj.doId, args)
+        dg = distObj.dclass.clientFormatUpdate(fieldName, distObj.doId, args)
         self.send(dg)
 
     # FIXME: The version string should default to a .prc variable.
     def sendHello(self, version_string):
         dg = PyDatagram()
-        dg.add_uint16(CLIENT_HELLO)
+        dg.add_uint16(MsgTypes.CLIENT_HELLO)
         dg.add_uint32(self.get_dc_file().get_hash())
         dg.add_string(version_string)
         self.send(dg)
 
     def sendHeartbeat(self):
         datagram = PyDatagram()
-        datagram.addUint16(CLIENT_HEARTBEAT)
+        datagram.addUint16(MsgTypes.CLIENT_HEARTBEAT)
         self.send(datagram)
 
     def sendAddInterest(self, context, interest_id, parent_id, zone_id):
         dg = PyDatagram()
-        dg.add_uint16(CLIENT_ADD_INTEREST)
+        dg.add_uint16(MsgTypes.CLIENT_ADD_INTEREST)
         dg.add_uint32(context)
         dg.add_uint16(interest_id)
         dg.add_uint32(parent_id)
@@ -238,7 +223,7 @@ def sendAddInterest(self, context, interest_id, parent_id, zone_id):
 
     def sendAddInterestMultiple(self, context, interest_id, parent_id, zone_ids):
         dg = PyDatagram()
-        dg.add_uint16(CLIENT_ADD_INTEREST_MULTIPLE)
+        dg.add_uint16(MsgTypes.CLIENT_ADD_INTEREST_MULTIPLE)
         dg.add_uint32(context)
         dg.add_uint16(interest_id)
         dg.add_uint32(parent_id)
@@ -249,7 +234,7 @@ def sendAddInterestMultiple(self, context, interest_id, parent_id, zone_ids):
 
     def sendRemoveInterest(self, context, interest_id):
         dg = PyDatagram()
-        dg.add_uint16(CLIENT_REMOVE_INTEREST)
+        dg.add_uint16(MsgTypes.CLIENT_REMOVE_INTEREST)
         dg.add_uint32(context)
         dg.add_uint16(interest_id)
         self.send(dg)

direct/src/distributed/AstronDatabaseInterface.py

@@ -1,10 +1,11 @@
 from panda3d.direct import DCPacker
-from .MsgTypes import *
+from . import MsgTypes
 from direct.directnotify import DirectNotifyGlobal
 from .ConnectionRepository import ConnectionRepository
 from .PyDatagram import PyDatagram
 from .PyDatagramIterator import PyDatagramIterator
 
+
 class AstronDatabaseInterface:
     """
     This class is part of Panda3D's new MMO networking framework.
@@ -22,7 +23,7 @@ def __init__(self, air):
         self._callbacks = {}
         self._dclasses = {}
 
-    def createObject(self, databaseId, dclass, fields={}, callback=None):
+    def createObject(self, databaseId, dclass, fields=None, callback=None):
         """
         Create an object in the specified database.
 
@@ -31,6 +32,8 @@ def createObject(self, databaseId, dclass, fields={}, callback=None):
         fields is a dict with any fields that should be stored in the object on creation.
         callback will be called with callback(doId) if specified. On failure, doId is 0.
         """
+        if fields is None:
+            fields = {}
 
         # Save the callback:
         ctx = self.air.getContext()
@@ -53,7 +56,7 @@ def createObject(self, databaseId, dclass, fields={}, callback=None):
 
         # Now generate and send the datagram:
         dg = PyDatagram()
-        dg.addServerHeader(databaseId, self.air.ourChannel, DBSERVER_CREATE_OBJECT)
+        dg.addServerHeader(databaseId, self.air.ourChannel, MsgTypes.DBSERVER_CREATE_OBJECT)
         dg.addUint32(ctx)
         dg.addUint16(dclass.getNumber())
         dg.addUint16(fieldCount)
@@ -92,18 +95,15 @@ def queryObject(self, databaseId, doId, callback, dclass=None, fieldNames=()):
         dg = PyDatagram()
 
         if not fieldNames:
-            dg.addServerHeader(databaseId, self.air.ourChannel,
-                               DBSERVER_OBJECT_GET_ALL)
+            dg.addServerHeader(databaseId, self.air.ourChannel, MsgTypes.DBSERVER_OBJECT_GET_ALL)
         else:
             # We need a dclass in order to convert the field names into field IDs:
             assert dclass is not None
 
             if len(fieldNames) > 1:
-                dg.addServerHeader(databaseId, self.air.ourChannel,
-                                   DBSERVER_OBJECT_GET_FIELDS)
+                dg.addServerHeader(databaseId, self.air.ourChannel, MsgTypes.DBSERVER_OBJECT_GET_FIELDS)
             else:
-                dg.addServerHeader(databaseId, self.air.ourChannel,
-                                   DBSERVER_OBJECT_GET_FIELD)
+                dg.addServerHeader(databaseId, self.air.ourChannel, MsgTypes.DBSERVER_OBJECT_GET_FIELD)
 
         dg.addUint32(ctx)
         dg.addUint32(doId)
@@ -123,7 +123,7 @@ def handleQueryObjectResp(self, msgType, di):
 
         if ctx not in self._callbacks:
             self.notify.warning('Received unexpected %s'
-                                ' (ctx %d)' % (MsgId2Names[msgType], ctx))
+                                ' (ctx %d)' % (MsgTypes.MsgId2Names[msgType], ctx))
             return
 
         try:
@@ -132,7 +132,7 @@ def handleQueryObjectResp(self, msgType, di):
                     self._callbacks[ctx](None, None)
                 return
 
-            if msgType == DBSERVER_OBJECT_GET_ALL_RESP:
+            if msgType == MsgTypes.DBSERVER_OBJECT_GET_ALL_RESP:
                 dclassId = di.getUint16()
                 dclass = self.air.dclassesByNumber.get(dclassId)
             else:
@@ -142,7 +142,7 @@ def handleQueryObjectResp(self, msgType, di):
                 self.notify.error('Received bad dclass %d in'
                                   ' DBSERVER_OBJECT_GET_ALL_RESP' % (dclassId))
 
-            if msgType == DBSERVER_OBJECT_GET_FIELD_RESP:
+            if msgType == MsgTypes.DBSERVER_OBJECT_GET_FIELD_RESP:
                 fieldCount = 1
             else:
                 fieldCount = di.getUint16()
@@ -224,18 +224,18 @@ def updateObject(self, databaseId, doId, dclass, newFields, oldFields=None, call
             self._callbacks[ctx] = callback
             if fieldCount == 1:
                 dg.addServerHeader(databaseId, self.air.ourChannel,
-                                   DBSERVER_OBJECT_SET_FIELD_IF_EQUALS)
+                                   MsgTypes.DBSERVER_OBJECT_SET_FIELD_IF_EQUALS)
             else:
                 dg.addServerHeader(databaseId, self.air.ourChannel,
-                                   DBSERVER_OBJECT_SET_FIELDS_IF_EQUALS)
+                                   MsgTypes.DBSERVER_OBJECT_SET_FIELDS_IF_EQUALS)
             dg.addUint32(ctx)
         else:
             if fieldCount == 1:
                 dg.addServerHeader(databaseId, self.air.ourChannel,
-                                   DBSERVER_OBJECT_SET_FIELD)
+                                   MsgTypes.DBSERVER_OBJECT_SET_FIELD)
             else:
                 dg.addServerHeader(databaseId, self.air.ourChannel,
-                                   DBSERVER_OBJECT_SET_FIELDS)
+                                   MsgTypes.DBSERVER_OBJECT_SET_FIELDS)
         dg.addUint32(doId)
         if fieldCount != 1:
             dg.addUint16(fieldCount)
@@ -295,13 +295,15 @@ def handleUpdateObjectResp(self, di, multi):
             del self._callbacks[ctx]
 
     def handleDatagram(self, msgType, di):
-        if msgType == DBSERVER_CREATE_OBJECT_RESP:
+        if msgType == MsgTypes.DBSERVER_CREATE_OBJECT_RESP:
             self.handleCreateObjectResp(di)
-        elif msgType in (DBSERVER_OBJECT_GET_ALL_RESP,
-                         DBSERVER_OBJECT_GET_FIELDS_RESP,
-                         DBSERVER_OBJECT_GET_FIELD_RESP):
+        elif msgType in (
+            MsgTypes.DBSERVER_OBJECT_GET_ALL_RESP,
+            MsgTypes.DBSERVER_OBJECT_GET_FIELDS_RESP,
+            MsgTypes.DBSERVER_OBJECT_GET_FIELD_RESP
+        ):
             self.handleQueryObjectResp(msgType, di)
-        elif msgType == DBSERVER_OBJECT_SET_FIELD_IF_EQUALS_RESP:
+        elif msgType == MsgTypes.DBSERVER_OBJECT_SET_FIELD_IF_EQUALS_RESP:
             self.handleUpdateObjectResp(di, False)
-        elif msgType == DBSERVER_OBJECT_SET_FIELDS_IF_EQUALS_RESP:
+        elif msgType == MsgTypes.DBSERVER_OBJECT_SET_FIELDS_IF_EQUALS_RESP:
             self.handleUpdateObjectResp(di, True)