ai.muna.muna 0.0.42

package/Unity/API/UnityClient.cs

@@ -0,0 +1,147 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.API {
+
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Text;
+    using System.Threading.Tasks;
+    using UnityEngine.Networking;
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// Muna API client for Unity Engine.
+    /// This uses Unity APIs for performing web requests.
+    /// </summary>
+    internal class UnityClient : MunaClient {
+
+        #region --Client API--
+        /// <summary>
+        /// Create the client.
+        /// </summary>
+        /// <param name="url">Muna API URL.</param>
+        /// <param name="accessKey">Muna access key.</param>
+        /// <param name="cache">Prediction cache.</param>
+        public UnityClient(
+            string url,
+            string? accessKey
+        ) : base(url.TrimEnd('/'), accessKey) { }
+
+        /// <summary>
+        /// Make a request to a REST endpoint.
+        /// </summary>
+        /// <typeparam name="T">Deserialized response type.</typeparam>
+        /// <param name="method">HTTP request method.</param>
+        /// <param name="path">Endpoint path.</param>
+        /// <param name="payload">Request body.</param>
+        /// <param name="headers">Request headers.</param>
+        /// <returns>Deserialized response.</returns>
+        public override async Task<T?> Request<T>(
+            string method,
+            string path,
+            Dictionary<string, object?>? payload = default,
+            Dictionary<string, string>? headers = default
+        ) where T : class {
+            // Create client
+            using var client = new UnityWebRequest($"{this.url}{path}", method) {
+                downloadHandler = new DownloadHandlerBuffer(),
+                disposeDownloadHandlerOnDispose = true,
+                disposeUploadHandlerOnDispose = true,
+                timeout = 20,
+            };
+            // Add headers
+            if (!string.IsNullOrEmpty(accessKey))
+                client.SetRequestHeader(@"Authorization", $"Bearer {accessKey}");
+            if (headers != null)
+                foreach (var header in headers)
+                    client.SetRequestHeader(header.Key, header.Value);
+            // Add payload
+            if (payload != null) {
+                var serializationSettings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore };
+                var payloadStr = JsonConvert.SerializeObject(payload, serializationSettings);
+                client.SetRequestHeader(@"Content-Type",  @"application/json");
+                client.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(payloadStr));
+            }
+            // Request
+            client.SendWebRequest();
+            while (!client.isDone)
+                await Task.Yield();
+            // Check error
+            var responseStr = client.downloadHandler.text;
+            if (client.responseCode == 0)
+                throw new MunaAPIException(
+                    @"Failed to get response from server. Check that you have an internet connection.",
+                    (int)client.responseCode
+                );
+            if (client.responseCode >= 400) {
+                var errorPayload = JsonConvert.DeserializeObject<ErrorResponse>(responseStr);
+                var error = errorPayload?.errors?[0]?.message ?? @"An unknown error occurred";
+                throw new MunaAPIException(error, (int)client.responseCode);
+            }
+            // Return
+            return JsonConvert.DeserializeObject<T>(responseStr)!;
+        }
+
+        /// <summary>
+        /// Download a file.
+        /// </summary>
+        /// <param name="url">URL</param>
+        public override async Task<Stream> Download(string url) {
+            using var request = UnityWebRequest.Get(url);
+            request.timeout = 20;
+            request.SendWebRequest();
+            while (!request.isDone)
+                await Task.Yield();
+            if (request.result != UnityWebRequest.Result.Success)
+                throw new InvalidOperationException(request.error);
+            var data = request.downloadHandler.data;
+            var stream = new MemoryStream(data, 0, data.Length, false, false);
+            return stream;
+        }
+
+        /// <summary>
+        /// Upload a data stream.
+        /// </summary>
+        /// <param name="stream">Data stream.</param>
+        /// <param name="url">Upload URL.</param>
+        /// <param name="mime">MIME type.</param>
+        public override async Task Upload(
+            Stream stream,
+            string url,
+            string? mime = null
+        ) {
+            using var client = new UnityWebRequest(url, UnityWebRequest.kHttpVerbPUT) {
+                uploadHandler = new UploadHandlerRaw(ToArray(stream)),
+                downloadHandler = new DownloadHandlerBuffer(),
+                disposeDownloadHandlerOnDispose = true,
+                disposeUploadHandlerOnDispose = true,
+                timeout = 20,
+            };
+            client.SetRequestHeader(@"Content-Type", mime ?? @"application/octet-stream");
+            client.SendWebRequest();
+            while (!client.isDone)
+                await Task.Yield();
+            if (client.error != null)
+                throw new InvalidOperationException($"Failed to upload stream with error: {client.error}");
+        }
+        #endregion
+
+
+        #region --Operations--
+
+        private static byte[] ToArray(Stream stream) {
+            if (stream is MemoryStream memoryStream)
+                return memoryStream.ToArray();
+            using var dstStream = new MemoryStream();
+            stream.CopyTo(dstStream);
+            return dstStream.ToArray();
+        }
+        #endregion
+    }
+}

