fix: add csharp code to log results for pii redaction

Author: a-dinoto

fern/pages/03-audio-intelligence/pii-redaction.mdx

@@ -210,6 +210,129 @@ while (true) {
     await new Promise((resolve) => setTimeout(resolve, 3000))
   }
 }
+```
+
+  </Tab>
+  <Tab language="csharp" title="C#">
+  
+  Enable Topic Detection by setting `redact_pii` to `true` in the JSON payload.
+
+Set `redact_pii_policies` to specify the information you want to redact. For the full list of policies, see [PII policies](#pii-policies).
+
+Set `redact_pii_sub` to specify the replacement for redacted information.
+
+<Info>
+Most of these libraries are included by default, but on .NET Framework and Mono you need to reference the System.Net.Http library and install the [System.Net.Http.Json NuGet package](https://www.nuget.org/packages/System.Net.Http.Json).
+</Info>
+
+```csharp {53-55}
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Net.Http.Json;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using System.Text.Json.Serialization;
+using System.Collections.Generic;
+
+class Program
+{
+    static async Task Main(string[] args)
+    {
+        string baseUrl = "https://api.assemblyai.com";
+        
+        using (var httpClient = new HttpClient())
+        {
+            httpClient.DefaultRequestHeaders.Authorization = 
+                new AuthenticationHeaderValue("<YOUR_API_KEY>");
+
+            string uploadUrl = await UploadFileAsync("./local_file.mp3", httpClient, baseUrl);
+            
+            var transcript = await CreateTranscriptWithPiiRedactionAsync(uploadUrl, httpClient, baseUrl);
+            
+            Console.WriteLine($"Transcript ID: {transcript.Id}");
+            transcript = await WaitForTranscriptToProcessAndGetRedactedText(transcript, httpClient, baseUrl);
+        }
+    }
+
+    static async Task<string> UploadFileAsync(string filePath, HttpClient httpClient, string baseUrl)
+    {
+        using (var fileStream = File.OpenRead(filePath))
+        using (var fileContent = new StreamContent(fileStream))
+        {
+            fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+
+            using (var response = await httpClient.PostAsync($"{baseUrl}/v2/upload", fileContent))
+            {
+                response.EnsureSuccessStatusCode();
+                var jsonDoc = await response.Content.ReadFromJsonAsync<JsonDocument>();
+                return jsonDoc.RootElement.GetProperty("upload_url").GetString();
+            }
+        }
+    }
+
+    static async Task<Transcript> CreateTranscriptWithPiiRedactionAsync(string audioUrl, HttpClient httpClient, string baseUrl)
+    {
+        var data = new 
+        { 
+            audio_url = audioUrl,
+            redact_pii = true,
+            redact_pii_policies = new[] { "person_name", "organization", "occupation" },
+            redact_pii_sub = "hash"
+        };
+        
+        var content = new StringContent(JsonSerializer.Serialize(data), Encoding.UTF8, "application/json");
+
+        using (var response = await httpClient.PostAsync($"{baseUrl}/v2/transcript", content))
+        {
+            response.EnsureSuccessStatusCode();
+            return await response.Content.ReadFromJsonAsync<Transcript>();
+        }
+    }
+
+    static async Task<Transcript> WaitForTranscriptToProcessAndGetRedactedText(Transcript transcript, HttpClient httpClient, string baseUrl)
+    {
+        string pollingEndpoint = $"{baseUrl}/v2/transcript/{transcript.Id}";
+
+        while (true)
+        {
+            var pollingResponse = await httpClient.GetAsync(pollingEndpoint);
+            transcript = await pollingResponse.Content.ReadFromJsonAsync<Transcript>();
+            
+            switch (transcript.Status)
+            {
+                case "completed":
+                    // Print the redacted transcript text
+                    Console.WriteLine(transcript.Text);
+                    return transcript;
+                    
+                case "error":
+                    throw new Exception($"Transcription failed: {transcript.Error}");
+                    
+                default:
+                    await Task.Delay(TimeSpan.FromSeconds(3));
+                    break;
+            }
+        }
+    }
+
+    public class Transcript
+    {
+        [JsonPropertyName("id")]
+        public string Id { get; set; }
+        
+        [JsonPropertyName("status")]
+        public string Status { get; set; }
+        
+        [JsonPropertyName("text")]
+        public string Text { get; set; }
+        
+        [JsonPropertyName("error")]
+        public string Error { get; set; }
+    }
+}
 ```
 
   </Tab>
@@ -519,6 +642,92 @@ while (true) {
     await new Promise((resolve) => setTimeout(resolve, 3000))
   }
 }
+```
+
+  </Tab>
+  <Tab value="csharp" title="C#" default>
+    To create a redacted version of the audio file, set `redact_pii_audio` to `true` on the JSON payload.
+    Set `redact_pii_audio_quality` to specify the quality of the redacted audio file.
+
+Use the transcript ID to poll the [GET redacted audio endpoint](https://www.assemblyai.com/docs/api-reference/transcripts/get-redacted-audio) every few seconds to check the status of the redacted audio. Once the status is `redacted_audio_ready`, you can retrieve the audio URL from the API response.
+```csharp {7-8,29,35-63,67-77}
+var data = new 
+{ 
+    audio_url = audioUrl,
+    redact_pii = true,
+    redact_pii_policies = new[] { "person_name", "organization", "occupation" },
+    redact_pii_sub = "hash",
+    redact_pii_audio = true,
+    redact_pii_audio_quality = "wav" // Optional. Defaults to "mp3"
+};
+
+// ...
+  static async Task Main(string[] args)
+  {
+      string baseUrl = "https://api.assemblyai.com";
+      
+      using (var httpClient = new HttpClient())
+      {
+          httpClient.DefaultRequestHeaders.Authorization = 
+              new AuthenticationHeaderValue("<YOUR_API_KEY>");
+
+          string uploadUrl = await UploadFileAsync("./local_file.mp3", httpClient, baseUrl);
+          
+          var transcript = await CreateTranscriptWithPiiRedactionAsync(uploadUrl, httpClient, baseUrl);
+          
+          Console.WriteLine($"Transcript ID: {transcript.Id}");
+          transcript = await WaitForTranscriptToProcessAndGetRedactedText(transcript, httpClient, baseUrl);
+          
+          // Wait for the redacted audio
+          string redactedAudioUrl = await WaitForRedactedAudioAsync(transcript.Id, httpClient, baseUrl);
+      }
+  }
+
+// ...
+
+static async Task<string> WaitForRedactedAudioAsync(string transcriptId, HttpClient httpClient, string baseUrl)
+{
+    string redactedAudioPollingEndpoint = $"{baseUrl}/v2/transcript/{transcriptId}/redacted-audio";
+
+    while (true)
+    {
+        var pollingResponse = await httpClient.GetAsync(redactedAudioPollingEndpoint);
+        var responseContent = await pollingResponse.Content.ReadAsStringAsync();
+
+        var redactedAudioResult = JsonSerializer.Deserialize<RedactedAudioResult>(
+            responseContent, 
+            new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
+        );
+
+        if (redactedAudioResult.Status == "redacted_audio_ready")
+        {
+            Console.WriteLine(redactedAudioResult.RedactedAudioUrl);
+            return redactedAudioResult.RedactedAudioUrl;
+        }
+        else if (redactedAudioResult.Status == "error")
+        {
+            throw new Exception($"Redacted audio failed: {redactedAudioResult.Error}");
+        }
+        else
+        {
+            await Task.Delay(TimeSpan.FromSeconds(3));
+        }
+    }
+}
+
+// ...
+
+public class RedactedAudioResult
+{
+    [JsonPropertyName("status")]
+    public string Status { get; set; } 
+
+    [JsonPropertyName("redacted_audio_url")]
+    public string RedactedAudioUrl { get; set; }
+
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+}
 ```
 
   </Tab>