Convert timestamp to opt-in feature

Not convinced that we need to do this, but we can spare a few bytes in the NLU results files by only including the timestamp when requested via CLI argument.

Author: rozele

docs/Test.md

@@ -153,6 +153,11 @@ See [Caching speech-to-text transcriptions](#caching-speech-to-text-transcriptio
 
 This is currently only used for LUIS, see the section on LUIS prebuilt entities in [Configuring prebuilt entities](LuisModelConfiguration.md#configuring-prebuilt-entities).
 
+### `--timestamp`
+(Optional) Signals whether to add a timestamp to each NLU test result.
+
+See the documentation on the [`timestamp` property](UtteranceExtensions.md#returning-timestamps-for-each-query) for more details.
+
 ### `-i, --include`
 (Optional) Path to custom NLU provider DLL. See documentation about [Specifying the include path](https://github.com/microsoft/NLU.DevOps/blob/master/docs/CliExtensions.md#specifying-the-include-path) for more details.
 

docs/UtteranceExtensions.md

@@ -22,7 +22,7 @@ When an NLU provider in NLU.DevOps returns a prediction result, the value will b
 ```
 In this case, the intent confidence score was `0.99` and the text transcription confidence score was `0.95`. This is useful context when debugging false predictions, as a low confidence score may indicate that the model could be improved with more training examples. The recognized `genre` entity also includes a confidence score of `0.80`, although it should be noted that only the LUIS provider currently returns confidence score for entity types trained from examples.
 
-## Labeled utterance timestamps
+## Returning timestamps for each query
 
 When analyzing results for a set of NLU predictions, it is often important context to understand when the test was run. For example, for Dialogflow `date` and `time` entities, the service only returns a date time string, and no indication of what token(s) triggered that entity to be recognized. For example, the result from a query like `"Call a taxi in 15 minutes"` may look like the following:
 ```json
@@ -38,7 +38,7 @@ When analyzing results for a set of NLU predictions, it is often important conte
     "timestamp": "2020-01-01T00:00:00-04:00"
 }
 ```
-Without the context provided by the `timestamp` property, we wouldn't be able to make any assertion about the correctness of the `entityValue` property for time. Currently, LUIS, Lex, and Dialogflow return a timestamp for each prediction result.
+Without the context provided by the `timestamp` property, we wouldn't be able to make any assertion about the correctness of the `entityValue` property for time. Currently, you must specify the [`--timestamp`](Test.md#--timestamp) option to ensure a timestamp is assigned to each NLU prediction result.
 
 ## Utterance Extension Properties
 

src/NLU.DevOps.CommandLine/Test/TestCommand.cs

@@ -7,7 +7,9 @@ namespace NLU.DevOps.CommandLine.Test
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
+    using Core;
     using Models;
     using Newtonsoft.Json.Linq;
     using static Serializer;
@@ -32,7 +34,8 @@ public override int Main()
 
         protected override INLUTestClient CreateNLUTestClient()
         {
-            return NLUClientFactory.CreateTestInstance(this.Options, this.Configuration, this.Options.SettingsPath);
+            var client = NLUClientFactory.CreateTestInstance(this.Options, this.Configuration, this.Options.SettingsPath);
+            return this.Options.Timestamp ? new TimestampNLUTestClient(client) : client;
         }
 
         private static void EnsureDirectory(string filePath)
@@ -146,5 +149,34 @@ public LabeledUtteranceWithSpeechFile(string text, string intent, string speechF
 
             public string SpeechFile { get; }
         }
+
+        private class TimestampNLUTestClient : INLUTestClient
+        {
+            public TimestampNLUTestClient(INLUTestClient client)
+            {
+                this.Client = client;
+            }
+
+            private INLUTestClient Client { get; }
+
+            public async Task<LabeledUtterance> TestAsync(JToken query, CancellationToken cancellationToken)
+            {
+                var timestamp = DateTimeOffset.Now;
+                var result = await this.Client.TestAsync(query, cancellationToken).ConfigureAwait(false);
+                return result.WithTimestamp(timestamp);
+            }
+
+            public async Task<LabeledUtterance> TestSpeechAsync(string speechFile, JToken query, CancellationToken cancellationToken)
+            {
+                var timestamp = DateTimeOffset.Now;
+                var result = await this.Client.TestSpeechAsync(speechFile, query, cancellationToken).ConfigureAwait(false);
+                return result.WithTimestamp(timestamp);
+            }
+
+            public void Dispose()
+            {
+                this.Client.Dispose();
+            }
+        }
     }
 }

src/NLU.DevOps.CommandLine/Test/TestOptions.cs

@@ -28,5 +28,8 @@ internal class TestOptions : BaseOptions
 
         [Option('p', "parallelism", HelpText = "Numeric value to determine the numer of parallel tests.  Default value is 3.", Required = false)]
         public int Parallelism { get; set; } = 3;
+
+        [Option("timestamp", HelpText = "Assign a timestamp to each utterance result.", Required = false)]
+        public bool Timestamp { get; set; }
     }
 }

src/NLU.DevOps.Dialogflow/DialogflowNLUTestClient.cs

@@ -78,8 +78,7 @@ protected override async Task<LabeledUtterance> TestAsync(string utterance, Canc
                                 result.QueryResult.Intent.DisplayName,
                                 result.QueryResult.Parameters?.Fields.SelectMany(GetEntities).ToList())
                             .WithScore(result.QueryResult.IntentDetectionConfidence)
-                            .WithTextScore(result.QueryResult.SpeechRecognitionConfidence)
-                            .WithTimestamp(DateTimeOffset.Now);
+                            .WithTextScore(result.QueryResult.SpeechRecognitionConfidence);
                     },
                     cancellationToken)
                 .ConfigureAwait(false);
@@ -115,8 +114,7 @@ protected override async Task<LabeledUtterance> TestSpeechAsync(string speechFil
                                 result.QueryResult.Intent.DisplayName,
                                 result.QueryResult.Parameters?.Fields.SelectMany(GetEntities).ToList())
                             .WithScore(result.QueryResult.IntentDetectionConfidence)
-                            .WithTextScore(result.QueryResult.SpeechRecognitionConfidence)
-                            .WithTimestamp(DateTimeOffset.Now);
+                            .WithTextScore(result.QueryResult.SpeechRecognitionConfidence);
                     },
                     cancellationToken)
                 .ConfigureAwait(false);

src/NLU.DevOps.Lex/LexNLUTestClient.cs

@@ -94,8 +94,7 @@ protected override async Task<LabeledUtterance> TestAsync(string utterance, Canc
                 .Select(slot => new Entity(slot.Key, slot.Value, null, 0))
                 .ToArray();
 
-            return new LabeledUtterance(utterance, postTextResponse.IntentName, entities)
-                .WithTimestamp(DateTimeOffset.Now);
+            return new LabeledUtterance(utterance, postTextResponse.IntentName, entities);
         }
 
         /// <inheritdoc />
@@ -125,8 +124,7 @@ protected override async Task<LabeledUtterance> TestSpeechAsync(string speechFil
                         .ToArray()
                     : null;
 
-                return new JsonLabeledUtterance(postContentResponse.InputTranscript, postContentResponse.IntentName, slots)
-                    .WithTimestamp(DateTimeOffset.Now);
+                return new LabeledUtterance(postContentResponse.InputTranscript, postContentResponse.IntentName, slots);
             }
         }
 

src/NLU.DevOps.Luis/LuisNLUTestClient.cs

@@ -147,8 +147,7 @@ Entity getEntity(EntityModel entity)
                     speechLuisResult.LuisResult.TopScoringIntent?.Intent,
                     speechLuisResult.LuisResult.Entities?.Select(getEntity).ToList())
                 .WithScore(speechLuisResult.LuisResult.TopScoringIntent?.Score)
-                .WithTextScore(speechLuisResult.TextScore)
-                .WithTimestamp(DateTimeOffset.Now);
+                .WithTextScore(speechLuisResult.TextScore);
         }
     }
 }

src/NLU.DevOps.LuisV3/LuisNLUTestClient.cs

@@ -178,8 +178,7 @@ private LabeledUtterance LuisResultToLabeledUtterance(SpeechPredictionResponse s
             speechPredictionResponse.PredictionResponse.Prediction.Intents?.TryGetValue(intent, out intentData);
             return new LabeledUtterance(query, intent, entities)
                 .WithScore(intentData?.Score)
-                .WithTextScore(speechPredictionResponse.TextScore)
-                .WithTimestamp(DateTimeOffset.Now);
+                .WithTextScore(speechPredictionResponse.TextScore);
         }
     }
 }