package/Unity/API/UnityClient.cs.meta

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

package/Unity/API.meta

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

package/Unity/Internal/MunaSettings.cs

@@ -0,0 +1,59 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Internal {
+
+    using System.Collections.Generic;
+    using UnityEngine;
+
+    /// <summary>
+    /// Muna settings for the current Unity project.
+    /// </summary>
+    [DefaultExecutionOrder(int.MinValue)]
+    internal sealed class MunaSettings : ScriptableObject {
+
+        #region --Client API--
+        /// <summary>
+        /// Project-wide access key.
+        /// </summary>
+        [field: SerializeField, HideInInspector]
+        public string accessKey { get; private set; } = string.Empty;
+
+        /// <summary>
+        /// Predictor cache.
+        /// </summary>
+        [field: SerializeField, HideInInspector]
+        public List<CachedPrediction> cache { get; internal set; } = new();
+
+        /// <summary>
+        /// Settings instance for this project.
+        /// </summary>
+        #pragma warning disable 8618
+        public static MunaSettings Instance;
+        #pragma warning restore 8618
+
+        /// <summary>
+        /// Create Muna settings.
+        /// </summary>
+        /// <param name="accessKey">Muna access key.</param>
+        public static MunaSettings Create(string accessKey) {
+            var settings = CreateInstance<MunaSettings>();
+            settings.accessKey = accessKey;
+            return settings;
+        }
+        #endregion
+
+
+        #region --Operations--
+
+        private void Awake() {
+            if (!Application.isEditor)
+                Instance = this;
+        }
+        #endregion
+    }
+}

package/Unity/Internal/MunaSettings.cs.meta

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

package/Unity/Internal.meta

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

package/Unity/Muna.Unity.asmdef

@@ -0,0 +1,29 @@
+{
+    "name": "Muna.Unity",
+    "rootNamespace": "",
+    "references": [
+        "Muna.Runtime"
+    ],
+    "includePlatforms": [
+        "Android",
+        "Editor",
+        "EmbeddedLinux",
+        "iOS",
+        "LinuxStandalone64",
+        "CloudRendering",
+        "macOSStandalone",
+        "VisionOS",
+        "WebGL",
+        "WindowsStandalone64"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "Newtonsoft.Json.dll"
+    ],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Unity/Muna.Unity.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7a346b965c6044600831104d454f53e8
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Unity/MunaUnity.cs

@@ -0,0 +1,130 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyCompany(@"NatML Inc")]
+[assembly: AssemblyTitle(@"Muna.Unity")]
+[assembly: AssemblyVersion(Muna.Muna.Version)]
+[assembly: AssemblyCopyright(@"Copyright © 2025 NatML Inc. All Rights Reserved.")]
+[assembly: InternalsVisibleTo(@"Muna.Editor")]
+[assembly: InternalsVisibleTo(@"Muna.Tests.Editor")]
+[assembly: InternalsVisibleTo(@"Muna.Tests.Runtime")]
+
+namespace Muna {
+
+    using System;
+    using System.Collections.Generic;
+    using UnityEngine;
+    using Unity.Collections.LowLevel.Unsafe;
+    using API;
+    using Internal;
+
+    /// <summary>
+    /// Utilities for working with Unity.
+    /// </summary>
+    public static class MunaUnity {
+
+        #region --Client API--
+        /// <summary>
+        /// Create a Muna client for Unity.
+        /// </summary>
+        /// <param name="accessKey">Muna access key. This defaults to your access key in Project Settings.</param>
+        /// <param name="url">Muna API URL.</param>
+        /// <param name="cachePath">Predictor cache path.</param>
+        /// <returns>Muna client.</returns>
+        public static Muna Create(
+            string? accessKey = null,
+            string? url = null
+        ) {
+            var settings = MunaSettings.Instance!;
+            var client = new PredictionCacheClient(
+                url ?? Muna.URL,
+                accessKey: accessKey ?? settings?.accessKey,
+                cache: settings?.cache
+            );
+            return new Muna(client);
+        }
+
+        /// <summary>
+        /// Convert a texture to an image.
+        /// NOTE: The texture format must be `R8`, `Alpha8`, `RGB24`, or `RGBA32`.
+        /// </summary>
+        /// <param name="texture">Input texture.</param>
+        /// <param name="pixelBuffer">Pixel buffer to store image data. Use this to prevent allocations.</param>
+        /// <returns>Image.</returns>
+        public static unsafe Image ToImage(
+            this Texture2D texture,
+            byte[]? pixelBuffer = null
+        ) {
+            if (texture == null)
+                throw new ArgumentNullException(nameof(texture));
+            if (!texture.isReadable)
+                throw new InvalidOperationException(@"Texture cannot be converted to a Muna image because it is not readable");
+            var FormatChannelMap = new Dictionary<TextureFormat, int> {
+                [TextureFormat.R8] = 1,
+                [TextureFormat.Alpha8] = 1,
+                [TextureFormat.RGB24] = 3,
+                [TextureFormat.RGBA32] = 4,
+            };
+            if (!FormatChannelMap.TryGetValue(texture.format, out var channels))
+                throw new InvalidOperationException($"Texture cannot be converted to a Muna image because it has unsupported format: {texture.format}");
+            var rowStride = texture.width * channels;
+            var bufferSize = rowStride * texture.height;
+            pixelBuffer ??= new byte[bufferSize];
+            if (pixelBuffer.Length < bufferSize)
+                throw new InvalidOperationException($"Texture cannot be converted to a Muna image because pixel buffer length was expected to be greater than or equal to {bufferSize} but got {pixelBuffer.Length}");
+            fixed (void* dst = pixelBuffer)
+                UnsafeUtility.MemCpyStride(
+                    dst,
+                    rowStride,
+                    (byte*)texture.GetRawTextureData<byte>().GetUnsafePtr() + (rowStride * (texture.height - 1)),
+                    -rowStride,
+                    rowStride,
+                    texture.height
+                );
+            var image = new Image(pixelBuffer, texture.width, texture.height, channels);
+            return image;
+        }
+
+        /// <summary>
+        /// Convert an image to a texture.
+        /// </summary>
+        /// <param name="value">Image.</param>
+        /// <param name="texture">Optional destination texture.</param>
+        /// <returns>Texture.</returns>
+        public static unsafe Texture2D ToTexture(
+            this Image image,
+            Texture2D? texture = null
+        ) {
+            var ChannelFormatMap = new Dictionary<int, TextureFormat> {
+                [1] = TextureFormat.Alpha8,
+                [3] = TextureFormat.RGB24,
+                [4] = TextureFormat.RGBA32
+            };
+            if (!ChannelFormatMap.TryGetValue(image.channels, out var format))
+                throw new InvalidOperationException($"Image cannot be converted to a Texture2D because it has unsupported channel count: {image.channels}");
+            texture = texture != null ? texture : new Texture2D(image.width, image.height, format, false);
+            if (texture.width != image.width || texture.height != image.height || texture.format != format)
+                texture.Reinitialize(image.width, image.height, format, false);
+            var rowStride = image.width * image.channels;
+            fixed (byte* srcData = image)
+                UnsafeUtility.MemCpyStride(
+                    texture.GetRawTextureData<byte>().GetUnsafePtr(),
+                    rowStride,
+                    srcData + (rowStride * (image.height - 1)),
+                    -rowStride,
+                    rowStride,
+                    image.height
+                );
+            texture.Apply();
+            return texture;
+        }
+        #endregion
+    }
+}

