ai.muna.muna 0.0.42

package/Runtime/Services/Prediction.cs

@@ -0,0 +1,247 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Services {
+
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.IO;
+    using System.Runtime.Serialization;
+    using System.Threading.Tasks;
+    using API;
+    using Configuration = C.Configuration;
+    using Value = C.Value;
+    using ValueMap = C.ValueMap;
+
+    /// <summary>
+    /// Make predictions.
+    /// </summary>
+    public sealed class PredictionService {
+
+        #region --Client API--
+        /// <summary>
+        /// Create a prediction.
+        /// </summary>
+        /// <param name="tag">Predictor tag.</param>
+        /// <param name="inputs">Input values.</param>
+        /// <param name="acceleration">Prediction acceleration.</param>
+        /// <param name="device">Prediction device. Do not set this unless you know what you are doing.</param>
+        /// <param name="clientId">Muna client identifier. Specify this to override the current client identifier.</param>
+        /// <param name="configurationId">Configuration identifier. Specify this to override the current client configuration token.</param>
+        public async Task<Prediction> Create(
+            string tag,
+            Dictionary<string, object?>? inputs = null,
+            Acceleration acceleration = default,
+            IntPtr device = default,
+            string? clientId = default,
+            string? configurationId = default
+        ) {
+            await Configuration.InitializationTask;
+            if (inputs == null)
+                return await CreateRawPrediction(tag, clientId, configurationId);
+            var predictor = await GetPredictor(tag, acceleration, device, clientId, configurationId);
+            using var inputMap = ToValueMap(inputs);
+            using var prediction = predictor.CreatePrediction(inputMap);
+            return ToPrediction(tag, prediction);
+        }
+
+        /// <summary>
+        /// Stream a prediction.
+        /// </summary>
+        /// <param name="tag">Predictor tag.</param>
+        /// <param name="inputs">Input values.</param>
+        /// <param name="acceleration">Prediction acceleration.</param>
+        /// <param name="device">Prediction device. Do not set this unless you know what you are doing.</param>
+        public async IAsyncEnumerable<Prediction> Stream(
+            string tag,
+            Dictionary<string, object?> inputs,
+            Acceleration acceleration = default,
+            IntPtr device = default
+        ) {
+            await Configuration.InitializationTask;
+            var predictor = await GetPredictor(tag, acceleration, device);
+            using var inputMap = ToValueMap(inputs);
+            using var stream = predictor.StreamPrediction(inputMap);
+            C.Prediction? prediction = null;
+            while ((prediction = stream.ReadNext()) != null)
+                using (prediction)
+                    yield return ToPrediction(tag, prediction);   
+        }
+
+        /// <summary>
+        /// Delete a predictor that is loaded in memory.
+        /// </summary>
+        /// <param name="tag">Predictor tag.</param>
+        /// <returns>Whether the predictor was successfully deleted from memory.</returns>
+        public async Task<bool> Delete(string tag) {
+            await Configuration.InitializationTask;
+            if (!cache.TryGetValue(tag, out var predictor))
+                return false;
+            predictor.Dispose();
+            cache.Remove(tag);
+            return true;
+        }
+        #endregion
+
+
+        #region --Operations--
+        private readonly MunaClient client;
+        private readonly string cachePath;
+        private readonly Dictionary<string, C.Predictor> cache = new();
+
+        internal PredictionService(MunaClient client) {
+            this.client = client;
+            this.cachePath = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+                ".fxn",
+                "cache"
+            );
+        }
+
+        private Task<Prediction> CreateRawPrediction(
+            string tag,
+            string? clientId = default,
+            string? configurationId = default
+        ) => client.Request<Prediction>(
+            method: @"POST",
+            path: $"/predictions",
+            payload: new () {
+                [@"tag"] = tag,
+                [@"clientId"] = clientId ?? Configuration.ClientId,
+                [@"configurationId"] = configurationId ?? Configuration.ConfigurationId,
+            }
+        )!;
+
+        private async Task<C.Predictor> GetPredictor(
+            string tag,
+            Acceleration acceleration = default,
+            IntPtr device = default,
+            string? clientId = default,
+            string? configurationId = default
+        ) {
+            if (cache.TryGetValue(tag, out var p))
+                return p;
+            var prediction = await CreateRawPrediction(tag, clientId, configurationId);
+            using var configuration = new Configuration() {
+                tag = prediction.tag,
+                token = prediction.configuration!,
+                acceleration = acceleration,
+                device = device
+            };
+            foreach (var resource in prediction.resources!)
+                await configuration.AddResource(
+                    resource.type,
+                    await DownloadResource(resource)
+                );
+            var predictor = new C.Predictor(configuration);
+            cache.Add(tag, predictor);
+            return predictor;
+        }
+
+        private async Task<string> DownloadResource(PredictionResource resource) {
+            var uri = new Uri(resource.url);
+            if (uri.IsFile)
+                return uri.LocalPath;
+            var path = GetResourcePath(resource, cachePath);
+            if (File.Exists(path))
+                return path;
+            Directory.CreateDirectory(Path.GetDirectoryName(path));
+            using var dataStream = await client.Download(resource.url);
+            using var fileStream = File.Create(path);
+            dataStream.CopyTo(fileStream); // CHECK // Async usage
+            return path;
+        }
+
+        internal static string GetResourcePath(PredictionResource resource, string cacheDir) {
+            var uri = new Uri(resource.url);
+            var stem = Path.GetFileName(uri.AbsolutePath);
+            var path = string.IsNullOrEmpty(resource.name) ?
+                Path.Combine(cacheDir, stem) :
+                Path.Combine(cacheDir, stem, resource.name);
+            return path;
+        }
+
+        internal static unsafe Value ToValue(object? value) => value switch {
+            Value           x => x,
+            IntPtr          x => new Value(x),
+            float           x => Value.CreateArray(x),
+            double          x => Value.CreateArray(x),
+            sbyte           x => Value.CreateArray(x),
+            short           x => Value.CreateArray(x),
+            int             x => Value.CreateArray(x),
+            long            x => Value.CreateArray(x),
+            byte            x => Value.CreateArray(x),
+            ushort          x => Value.CreateArray(x),
+            uint            x => Value.CreateArray(x),
+            ulong           x => Value.CreateArray(x),
+            bool            x => Value.CreateArray(x),
+            float[]         x => Value.CreateArray(x),
+            double[]        x => Value.CreateArray(x),
+            sbyte[]         x => Value.CreateArray(x),
+            short[]         x => Value.CreateArray(x),
+            int[]           x => Value.CreateArray(x),
+            long[]          x => Value.CreateArray(x),
+            byte[]          x => Value.CreateArray(x),
+            ushort[]        x => Value.CreateArray(x),
+            uint[]          x => Value.CreateArray(x),
+            ulong[]         x => Value.CreateArray(x),
+            bool[]          x => Value.CreateArray(x),
+            Tensor<float>   x => Value.CreateArray(x),
+            Tensor<double>  x => Value.CreateArray(x),
+            Tensor<sbyte>   x => Value.CreateArray(x),
+            Tensor<short>   x => Value.CreateArray(x),
+            Tensor<int>     x => Value.CreateArray(x),
+            Tensor<long>    x => Value.CreateArray(x),
+            Tensor<byte>    x => Value.CreateArray(x),
+            Tensor<ushort>  x => Value.CreateArray(x),
+            Tensor<uint>    x => Value.CreateArray(x),
+            Tensor<ulong>   x => Value.CreateArray(x),
+            Tensor<bool>    x => Value.CreateArray(x),
+            string          x => Value.CreateString(x),
+            Enum            x => ToValue(SerializeEnum(x)),
+            IList           x => Value.CreateList(x),
+            IDictionary     x => Value.CreateDict(x),
+            Image           x => Value.CreateImage(x),
+            Stream          x => Value.CreateBinary(x),          
+            null              => Value.CreateNull(),
+            _                 => throw new InvalidOperationException($"Cannot create a Muna value from value '{value}' of type {value.GetType()}"),
+        };
+
+        private static ValueMap ToValueMap(Dictionary<string, object?> inputs) {
+            var map = new ValueMap();
+            foreach (var pair in inputs)
+                map[pair.Key] = ToValue(pair.Value);
+            return map;
+        }
+
+        private static Prediction ToPrediction(string tag, C.Prediction prediction) {
+            var outputMap = prediction.results;
+            return new Prediction {
+                id = prediction.id,
+                tag = tag,
+                created = DateTime.UtcNow,
+                results = outputMap != null ? Enumerable.Range(0, outputMap.size)
+                    .Select(outputMap.GetKey)
+                    .Select(outputMap.GetValue)
+                    .Select(value => value.ToObject())
+                    .ToArray() : null,
+                latency = prediction.latency,
+                error = prediction.error,
+                logs = prediction.logs,
+            };
+        }
+
+        private static object SerializeEnum(Enum value) {
+            var fieldInfo = value.GetType().GetField(value.ToString());
+            var attribute = fieldInfo?.GetCustomAttributes(typeof(EnumMemberAttribute), false)?.FirstOrDefault() as EnumMemberAttribute;
+            return (attribute?.IsValueSetExplicitly ?? false) ? attribute.Value : Convert.ToInt32(value);
+        }
+        #endregion
+    }
+}

