public List <ModelResult> Parse(string query) { var parsedNumbers = new List <ParseResult>(); // Preprocess the query query = QueryProcessor.Preprocess(query, caseSensitive: true); try { var extractResults = Extractor.Extract(query); foreach (var result in extractResults) { var parseResult = Parser.Parse(result); if (parseResult.Data is List <ParseResult> parseResults) { parsedNumbers.AddRange(parseResults); } else { parsedNumbers.Add(parseResult); } } return(parsedNumbers.Select(BuildModelResult).Where(r => r != null).ToList()); } catch (Exception) { // Nothing to do. Exceptions in parse should not break users of recognizers. // No result. } return(new List <ModelResult>()); }
public List <ModelResult> Parse(string query, DateObject refTime) { var parsedDateTimes = new List <DateTimeParseResult>(); // Preprocess the query query = QueryProcessor.Preprocess(query); try { var extractResults = Extractor.Extract(query, refTime); foreach (var result in extractResults) { var parseResults = Parser.Parse(result, refTime); if (parseResults.Value is List <DateTimeParseResult> list) { parsedDateTimes.AddRange(list); } else { parsedDateTimes.Add(parseResults); } } // Filter out ambiguous cases. Naïve approach. parsedDateTimes = Parser.FilterResults(query, parsedDateTimes); } catch (Exception) { // Nothing to do. Exceptions in parse should not break users of recognizers. // No result. } return(parsedDateTimes.Select(o => GetModelResult(o)).ToList()); }
public virtual List <ModelResult> Parse(string query) { var parsedSequences = new List <ParseResult>(); // Preprocess the query query = QueryProcessor.Preprocess(query); try { var extractResults = Extractor.Extract(query); foreach (var result in extractResults) { parsedSequences.Add(Parser.Parse(result)); } } catch (Exception) { // Nothing to do. Exceptions in parse should not break users of recognizers. // No result. } return(parsedSequences.Select(o => new ModelResult { Start = o.Start.Value, End = o.Start.Value + o.Length.Value - 1, Resolution = new SortedDictionary <string, object> { { ResolutionKey.Value, o.ResolutionStr } }, Text = o.Text, TypeName = ModelTypeName, }).ToList()); }
public List <ModelResult> Parse(string query) { var parsedNumbers = new List <ParseResult>(); // Preprocess the query query = QueryProcessor.Preprocess(query, caseSensitive: true); try { var extractResults = Extractor.Extract(query); foreach (var result in extractResults) { var parseResult = Parser.Parse(result); if (parseResult.Data is List <ParseResult> parseResults) { parsedNumbers.AddRange(parseResults); } else { parsedNumbers.Add(parseResult); } } } catch (Exception) { // Nothing to do. Exceptions in parse should not break users of recognizers. // No result. } return(parsedNumbers.Select(o => { var end = o.Start.Value + o.Length.Value - 1; var resolution = new SortedDictionary <string, object> { { ResolutionKey.Value, o.ResolutionStr } }; var extractorType = Extractor.GetType().ToString(); // Only support "subtype" for English for now // As some languages like German, we miss handling some subtypes between "decimal" and "integer" if (!string.IsNullOrEmpty(o.Type) && Constants.ValidSubTypes.Contains(o.Type) && extractorType.Contains(Constants.ENGLISH)) { resolution.Add(ResolutionKey.SubType, o.Type); } return new ModelResult { Start = o.Start.Value, End = end, Resolution = resolution, Text = o.Text, TypeName = ModelTypeName }; }).ToList()); }
public void TestDateTimeParser(TestModel testSpec) { TestPreValidation(testSpec); var referenceDateTime = testSpec.GetReferenceDateTime(); var extractResults = Extractor.Extract(QueryProcessor.Preprocess(testSpec.Input), referenceDateTime); var actualResults = extractResults.Select(o => DateTimeParser.Parse(o, referenceDateTime)).ToArray(); var expectedResults = testSpec.CastResults <DateTimeParseResult>(); Assert.AreEqual(expectedResults.Count(), actualResults.Count(), GetMessage(testSpec)); foreach (var tuple in Enumerable.Zip(expectedResults, actualResults, Tuple.Create)) { var expected = tuple.Item1; var actual = tuple.Item2; var ignoreResultCase = true; Assert.AreEqual(expected.Type, actual.Type, GetMessage(testSpec)); Assert.AreEqual(expected.Text, actual.Text, ignoreResultCase, GetMessage(testSpec)); Assert.AreEqual(expected.Start, actual.Start, GetMessage(testSpec)); Assert.AreEqual(expected.Length, actual.Length, GetMessage(testSpec)); if (testSpec.IgnoreResolution) { Assert.Inconclusive(GetMessage(testSpec) + ". Resolution not validated."); } else { var actualValue = actual.Value as DateTimeResolutionResult; var expectedValue = JsonConvert.DeserializeObject <DateTimeResolutionResult>(expected.Value.ToString()); Assert.IsNotNull(actualValue, GetMessage(testSpec)); Assert.AreEqual(expectedValue.Timex, actualValue.Timex, GetMessage(testSpec)); if (expectedValue.Mod != null || actualValue.Mod != null) { Assert.IsNotNull(expectedValue.Mod, GetMessage(testSpec)); Assert.IsNotNull(actualValue.Mod, GetMessage(testSpec)); Assert.AreEqual(expectedValue.Mod, actualValue.Mod, GetMessage(testSpec)); } CollectionAssert.AreEqual(expectedValue.FutureResolution, actualValue.FutureResolution, GetMessage(testSpec)); CollectionAssert.AreEqual(expectedValue.PastResolution, actualValue.PastResolution, GetMessage(testSpec)); if (expectedValue.TimeZoneResolution != null || actualValue.TimeZoneResolution != null) { Assert.IsNotNull(actualValue.TimeZoneResolution, GetMessage(testSpec)); Assert.IsNotNull(expectedValue.TimeZoneResolution, GetMessage(testSpec)); Assert.AreEqual(expectedValue.TimeZoneResolution.Value, actualValue.TimeZoneResolution.Value, GetMessage(testSpec)); Assert.AreEqual(expectedValue.TimeZoneResolution.UtcOffsetMins, actualValue.TimeZoneResolution.UtcOffsetMins, GetMessage(testSpec)); } } } }
public void TestDateTimeExtractor(TestModel testSpec) { TestPreValidation(testSpec); var referenceDateTime = testSpec.GetReferenceDateTime(); var actualResults = Extractor.Extract(QueryProcessor.Preprocess(testSpec.Input), referenceDateTime); var expectedResults = testSpec.CastResults <ExtractResult>(); Assert.AreEqual(expectedResults.Count(), actualResults.Count, GetMessage(testSpec)); foreach (var tuple in Enumerable.Zip(expectedResults, actualResults, Tuple.Create)) { var expected = tuple.Item1; var actual = tuple.Item2; var ignoreResultCase = true; Assert.AreEqual(expected.Type, actual.Type, GetMessage(testSpec)); Assert.AreEqual(expected.Text, actual.Text, ignoreResultCase, GetMessage(testSpec)); Assert.AreEqual(expected.Start, actual.Start, GetMessage(testSpec)); Assert.AreEqual(expected.Length, actual.Length, GetMessage(testSpec)); } }
public List<ModelResult> Parse(string query) { // Preprocess the query query = QueryProcessor.Preprocess(query, caseSensitive: true); var extractionResults = new List<ModelResult>(); try { foreach (var p in ExtractorParserDic) { var extractor = p.Key; var parser = p.Value; var extractedResults = extractor.Extract(query); var parsedResults = new List<ParseResult>(); foreach (var result in extractedResults) { var parseResult = parser.Parse(result); if (parseResult.Value is List<ParseResult>) { parsedResults.AddRange((List<ParseResult>)parseResult.Value); } else { parsedResults.Add(parseResult); } } var modelResults = parsedResults.Select(o => new ModelResult { Start = o.Start.Value, End = o.Start.Value + o.Length.Value - 1, Resolution = (o.Value is CurrencyUnitValue) ? new SortedDictionary<string, object> { { ResolutionKey.Value, ((CurrencyUnitValue)o.Value).Number }, { ResolutionKey.Unit, ((CurrencyUnitValue)o.Value).Unit }, { ResolutionKey.IsoCurrency, ((CurrencyUnitValue)o.Value).IsoCurrency }, } : (o.Value is UnitValue && !string.IsNullOrEmpty(o.Type) && Constants.ValidSubTypes.Contains(o.Type)) ? new SortedDictionary<string, object> { { ResolutionKey.Value, ((UnitValue)o.Value).Number }, { ResolutionKey.Unit, ((UnitValue)o.Value).Unit }, { ResolutionKey.SubType, o.Type }, } : (o.Value is UnitValue) ? new SortedDictionary<string, object> { { ResolutionKey.Value, ((UnitValue)o.Value).Number }, { ResolutionKey.Unit, ((UnitValue)o.Value).Unit }, } : new SortedDictionary<string, object> { { ResolutionKey.Value, (string)o.Value }, }, Text = o.Text, TypeName = ModelTypeName, }).ToList(); foreach (var result in modelResults) { bool shouldAdd = true; foreach (var extractionResult in extractionResults) { if (result.Start <= extractionResult.Start && result.End >= extractionResult.End) { shouldAdd = false; } } if (shouldAdd) { extractionResults.Add(result); } } } } catch (Exception) { // Nothing to do. Exceptions in parse should not break users of recognizers. // No result. } return extractionResults; }
public List <ModelResult> Parse(string query) { var parsedNumbers = new List <ParseResult>(); // Preprocess the query query = QueryProcessor.Preprocess(query, caseSensitive: true); try { var extractResults = Extractor.Extract(query); foreach (var result in extractResults) { var parseResult = Parser.Parse(result); if (parseResult.Data is List <ParseResult> parseResults) { parsedNumbers.AddRange(parseResults); } else { parsedNumbers.Add(parseResult); } } } catch (Exception) { // Nothing to do. Exceptions in parse should not break users of recognizers. // No result. } return(parsedNumbers.Select(o => { var end = o.Start.Value + o.Length.Value - 1; var resolution = new SortedDictionary <string, object>(); if (o.Value != null) { resolution.Add(ResolutionKey.Value, o.ResolutionStr); } var extractorSupportsSubtype = ExtractorsSupportingSubtype.Exists(e => Extractor.GetType().ToString().Contains(e)); // Check if current extractor supports the Subtype field in the resolution // As some languages like German, we miss handling some subtypes between "decimal" and "integer" if (!string.IsNullOrEmpty(o.Type) && Constants.ValidSubTypes.Contains(o.Type) && extractorSupportsSubtype) { resolution.Add(ResolutionKey.SubType, o.Type); } var type = string.Empty; // for ordinal and ordinal.relative // Only support "ordinal.relative" for English for now if (ModelTypeName.Equals(Constants.MODEL_ORDINAL)) { if (o.Metadata != null && o.Metadata.IsOrdinalRelative) { type = $"{ModelTypeName}.{Constants.RELATIVE}"; } else { type = ModelTypeName; } resolution.Add(ResolutionKey.Offset, o.Metadata.Offset); resolution.Add(ResolutionKey.RelativeTo, o.Metadata.RelativeTo); } else { type = ModelTypeName; } return new ModelResult { Start = o.Start.Value, End = end, Resolution = resolution, Text = o.Text, TypeName = type, }; }).ToList()); }