ai.muna.muna 0.0.44 → 0.0.46

package/Runtime/C/ValueMap.cs

@@ -9,7 +9,7 @@ namespace Muna.C {
 
     using System;
     using System.Text;
-    using static Muna;
+    using static Function;
 
     public sealed class ValueMap : IDisposable {
 

package/Runtime/Muna.cs

@@ -87,14 +87,14 @@ namespace Muna {
             this.Users = new UserService(client);
             this.Predictors = new PredictorService(client);
             this.Predictions = new PredictionService(client);
-            this.Beta = new BetaClient(client);
+            this.Beta = new BetaClient(client, this.Predictors, this.Predictions);
         }
         #endregion
 
 
         #region --Operations--
         public readonly MunaClient client;
-        public const string Version = @"0.0.44";
+        public const string Version = @"0.0.46";
         internal const string URL = @"https://api.muna.ai/v1";
         #endregion
     }

package/Runtime/Types/Parameter.cs

@@ -0,0 +1,75 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+#pragma warning disable 8618
+
+namespace Muna {
+
+    using System;
+
+    /// <summary>
+    /// Predictor parameter.
+    /// </summary>
+    [Preserve, Serializable]
+    public class Parameter {
+
+        /// <summary>
+        /// Parameter name.
+        /// </summary>
+        public string name;
+
+        /// <summary>
+        /// Parameter type.
+        /// </summary>
+        public Dtype type;
+
+        /// <summary>
+        /// Parameter description.
+        /// </summary>
+        public string? description;
+
+        /// <summary>
+        /// Parameter denotation.
+        /// </summary>
+        public string? denotation;
+
+        /// <summary>
+        /// Parameter is optional.
+        /// </summary>
+        public bool? optional;
+
+        /// <summary>
+        /// Parameter value range for numeric parameters.
+        /// </summary>
+        public float[]? range;
+
+        /// <summary>
+        /// Parameter value choices for enumeration parameters.
+        /// </summary>
+        public EnumerationMember[]? enumeration;
+
+        /// <summary>
+        /// Parameter audio sample rate.
+        /// </summary>
+        public int? sampleRate;
+    }
+
+    /// <summary>
+    /// Prediction parameter enumeration member.
+    /// </summary>
+    [Preserve, Serializable]
+    public class EnumerationMember {
+        /// <summary>
+        /// Enumeration member name.
+        /// </summary>
+        public string name;
+        /// <summary>
+        /// Enumeration member value.
+        /// This is usually a `string` or `int`.
+        /// </summary>
+        public object value;
+    }
+}

package/Runtime/Types/Parameter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 624d8c36be04548b7ae5358fd8970639
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Types/Predictor.cs

@@ -94,59 +94,6 @@ namespace Muna {
         public Parameter[] outputs;
     }
 
-    /// <summary>
-    /// Predictor parameter.
-    /// </summary>
-    [Preserve, Serializable]
-    public class Parameter {
-
-        /// <summary>
-        /// Parameter name.
-        /// </summary>
-        public string? name;
-
-        /// <summary>
-        /// Parameter type.
-        /// </summary>
-        public Dtype? type;
-
-        /// <summary>
-        /// Parameter description.
-        /// </summary>
-        public string? description;
-
-        /// <summary>
-        /// Parameter is optional.
-        /// </summary>
-        public bool? optional;
-
-        /// <summary>
-        /// Parameter value range for numeric parameters.
-        /// </summary>
-        public float[]? range;
-
-        /// <summary>
-        /// Parameter value choices for enumeration parameters.
-        /// </summary>
-        public EnumerationMember[]? enumeration;
-    }
-
-    /// <summary>
-    /// Prediction parameter enumeration member.
-    /// </summary>
-    [Preserve, Serializable]
-    public class EnumerationMember {
-        /// <summary>
-        /// Enumeration member name.
-        /// </summary>
-        public string name;
-        /// <summary>
-        /// Enumeration member value.
-        /// This is usually a `string` or `int`.
-        /// </summary>
-        public object value;
-    }
-
     /// <summary>
     /// Predictor access mode.
     /// </summary>

package/Unity/API/PredictionCacheClient.cs

@@ -109,7 +109,7 @@ namespace Muna.API {
             Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), @".fxn") :
             Path.Combine(Application.persistentDataPath, @"fxn");
         private static string ResourceCachePath => Path.Combine(CacheRoot, @"cache");
