SideChannel helper messages

DevProject/ProjectSettings/ProjectSettings.asset

   xboxOneMonoLoggingLevel: 0
   xboxOneLoggingLevel: 1
   xboxOneDisableEsram: 0
+  xboxOneEnableTypeOptimization: 0
   xboxOnePresentImmediateThreshold: 0
   switchQueueCommandMemory: 1048576
   switchQueueControlMemory: 16384
   useHDRDisplay: 0
   D3DHDRBitDepth: 0
   m_ColorGamuts: 00000000
-  targetPixelDensity: 0
+  targetPixelDensity: 30
   resolutionScalingMode: 0
   androidSupportedAspectRatio: 1
   androidMaxAspectRatio: 2.1
   StripUnusedMeshComponents: 0
   VertexChannelCompressionMask: 4054
   iPhoneSdkVersion: 988
-  iOSTargetOSVersionString: 
+  iOSTargetOSVersionString: 10.0
-  tvOSTargetOSVersionString: 
+  tvOSTargetOSVersionString: 10.0
   uIPrerenderedIcon: 0
   uIRequiresPersistentWiFi: 0
   uIRequiresFullScreen: 1

Project/ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 2018.4.14f1
+m_EditorVersion: 2018.4.17f1

com.unity.ml-agents/Runtime/Agent.cs

             {
                 throw new UnityAgentsException("Call to SendInfoToBrain when Agent hasn't been initialized." +
                     "Please ensure that you are calling 'base.OnEnable()' if you have overridden OnEnable.");
-
             }
 
             if (m_Brain == null)

com.unity.ml-agents/Tests/Editor/MLAgentsEditModeTest.cs

 
         internal IPolicy GetPolicy()
         {
-            return (IPolicy) typeof(Agent).GetField("m_Brain", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this);
+            return (IPolicy)typeof(Agent).GetField("m_Brain", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this);
         }
 
         public int initializeAgentCalls;

ml-agents-envs/mlagents_envs/environment.py

 from typing import Dict, List, Optional, Any
 
 import mlagents_envs
-from mlagents_envs.side_channel.side_channel import SideChannel
+from mlagents_envs.side_channel.side_channel import SideChannel, IncomingMessage
 
 from mlagents_envs.base_env import (
     BaseEnv,
                     "sending side channel data properly.".format(channel_id)
                 )
             if channel_id in side_channels:
