make StackingSensor public (#3701)

* make StackingSensor public, add some sanity checks

* actually make public, add to Public API check

* changelog

com.unity.ml-agents/CHANGELOG.md

  - The way that UnityEnvironment decides the port was changed. If no port is specified, the behavior will depend on the `file_name` parameter. If it is `None`, 5004 (the editor port) will be used; otherwise 5005 (the base environment port) will be used.
  - Fixed an issue where exceptions from environments provided a returncode of 0. (#3680)
  - Running `mlagents-learn` with the same `--run-id` twice will no longer overwrite the existing files. (#3705)
+ - `StackingSensor` was changed from `internal` visibility to `public`
 
 ## [0.15.1-preview] - 2020-03-30
 ### Bug Fixes

com.unity.ml-agents/Runtime/Sensors/StackingSensor.cs

     /// For example, 4 stacked sets of observations would be output like
     ///   |  t = now - 3  |  t = now -3  |  t = now - 2  |  t = now  |
     /// Internally, a circular buffer of arrays is used. The m_CurrentIndex represents the most recent observation.
+    ///
+    /// Currently, compressed and multidimensional observations are not supported.
-    internal class StackingSensor : ISensor
+    public class StackingSensor : ISensor
     {
         /// <summary>
         /// The wrapped sensor.
         WriteAdapter m_LocalAdapter = new WriteAdapter();
 
         /// <summary>
-        ///
+        /// Initializes the sensor.
         /// </summary>
         /// <param name="wrapped">The wrapped sensor.</param>
         /// <param name="numStackedObservations">Number of stacked observations to keep.</param>
 
             m_Name = $"StackingSensor_size{numStackedObservations}_{wrapped.GetName()}";
 
+            if (wrapped.GetCompressionType() != SensorCompressionType.None)
+            {
+                throw new UnityAgentsException("StackingSensor doesn't support compressed observations.'");
+            }
+
+            if (shape.Length != 1)
+            {
+                throw new UnityAgentsException("Only 1-D observations are supported by StackingSensor");
+            }
             m_Shape = new int[shape.Length];
 
             m_UnstackedObservationSize = wrapped.ObservationSize();
             }
         }
 
+        /// <inheritdoc/>
         public int Write(WriteAdapter adapter)
         {
             // First, call the wrapped sensor's write method. Make sure to use our own adapter, not the passed one.
             m_CurrentIndex = (m_CurrentIndex + 1) % m_NumStackedObservations;
         }
 
+        /// <inheritdoc/>
+        /// <inheritdoc/>
+        /// <inheritdoc/>
+        /// <inheritdoc/>
         public virtual SensorCompressionType GetCompressionType()
         {
             return SensorCompressionType.None;

com.unity.ml-agents/Tests/Editor/PublicAPI/PublicApiValidation.cs

             }
         }
 
+        // Simple SensorComponent that sets up a StackingSensor
+        class StackingComponent : SensorComponent
+        {
+            public SensorComponent wrappedComponent;
+            public int numStacks;
+
+            public override ISensor CreateSensor()
+            {
+                var wrappedSensor = wrappedComponent.CreateSensor();
+                return new StackingSensor(wrappedSensor, numStacks);
+            }
+
+            public override int[] GetObservationShape()
+            {
+                int[] shape = (int[]) wrappedComponent.GetObservationShape().Clone();
+                for (var i = 0; i < shape.Length; i++)
+                {
+                    shape[i] *= numStacks;
+                }
+
+                return shape;
+            }
+        }
+
 
         [Test]
         public void CheckSetupAgent()
             sensorComponent.sensorName = "ray3d";
             sensorComponent.detectableTags = new List<string> { "Player", "Respawn" };
             sensorComponent.raysPerDirection = 3;
+
+            // Make a StackingSensor that wraps the RayPerceptionSensorComponent3D
+            // This isn't necessarily practical, just to ensure that it can be done
+            var wrappingSensorComponent = gameObject.AddComponent<StackingComponent>();
+            wrappingSensorComponent.wrappedComponent = sensorComponent;
+            wrappingSensorComponent.numStacks = 3;
 
             // ISensor isn't set up yet.
             Assert.IsNull(sensorComponent.raySensor);