-        private static string PredictorCachePath => Path.Combine(CacheRoot, @"predictors");
+        internal static string PredictorCachePath => Path.Combine(CacheRoot, @"predictors");
 
         private async Task<PredictionResource> GetCachedResource(PredictionResource resource) {
             var path = PredictionService.GetResourcePath(resource, ResourceCachePath);

package/Unity/Converters/Color.cs

@@ -0,0 +1,46 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Convert an array field to a `Color`.
+    /// The array MUST contain three or four numbers.
+    /// </summary>
+    public sealed class ArrayToColorConverter : JsonConverter<Color> {
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Color value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.r, value.g, value.b, value.a };
+            obj.WriteTo(writer);
+        }
+
+        public override Color ReadJson(
+            JsonReader reader,
+            Type type,
+            Color existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Color(
+                r: (float)arr[0],
+                g: (float)arr[1],
+                b: (float)arr[2],
+                a: arr.Count > 3 ? (float)arr[3] : 1f
+            );
+        }
+    }
+}

package/Unity/Converters/Color.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 64482ee46d27541c0a981e4688bfeaad

package/Unity/Converters/Rect.cs

@@ -0,0 +1,230 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using System.Runtime.Serialization;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Converters;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Box format.
+    /// </summary>
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum BoxFormat : int {
+        /// <summary>
+        /// Boxes are represented via corners: x1, y1 being top left and x2, y2 being bottom right.
+        /// </summary>
+        [EnumMember(Value = @"xyxy")]
+        XYXY = 1,
+        /// <summary>
+        /// Boxes are represented via corner, width and height: x1, y2 being top left.
+        /// </summary>
+        [EnumMember(Value = @"xywh")]
+        XYWH = 2,
+        /// <summary>
+        /// Boxes are represented via center, width, and height.
+        /// </summary>
+        [EnumMember(Value = @"cxcywh")]
+        CxCyWH = 3,
+        /// <summary>
+        /// Boxes are represented via corners:
+        /// - x1, y1 being top left
+        /// - x2, y2 top right
+        /// - x3, y3 bottom right
+        /// - x4, y4 bottom left
+        /// </summary>
+        [EnumMember(Value = @"xyxyxyxy")]
+        XYXYXYXY = 4,
+    }
+
+    /// <summary>
+    /// Convert an object field to a `Rect`.
+    /// </summary>
+    public sealed class ObjectToRectConverter : JsonConverter<Rect> {
+
+        private readonly BoxFormat format;
+        private readonly string[] fieldNames;
+
+        /// <summary>
+        /// Create a converter with the provided box format.
+        /// </summary>
+        /// <param name="format">Box format to parse.</param>
+        public ObjectToRectConverter(BoxFormat format): this(
+            format,
+            GetReferenceFieldNames(format)
+        ) { }
+
+        /// <summary>
+        /// Create a converter with the provided box format and corresponding field names.
+        /// </summary>
+        /// <param name="format">Box format to parse.</param>
+        /// <param name="fieldNames">Field names that correspond to the chosen format.</param>
+        public ObjectToRectConverter(BoxFormat format, string[] fieldNames) {
+            this.format = format;
+            this.fieldNames = fieldNames;
+        }
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Rect value,
+            JsonSerializer serializer
+        ) {
+            var values = GetRectValues(value, format);
+            var obj = new JObject();
+            for (var i = 0; i < fieldNames.Length; ++i)
+                obj[fieldNames[i]] = values[i];
+            obj.WriteTo(writer);
+        }
+
+        public override Rect ReadJson(
+            JsonReader reader,
+            Type type,
+            Rect existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var obj = JObject.Load(reader);
+            return format switch {
+                BoxFormat.XYXY => Rect.MinMaxRect(
+                    xmin: GetFieldValue(obj, fieldNames[0]),
+                    ymin: GetFieldValue(obj, fieldNames[1]),
+                    xmax: GetFieldValue(obj, fieldNames[2]),
+                    ymax: GetFieldValue(obj, fieldNames[3])
+                ),
+                BoxFormat.XYWH => new Rect(
+                    x: GetFieldValue(obj, fieldNames[0]),
+                    y: GetFieldValue(obj, fieldNames[1]),
+                    width: GetFieldValue(obj, fieldNames[2]),
+                    height: GetFieldValue(obj, fieldNames[3])
+                ),
+                BoxFormat.CxCyWH => GetCenterRect(obj),
+                BoxFormat.XYXYXYXY => Rect.MinMaxRect(
+                    xmin: GetFieldValue(obj, fieldNames[0]),  // left
+                    ymin: GetFieldValue(obj, fieldNames[1]),  // top
+                    xmax: GetFieldValue(obj, fieldNames[4]),  // right
+                    ymax: GetFieldValue(obj, fieldNames[5])   // bottom
+                ),
+                _ => throw new JsonSerializationException($"Failed to read `Rect` from JSON object because of unsupported format: {format}")
+            };
+        }
+
+        private Rect GetCenterRect(JObject obj) {
+            var cx = GetFieldValue(obj, fieldNames[0]);
+            var cy = GetFieldValue(obj, fieldNames[1]);
+            var w = GetFieldValue(obj, fieldNames[2]);
+            var h = GetFieldValue(obj, fieldNames[3]);
+            var center = new Vector2(cx, cy);
+            var size = new Vector2(w, h);
+            return new Rect(center - 0.5f * size, size);
+        }
+
+        private float GetFieldValue(
+            JObject obj,
+            string name
+        ) {
+            if (!obj.TryGetValue(name, StringComparison.InvariantCulture, out var value))
+                throw new JsonSerializationException($"Missing '{name}' field for {format} box.");
+            return (float)value;
+        }
+
+        internal static float[] GetRectValues(
+            in Rect rect,
+            BoxFormat format
+        ) => format switch {
+            BoxFormat.XYXY      => new[] { rect.xMin, rect.yMin, rect.xMax, rect.yMax },
+            BoxFormat.XYWH      => new[] { rect.xMin, rect.yMin, rect.width, rect.height },
+            BoxFormat.CxCyWH    => new[] { rect.center.x, rect.center.y, rect.width, rect.height },
+            BoxFormat.XYXYXYXY  => new[] {
+                rect.xMin, rect.yMin, // top-left
+                rect.xMax, rect.yMin, // top-right
+                rect.xMax, rect.yMax, // bottom-right
+                rect.xMin, rect.yMax  // bottom-left
+            },
+            _                   => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+
+        private static string[] GetReferenceFieldNames(BoxFormat format) => format switch {
+            BoxFormat.XYXY      => new[] { @"x_min", @"y_min", @"x_max", @"y_max" },
+            BoxFormat.XYWH      => new[] { @"x", @"y", @"width", @"height" },
+            BoxFormat.CxCyWH    => new[] { @"x_center", @"y_center", @"width", @"height" },
+            BoxFormat.XYXYXYXY  => new[] { @"x1", @"y1", @"x2", @"y2", @"x3", @"y3", @"x4", @"y4" },
+            _                   => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+    }
+
+    /// <summary>
+    /// Convert an array field to a `Rect`.
+    /// The array MUST contain numbers, and have the required count depending on the box format.
+    /// </summary>
+    public sealed class ArrayToRectConverter : JsonConverter<Rect> {
+
+        private readonly BoxFormat format;
+
+        /// <summary>
+        /// Create a converter for the provided box format.
+        /// </summary>
+        /// <param name="format">Box format to parse.</param>
+        public ArrayToRectConverter(BoxFormat format) => this.format = format;
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Rect value,
+            JsonSerializer serializer
+        ) {
+            var values = ObjectToRectConverter.GetRectValues(value, format);
+            var arr = new JArray(values);
+            arr.WriteTo(writer);
+        }
+
+        public override Rect ReadJson(
+            JsonReader reader,
+            Type type,
+            Rect existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            var expected = ExpectedCount(format);
+            if (arr.Count != expected)
+                throw new JsonSerializationException($"Expected {expected} numbers for {format} box but got {arr.Count}.");
+            var data = arr.ToObject<float[]>()!;
+            return format switch {
+                BoxFormat.XYXY => Rect.MinMaxRect(
+                    xmin: data[0],
+                    ymin: data[1],
+                    xmax: data[2],
+                    ymax: data[3]
+                ),
+                BoxFormat.XYWH => new Rect(
+                    x: data[0],
+                    y: data[1],
+                    width: data[2],
+                    height: data[3]
+                ),
+                BoxFormat.CxCyWH => new Rect(
+                    x: data[0] - 0.5f * data[2],
+                    y: data[1] * 0.5f - data[3],
+                    width: data[2],
+                    height: data[3]
+                ),
+                _ => throw new JsonSerializationException($"Failed to read `Rect` from JSON array because of unsupported format: {format}")
+            };
+        }
+
+        private static int ExpectedCount(BoxFormat format) => format switch {
+            BoxFormat.XYXY      => 4,
+            BoxFormat.XYWH      => 4,
+            BoxFormat.CxCyWH    => 4,
+            BoxFormat.XYXYXYXY  => 8,
+            _                   => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+    }
+}

package/Unity/Converters/Rect.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d6cd7cc66eca9496f9387c790eec7a1a

package/Unity/Converters/Vector2.cs

@@ -0,0 +1,44 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Convert an array field to a `Vector2`.
+    /// The array MUST contain exactly two numbers.
+    /// </summary>
+    public sealed class ArrayToVector2Converter : JsonConverter<Vector2> {
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Vector2 value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.x, value.y };
+            obj.WriteTo(writer);
+        }
+
+        public override Vector2 ReadJson(
+            JsonReader reader,
+            Type type,
+            Vector2 existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Vector2(
+                x: (float)arr[0],
+                y: (float)arr[1]
+            );
+        }
+    }
+}

package/Unity/Converters/Vector2.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: aae870c26c0ca457094e039514a8a134

package/Unity/Converters/Vector3.cs

@@ -0,0 +1,45 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Convert an array field to a `Vector3`.
+    /// The array MUST contain exactly three numbers.
+    /// </summary>
+    public sealed class ArrayToVector3Converter : JsonConverter<Vector3> {
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Vector3 value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.x, value.y, value.z };
+            obj.WriteTo(writer);
+        }
+
+        public override Vector3 ReadJson(
+            JsonReader reader,
+            Type type,
+            Vector3 existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Vector3(
+                x: (float)arr[0],
+                y: (float)arr[1], 
+                z: (float)arr[2]
+            );
+        }
+    }
+}

package/Unity/Converters/Vector3.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fc6fa1f08b7e14d6595566ba018a5f18

package/Unity/Converters/Vector4.cs

@@ -0,0 +1,46 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Convert an array field to a `Vector4`.
+    /// The array MUST contain exactly four numbers.
+    /// </summary>
+    public sealed class ArrayToVector4Converter : JsonConverter<Vector4> {
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Vector4 value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.x, value.y, value.z, value.w };
+            obj.WriteTo(writer);
+        }
+
+        public override Vector4 ReadJson(
+            JsonReader reader,
+            Type type,
+            Vector4 existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Vector4(
+                x: (float)arr[0],
+                y: (float)arr[1],
+                z: (float)arr[2],
+                w: (float)arr[3]
+            );
+        }
+    }
+}

package/Unity/Converters/Vector4.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b9fecd773c668496b812e7d861c7d669

package/Unity/Converters.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 110a01a39990b4ebf95762b66a191ec2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: