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());
}