package/Unity/MunaUnity.cs.meta

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

package/Unity/Types/CachedPrediction.cs

@@ -0,0 +1,36 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna {
+
+    using System;
+
+    /// <summary>
+    /// Cached prediction.
+    /// </summary>
+    [Preserve, Serializable]
+    internal class CachedPrediction : Prediction {
+
+        public string? clientId;
+
+        [Preserve]
+        public CachedPrediction() { }
+
+        public CachedPrediction(Prediction prediction, string clientId) {
+            this.id = prediction.id;
+            this.tag = prediction.tag;
+            this.created = prediction.created;
+            this.results = prediction.results;
+            this.latency = prediction.latency;
+            this.error = prediction.error;
+            this.logs = prediction.logs;
+            this.resources = prediction.resources;
+            this.configuration = prediction.configuration;
+            this.clientId = clientId;
+        }
+    }
+}

package/Unity/Types/CachedPrediction.cs.meta

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

package/Unity/Types.meta

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

package/Unity.meta

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

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "ai.muna.muna",
+    "version": "0.0.42",
+    "displayName": "Muna",
+    "description": "Run AI inference in Unity Engine.",
+    "unity": "2022.3",
+    "dependencies": {
+        "com.unity.nuget.newtonsoft-json": "3.2.1"
+    },
+    "keywords": [
+        "fxn",
+        "natml",
+        "machine learning",
+        "ml",
+        "aritificial intelligence",
+        "ai",
+        "computer vision",
+        "opencv",
+        "android",
+        "ios",
+        "macos",
+        "windows",
+        "coreml",
+        "nnapi",
+        "directml",
+        "tensorflow",
+        "pytorch",
+        "torch",
+        "llm"
+    ],
+    "author": {
+        "name": "NatML Inc",
+        "email": "hi@muna.ai",
+        "url": "https://github.com/muna-ai"
+    },
+    "license": "Apache-2.0",
+    "repository": "github:muna-ai/muna-unity"
+}

package/package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: bc5c081aa390c4293a55ef9ba8b3e9b6
+PackageManifestImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: