6.8.0

OpenAI.Playground/App.config

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.3.0" newVersion="4.0.3.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Numerics.Vectors" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.1.4.0" newVersion="4.1.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.ComponentModel.Annotations" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.2.1.0" newVersion="4.2.1.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>

OpenAI.Playground/FileExtensions.cs

@@ -0,0 +1,36 @@
+namespace OpenAI.Playground;
+
+using System.IO;
+using System.Threading.Tasks;
+
+public static class FileExtensions
+{
+    public static async Task<byte[]> ReadAllBytesAsync(string path)
+    {
+#if NET6_0_OR_GREATER
+        return await File.ReadAllBytesAsync(path);
+#else
+        byte[] buffer;
+        using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true))
+        {
+            buffer = new byte[stream.Length];
+            await stream.ReadAsync(buffer, 0, (int)stream.Length);
+        }
+        return buffer;
+#endif
+    }
+
+    public static async Task<string> ReadAllTextAsync(string path)
+    {
+#if NET6_0_OR_GREATER
+        return await File.ReadAllTextAsync(path);
+#else
+        string text;
+        using (var reader = new StreamReader(path))
+        {
+            text = await reader.ReadToEndAsync();
+        }
+        return text;
+#endif
+    }
+}

OpenAI.Playground/OpenAI.Playground.csproj

@@ -2,7 +2,9 @@
 
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
-		<TargetFramework>net6.0</TargetFramework>
+		<TargetFrameworks>net6.0;netstandard2.0</TargetFrameworks>
+		<CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+		<RestoreProjectStyle>PackageReference</RestoreProjectStyle>
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
 		<UserSecretsId>c7a3a51e-4319-4038-b522-9ed24fd5ef66</UserSecretsId>
@@ -19,15 +21,25 @@
 		</Content>
 	</ItemGroup>
 
-	<ItemGroup>
+	<ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
 		<PackageReference Include="LaserCatEyes.HttpClientListener" Version="6.0.0" />
+	</ItemGroup>
+
+	<ItemGroup>
 		<PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.1" />
 		<PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="6.0.0" />
 		<PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="6.0.0" />
 		<PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="6.0.1" />
 		<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.1" />
 		<PackageReference Include="Microsoft.Extensions.Options" Version="6.0.0" />
 		<PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="6.0.0" />
+		<PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+	</ItemGroup>
+
+	<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+		<PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="6.0.0" />
+		<PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
+		<PackageReference Include="System.Net.Http.Json" Version="6.0.0" />
 	</ItemGroup>
 
 	<ItemGroup>

OpenAI.Playground/Program.cs

@@ -1,4 +1,6 @@
-using LaserCatEyes.HttpClientListener;
+#if NET6_0_OR_GREATER
+using LaserCatEyes.HttpClientListener;
+#endif
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using OpenAI.GPT3.Extensions;
@@ -13,10 +15,12 @@
 var serviceCollection = new ServiceCollection();
 serviceCollection.AddScoped(_ => configuration);
 
+#if NET6_0_OR_GREATER
 // Laser cat eyes is a tool that shows your requests and responses between OpenAI server and your client.
 // Get your app key from https://lasercateyes.com for FREE and put it under ApiSettings.json or secrets.json.
 // It is in Beta version, if you don't want to use it just comment out below line.
 serviceCollection.AddLaserCatEyesHttpClientListener();
+#endif
 
 serviceCollection.AddOpenAIService();
 //// DeploymentId and ResourceName are only for Azure OpenAI. If you want to use Azure OpenAI services you have to set Provider type To Azure.

OpenAI.Playground/TestHelpers/AudioTestHelper.cs

@@ -15,7 +15,7 @@ public static async Task RunSimpleAudioCreateTranscriptionTest(IOpenAIService sd
             ConsoleExtensions.WriteLine("Audio Create Transcription Test:", ConsoleColor.DarkCyan);
 
             const string fileName = "micro-machines.mp3";
-            var sampleFile = await File.ReadAllBytesAsync($"SampleData/{fileName}");
+            var sampleFile = await FileExtensions.ReadAllBytesAsync($"SampleData/{fileName}");
 
             ConsoleExtensions.WriteLine($"Uploading file {fileName}", ConsoleColor.DarkCyan);
             var audioResult = await sdk.Audio.CreateTranscription(new AudioCreateTranscriptionRequest
@@ -57,7 +57,7 @@ public static async Task RunSimpleAudioCreateTranslationTest(IOpenAIService sdk)
             ConsoleExtensions.WriteLine("Audio Create Translation Test:", ConsoleColor.DarkCyan);
 
             const string fileName = "multilingual.mp3";
-            var sampleFile = await File.ReadAllBytesAsync($"SampleData/{fileName}");
+            var sampleFile = await FileExtensions.ReadAllBytesAsync($"SampleData/{fileName}");
 
             ConsoleExtensions.WriteLine($"Uploading file {fileName}", ConsoleColor.DarkCyan);
             var audioResult = await sdk.Audio.CreateTranslation(new AudioCreateTranscriptionRequest

OpenAI.Playground/TestHelpers/FileTestHelper.cs

@@ -14,7 +14,7 @@ public static async Task RunSimpleFileTest(IOpenAIService sdk)
         {
             const string fileName = "SentimentAnalysisSample.jsonl";
 
-            var sampleFile = await File.ReadAllBytesAsync($"SampleData/{fileName}");
+            var sampleFile = await FileExtensions.ReadAllBytesAsync($"SampleData/{fileName}");
             var sampleFileAsString = Encoding.UTF8.GetString(sampleFile);
 
             ConsoleExtensions.WriteLine($"Uploading file {fileName}", ConsoleColor.DarkCyan);

OpenAI.Playground/TestHelpers/FineTuningTestHelper.cs

@@ -14,7 +14,7 @@ public static async Task RunCaseStudyIsTheModelMakingUntrueStatements(IOpenAISer
         try
         {
             const string fileName = "FineTuningSample1.jsonl";
-            var sampleFile = await File.ReadAllBytesAsync($"SampleData/{fileName}");
+            var sampleFile = await FileExtensions.ReadAllBytesAsync($"SampleData/{fileName}");
 
             ConsoleExtensions.WriteLine($"Uploading file {fileName}", ConsoleColor.DarkCyan);
             var uploadFilesResponse = await sdk.Files.FileUpload(UploadFilePurposes.UploadFilePurpose.FineTune, sampleFile, fileName);

OpenAI.Playground/TestHelpers/ImageTestHelper.cs

@@ -52,8 +52,8 @@ public static async Task RunSimpleCreateImageEditTest(IOpenAIService sdk)
 
         // Images should be in png format with ARGB. I got help from this website to generate sample mask
         // https://www.online-image-editor.com/
-        var maskFile = await File.ReadAllBytesAsync($"SampleData/{maskFileName}");
-        var originalFile = await File.ReadAllBytesAsync($"SampleData/{originalFileName}");
+        var maskFile = await FileExtensions.ReadAllBytesAsync($"SampleData/{maskFileName}");
+        var originalFile = await FileExtensions.ReadAllBytesAsync($"SampleData/{originalFileName}");
 
         try
         {
@@ -98,7 +98,7 @@ public static async Task RunSimpleCreateImageVariationTest(IOpenAIService sdk)
         ConsoleExtensions.WriteLine("Image Variation Create Testing is starting:", ConsoleColor.Cyan);
         const string originalFileName = "image_edit_original.png";
 
-        var originalFile = await File.ReadAllBytesAsync($"SampleData/{originalFileName}");
+        var originalFile = await FileExtensions.ReadAllBytesAsync($"SampleData/{originalFileName}");
 
         try
         {

OpenAI.Playground/TestHelpers/TokenizerTestHelper.cs

@@ -13,7 +13,7 @@ public static async Task RunTokenizerTest()
             ConsoleExtensions.WriteLine("Tokenizer Test:", ConsoleColor.DarkCyan);
             const string fileName = "TokenizerSample.txt";
 
-            var input = await File.ReadAllTextAsync($"SampleData/{fileName}");
+            var input = await FileExtensions.ReadAllTextAsync($"SampleData/{fileName}");
             var encodedList = TokenizerGpt3.Encode(input);
             if (encodedList.Count == 68)
             {
@@ -41,7 +41,7 @@ public static async Task RunTokenizerTestCrClean()
             ConsoleExtensions.WriteLine("Tokenizer Test:", ConsoleColor.DarkCyan);
             const string fileName = "TokenizerSample.txt";
 
-            var input = await File.ReadAllTextAsync($"SampleData/{fileName}");
+            var input = await FileExtensions.ReadAllTextAsync($"SampleData/{fileName}");
             var encodedList = TokenizerGpt3.Encode(input,true);
             if (encodedList.Count == 64)
             {

OpenAI.SDK/Extensions/AsyncDisposableStream.cs

@@ -0,0 +1,182 @@
+#if NETSTANDARD2_0
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace OpenAI.GPT3.Extensions
+{
+    public class AsyncDisposableStream : Stream, IAsyncDisposable
+    {
+        private readonly Stream _innerStream;
+
+        public AsyncDisposableStream(Stream stream)
+        {
+            _innerStream = stream;
+        }
+
+        public new Task CopyToAsync(Stream destination)
+        {
+            return _innerStream.CopyToAsync(destination);
+        }
+
+        public new Task CopyToAsync(Stream destination, int bufferSize)
+        {
+            return _innerStream.CopyToAsync(destination, bufferSize);
+        }
+
+        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
+        {
+            return _innerStream.CopyToAsync(destination, bufferSize, cancellationToken);
+        }
+
+        public new void CopyTo(Stream destination)
+        {
+            _innerStream.CopyTo(destination);
+        }
+
+        public new void CopyTo(Stream destination, int bufferSize)
+        {
+            _innerStream.CopyTo(destination, bufferSize);
+        }
+
+        public override void Close()
+        {
+            _innerStream.Close();
+        }
+
+        public new void Dispose()
+        {
+            _innerStream.Dispose();
+        }
+
+        public override void Flush()
+        {
+            _innerStream.Flush();
+        }
+
+        public new Task FlushAsync()
+        {
+            return _innerStream.FlushAsync();
+        }
+
+        public override Task FlushAsync(CancellationToken cancellationToken)
+        {
+            return _innerStream.FlushAsync(cancellationToken);
+        }
+
+        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+        {
+            return _innerStream.BeginRead(buffer, offset, count, callback, state);
+        }
+
+        public override int EndRead(IAsyncResult asyncResult)
+        {
+            return _innerStream.EndRead(asyncResult);
+        }
+
+        public new Task<int> ReadAsync(byte[] buffer, int offset, int count)
+        {
+            return _innerStream.ReadAsync(buffer, offset, count);
+        }
+
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return _innerStream.ReadAsync(buffer, offset, count, cancellationToken);
+        }
+
+        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+        {
+            return _innerStream.BeginWrite(buffer, offset, count, callback, state);
+        }
+
+        public override void EndWrite(IAsyncResult asyncResult)
+        {
+            _innerStream.EndWrite(asyncResult);
+        }
+
+        public new Task WriteAsync(byte[] buffer, int offset, int count)
+        {
+            return _innerStream.WriteAsync(buffer, offset, count);
+        }
+
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return _innerStream.WriteAsync(buffer, offset, count, cancellationToken);
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            return _innerStream.Seek(offset, origin);
+        }
+
+        public override void SetLength(long value)
+        {
+            _innerStream.SetLength(value);
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return _innerStream.Read(buffer, offset, count);
+        }
+
+        public override int ReadByte()
+        {
+            return _innerStream.ReadByte();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            _innerStream.Write(buffer, offset, count);
+        }
+
+        public override void WriteByte(byte value)
+        {
+            _innerStream.WriteByte(value);
+        }
+
+        public override bool CanRead => _innerStream.CanRead;
+
+        public override bool CanSeek => _innerStream.CanSeek;
+
+        public override bool CanTimeout => _innerStream.CanTimeout;
+
+        public override bool CanWrite => _innerStream.CanWrite;
+
+        public override long Length => _innerStream.Length;
+
+        public override long Position
+        {
+            get => _innerStream.Position;
+            set => _innerStream.Position = value;
+        }
+
+        public override int ReadTimeout
+        {
+            get => _innerStream.ReadTimeout;
+            set => _innerStream.ReadTimeout = value;
+        }
+
+        public override int WriteTimeout
+        {
+            get => _innerStream.WriteTimeout;
+            set => _innerStream.WriteTimeout = value;
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            if (_innerStream != null)
+            {
+                if (_innerStream is IAsyncDisposable asyncDisposable)
+                {
+                    await asyncDisposable.DisposeAsync().ConfigureAwait(false);
+                }
+                else
+                {
+                    await Task.Run(() => _innerStream.Dispose()).ConfigureAwait(false);
+                }
+            }
+        }
+    }
+}
+#endif