-                side_channels[channel_id].on_message_received(message_data)
+                incoming_message = IncomingMessage(message_data)
+                side_channels[channel_id].on_message_received(incoming_message)
             else:
                 logger.warning(
                     "Unknown side channel data received. Channel type "

ml-agents-envs/mlagents_envs/side_channel/engine_configuration_channel.py

-from mlagents_envs.side_channel.side_channel import SideChannel
+from mlagents_envs.side_channel.side_channel import (
+    SideChannel,
+    OutgoingMessage,
+    IncomingMessage,
+)
-import struct
 import uuid
 from typing import NamedTuple
 
     def __init__(self) -> None:
         super().__init__(uuid.UUID("e951342c-4f7e-11ea-b238-784f4387d1f7"))
 
-    def on_message_received(self, data: bytes) -> None:
+    def on_message_received(self, msg: IncomingMessage) -> None:
         """
         Is called by the environment to the side channel. Can be called
         multiple times per step if multiple messages are meant for that
         :param target_frame_rate: Instructs simulation to try to render at a
         specified frame rate. Default -1.
         """
-        data = bytearray()
-        data += struct.pack("<i", width)
-        data += struct.pack("<i", height)
-        data += struct.pack("<i", quality_level)
-        data += struct.pack("<f", time_scale)
-        data += struct.pack("<i", target_frame_rate)
-        super().queue_message_to_send(data)
+        msg = OutgoingMessage()
+        msg.write_int32(width)
+        msg.write_int32(height)
+        msg.write_int32(quality_level)
+        msg.write_float32(time_scale)
+        msg.write_int32(target_frame_rate)
+        super().queue_message_to_send(msg)
-        data = bytearray()
-        data += struct.pack("<iiifi", *config)
-        super().queue_message_to_send(data)
+        self.set_configuration_parameters(**config._asdict())

ml-agents-envs/mlagents_envs/side_channel/float_properties_channel.py

-from mlagents_envs.side_channel.side_channel import SideChannel
-import struct
+from mlagents_envs.side_channel.side_channel import (
+    SideChannel,
+    IncomingMessage,
+    OutgoingMessage,
+)
-from typing import Dict, Tuple, Optional, List
+from typing import Dict, Optional, List
 
 
 class FloatPropertiesChannel(SideChannel):
             channel_id = uuid.UUID(("60ccf7d0-4f7e-11ea-b238-784f4387d1f7"))
         super().__init__(channel_id)
 
-    def on_message_received(self, data: bytes) -> None:
+    def on_message_received(self, msg: IncomingMessage) -> None:
-        Note that Python should never receive an engine configuration from
-        Unity
-        k, v = self.deserialize_float_prop(data)
+        k = msg.read_string()
+        v = msg.read_float32()
         self._float_properties[k] = v
 
     def set_property(self, key: str, value: float) -> None:
         :param value: The float value of the property.
         """
         self._float_properties[key] = value
-        super().queue_message_to_send(self.serialize_float_prop(key, value))
+        msg = OutgoingMessage()
+        msg.write_string(key)
+        msg.write_float32(value)
+        super().queue_message_to_send(msg)
 
     def get_property(self, key: str) -> Optional[float]:
         """
         :return:
         """
         return dict(self._float_properties)
-
-    @staticmethod
-    def serialize_float_prop(key: str, value: float) -> bytearray:
-        result = bytearray()
-        encoded_key = key.encode("ascii")
-        result += struct.pack("<i", len(encoded_key))
-        result += encoded_key
-        result += struct.pack("<f", value)
-        return result
-
-    @staticmethod
-    def deserialize_float_prop(data: bytes) -> Tuple[str, float]:
-        offset = 0
-        encoded_key_len = struct.unpack_from("<i", data, offset)[0]
-        offset = offset + 4
-        key = data[offset : offset + encoded_key_len].decode("ascii")
-        offset = offset + encoded_key_len
-        value = struct.unpack_from("<f", data, offset)[0]
-        return key, value

ml-agents-envs/mlagents_envs/side_channel/raw_bytes_channel.py

-from mlagents_envs.side_channel.side_channel import SideChannel
+from mlagents_envs.side_channel.side_channel import (
+    SideChannel,
+    IncomingMessage,
+    OutgoingMessage,
+)
 from typing import List
 import uuid
 
         self._received_messages: List[bytes] = []
         super().__init__(channel_id)
 
-    def on_message_received(self, data: bytes) -> None:
+    def on_message_received(self, msg: IncomingMessage) -> None:
-        self._received_messages.append(data)
+        self._received_messages.append(msg.get_raw_bytes())
 
     def get_and_clear_received_messages(self) -> List[bytes]:
         """
         Queues a message to be sent by the environment at the next call to
         step.
         """
-        super().queue_message_to_send(data)
+        msg = OutgoingMessage()
+        msg.set_raw_bytes(data)
+        super().queue_message_to_send(msg)

ml-agents-envs/mlagents_envs/side_channel/side_channel.py

 from abc import ABC, abstractmethod
 from typing import List
 import uuid
+import struct
+
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class SideChannel(ABC):
         self._channel_id: uuid.UUID = channel_id
         self.message_queue: List[bytearray] = []
 
-    def queue_message_to_send(self, data: bytearray) -> None:
+    def queue_message_to_send(self, msg: "OutgoingMessage") -> None:
-        self.message_queue.append(data)
+        self.message_queue.append(msg.buffer)
-    def on_message_received(self, data: bytes) -> None:
+    def on_message_received(self, msg: "IncomingMessage") -> None:
         """
         Is called by the environment to the side channel. Can be called
         multiple times per step if multiple messages are meant for that
         processed in the environment.
         """
         return self._channel_id
+
+
+class OutgoingMessage:
+    def __init__(self):
+        self.buffer = bytearray()
+
+    def write_int32(self, i: int) -> None:
+        self.buffer += struct.pack("<i", i)
+
+    def write_float32(self, f: float) -> None:
+        self.buffer += struct.pack("<f", f)
+
+    def write_string(self, s: str) -> None:
+        encoded_key = s.encode("ascii")
+        self.write_int32(len(encoded_key))
+        self.buffer += encoded_key
+
+    def set_raw_bytes(self, buffer: bytearray) -> None:
+        if self.buffer:
+            logger.warning(
+                "Called set_raw_bytes but the message already has been written to. This will overwrite data."
+            )
+        self.buffer = bytearray(buffer)
+
+
+class IncomingMessage:
+    def __init__(self, buffer: bytes, offset: int = 0):
+        self.buffer = buffer
+        self.offset = offset
+
+    def read_int32(self) -> int:
+        val = struct.unpack_from("<i", self.buffer, self.offset)[0]
+        self.offset += 4
+        return val
+
+    def read_float32(self) -> float:
+        val = struct.unpack_from("<f", self.buffer, self.offset)[0]
+        self.offset += 4
+        return val
+
+    def read_string(self) -> str:
+        encoded_str_len = self.read_int32()
+        val = self.buffer[self.offset : self.offset + encoded_str_len].decode("ascii")
+        self.offset += encoded_str_len
+        return val
+
+    def get_raw_bytes(self) -> bytes:
+        return bytearray(self.buffer)

ml-agents-envs/mlagents_envs/tests/test_side_channel.py

-import struct
-from mlagents_envs.side_channel.side_channel import SideChannel
+from mlagents_envs.side_channel.side_channel import (
+    SideChannel,
+    IncomingMessage,
+    OutgoingMessage,
+)
 from mlagents_envs.side_channel.float_properties_channel import FloatPropertiesChannel
 from mlagents_envs.side_channel.raw_bytes_channel import RawBytesChannel
 from mlagents_envs.environment import UnityEnvironment
         self.list_int = []
         super().__init__(uuid.UUID("a85ba5c0-4f87-11ea-a517-784f4387d1f7"))
 
-    def on_message_received(self, data):
-        val = struct.unpack_from("<i", data, 0)[0]
+    def on_message_received(self, msg: IncomingMessage) -> None:
+        val = msg.read_int32()
-        data = bytearray()
-        data += struct.pack("<i", value)
-        super().queue_message_to_send(data)
+        msg = OutgoingMessage()
+        msg.write_int32(value)
+        super().queue_message_to_send(msg)
 
 
 def test_int_channel():