package/Runtime/Services/Prediction.cs.meta

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

package/Runtime/Services/Predictor.cs

@@ -0,0 +1,44 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Services {
+
+    using System.Threading.Tasks;
+    using API;
+
+    /// <summary>
+    /// Manage predictors.
+    /// </summary>
+    public sealed class PredictorService {
+
+        #region --Client API--
+        /// <summary>
+        /// Retrieve a predictor.
+        /// </summary>
+        /// <param name="tag">Predictor tag.</param>
+        public async Task<Predictor?> Retrieve(string tag) {
+            try {
+                return await client.Request<Predictor>(
+                    method: @"GET",
+                    path: $"/predictors/{tag}"
+                );
+            } catch (MunaAPIException ex) {
+                if (ex.status == 404)
+                    return null;
+                throw;
+            }
+        }
+        #endregion
+
+
+        #region --Operations--
+        private readonly MunaClient client;
+
+        internal PredictorService(MunaClient client) => this.client = client;
+        #endregion
+    }
+}

package/Runtime/Services/Predictor.cs.meta

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

package/Runtime/Services/User.cs

@@ -0,0 +1,43 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Services {
+
+    using System.Threading.Tasks;
+    using API;
+
+    /// <summary>
+    /// Manage users.
+    /// </summary>
+    public sealed class UserService {
+
+        #region --Client API--
+        /// <summary>
+        /// Retrieve the current user.
+        /// </summary>
+        public async Task<User?> Retrieve() {
+            try {
+                return await client.Request<User>(
+                    method: @"GET",
+                    path: @"/users"
+                );
+            } catch (MunaAPIException ex) {
+                if (ex.status == 401)
+                    return null;
+                throw;
+            }
+        }
+        #endregion
+
+
+        #region --Operations--
+        private readonly MunaClient client;
+
+        internal UserService(MunaClient client) => this.client = client;
+        #endregion
+    }
+}

package/Runtime/Services/User.cs.meta

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

package/Runtime/Services.meta

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

package/Runtime/Types/Dtype.cs

@@ -0,0 +1,118 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+namespace Muna {
+
+    using System.Runtime.Serialization;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Converters;
+
+    /// <summary>
+    /// Value type.
+    /// </summary>
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum Dtype : int { // CHECK // Must match `Function.h`
+        /// <summary>
+        /// Null or unsupported data type.
+        /// </summary>
+        [EnumMember(Value = @"null")]
+        Null = 0,
+        /// <summary>
+        /// Type is a generic half-precision float.
+        /// </summary>
+        [EnumMember(Value = @"float16")]
+        Float16 = 1,
+        /// <summary>
+        /// Type is `float` in C/C++/C#.
+        /// </summary>
+        [EnumMember(Value = @"float32")]
+        Float32 = 2,
+        /// <summary>
+        /// Type is `double` in C/C++/C#.
+        /// </summary>
+        [EnumMember(Value = @"float64")]
+        Float64 = 3,
+        /// <summary>
+        /// Type is a `int8_t` in C/C++ and `sbyte` in C#.
+        /// </summary>
+        [EnumMember(Value = @"int8")]
+        Int8 = 4,
+        /// <summary>
+        /// Type is `int16_t` in C/C++ and `short` in C#.
+        /// </summary>
+        [EnumMember(Value = @"int16")]
+        Int16 = 5,
+        /// <summary>
+        /// Type is `int32_t` in C/C++ and `int` in C#.
+        /// </summary>
+        [EnumMember(Value = @"int32")]
+        Int32 = 6,
+        /// <summary>
+        /// Type is `int64_t` in C/C++ and `long` in C#.
+        /// </summary>
+        [EnumMember(Value = @"int64")]
+        Int64 = 7,
+        /// <summary>
+        /// Type is `uint8_t` in C/C++ and `byte` in C#.
+        /// </summary>
+        [EnumMember(Value = @"uint8")]
+        Uint8 = 8,
+        /// <summary>
+        /// Type is a `uint16_t` in C/C++ and `ushort` in C#.
+        /// </summary>
+        [EnumMember(Value = @"uint16")]
+        Uint16 = 9,
+        /// <summary>
+        /// Type is a `uint32_t` in C/C++ and `uint` in C#.
+        /// </summary>
+        [EnumMember(Value = @"uint32")]
+        Uint32 = 10,
+        /// <summary>
+        /// Type is a `uint64_t` in C/C++ and `ulong` in C#.
+        /// </summary>
+        [EnumMember(Value = @"uint64")]
+        Uint64 = 11,
+        /// <summary>
+        /// Type is a `bool` in C/C++/C#.
+        /// </summary>
+        [EnumMember(Value = @"bool")]
+        Bool = 12,
+        /// <summary>
+        /// Type is `std::string` in C++ and `string` in C#.
+        /// </summary>
+        [EnumMember(Value = @"string")]
+        String = 13,
+        /// <summary>
+        /// Type is a generic list.
+        /// </summary>
+        [EnumMember(Value = @"list")]
+        List = 14,
+        /// <summary>
+        /// Type is a generic dictionary.
+        /// </summary>
+        [EnumMember(Value = @"dict")]
+        Dict = 15,
+        /// <summary>
+        /// Type is an encoded image.
+        /// </summary>
+        [EnumMember(Value = @"image")]
+        Image = 16,
+        /// <summary>
+        /// Type is a binary blob.
+        /// </summary>
+        [EnumMember(Value = @"binary")]
+        Binary = 17,
+        /// <summary>
+        /// Type is an encoded audio.
+        /// </summary>
+        [EnumMember(Value = @"audio")]
+        Audio = 18,
+        /// <summary>
+        /// Type is an encoded video.
+        /// </summary>
+        [EnumMember(Value = @"video")]
+        Video = 19,        
+    }
+}

package/Runtime/Types/Dtype.cs.meta

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

package/Runtime/Types/Image.cs

@@ -0,0 +1,93 @@
+/*
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna {
+
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// Image.
+    /// </summary>
+    [Preserve]
+    public unsafe readonly struct Image {
+
+        #region --Client API--
+        /// <summary>
+        /// Image pixel buffer.
+        /// This is always 8bpp interleaved by channel.
+        /// </summary>
+        [JsonIgnore]
+        public readonly byte[] data;
+
+        /// <summary>
+        /// Image width.
+        /// </summary>
+        public readonly int width;
+
+        /// <summary>
+        /// Image height.
+        /// </summary>
+        public readonly int height;
+
+        /// <summary>
+        /// Image channels.
+        /// </summary>
+        public readonly int channels;
+        
+        /// <summary>
+        /// Create an image.
+        /// </summary>
+        /// <param name="data">Pixel buffer. The pixel buffer format MUST be `R8`, `RGB888`, or `RGBA8888`.</param>
+        /// <param name="width">Image width.</param>
+        /// <param name="height">Image height.</param>
+        /// <param name="channels">Image channels.</param>
+        public Image(byte[] data, int width, int height, int channels) {
+            this.data = data;
+            this.nativeData = null;
+            this.width = width;
+            this.height = height;
+            this.channels = channels;
+        }
+
+        /// <summary>
+        /// Create an image from a pixel buffer.
+        /// NOTE: DO NOT use this overload unless you absolutely know what you are doing.
+        /// </summary>
+        /// <param name="data">Pixel buffer. The pixel buffer format MUST be `R8`, `RGB888`, or `RGBA8888`.</param>
+        /// <param name="width">Image width.</param>
+        /// <param name="height">Image height</param>
+        /// <param name="channels">Image channels.</param>
+        public unsafe Image(byte* data, int width, int height, int channels) { // Enables zero copy into `FXNValue`
+            this.data = null!;
+            this.nativeData = data;
+            this.width = width;
+            this.height = height;
+            this.channels = channels;
+        }
+        #endregion
+
+
+        #region --Operations--
+        private readonly byte* nativeData;
+
+        [JsonProperty(@"data"), Preserve]
+        private readonly string dataPlaceholder {
+            get {
+                var channelStr = "?";
+                switch (channels) {
+                    case 1: channelStr = "R8"; break;
+                    case 3: channelStr = "RGB888"; break;
+                    case 4: channelStr = "RGBA8888"; break;
+                }
+                return $"<{width}x{height},{channelStr},{data.Length} bytes>";
+            }
+        }
+        
+        public ref byte GetPinnableReference() => ref (nativeData == null ? ref data[0] : ref *nativeData);
+        #endregion
+    }
+}

package/Runtime/Types/Image.cs.meta

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