internal Constraints Substitute(Constraints constraints)
{
if (!containsVariables())
{
return(constraints);
}
var currentConstraints = constraints;
var currentOffset = _currentMatchStart;
for (var i = 0; i < _tokens.Count - 1; ++i)
{
var variable = _tokens[i];
var length = _variableLenghts[i];
var value = string.Join(" ", _input.Skip(currentOffset).Take(length));
var entityValue = SemanticItem.Entity(value);
currentOffset += length;
currentConstraints = currentConstraints.AddValue(variable, entityValue);
}
var lastValue = string.Join(" ", _input.Skip(currentOffset).Take(_currentMatchEnd - currentOffset));
var entityLastValue = SemanticItem.Entity(lastValue);
currentConstraints = currentConstraints.AddValue(_tokens.Last(), entityLastValue);
return(currentConstraints);
}
internal static void ModuleTesting()
{
var externalDatabase = RestaurantAgent.CreateRestaurantDatabase();
var module = new ExternalDatabaseProviderModule("restaurant", externalDatabase);
var database = new EvaluatedDatabase();
database.Container
.Pattern("luxury")
.WhatItSpecifies("pricerange")
.HowToEvaluate("expensive")
;
database.StartQueryLog();
module.AttachTo(database);
var result = database.Query(SemanticItem.AnswerQuery(Question.HowToDo, Constraints.WithInput("set restaurant specifier luxury")));
//var result = database.Query(SemanticItem.AnswerQuery(Question.IsItTrue, Constraints.WithInput("restaurant database has 1 result")));
var actionId = result.FirstOrDefault().Answer;
var action = database.GetNativeAction(actionId);
action(result.FirstOrDefault());
var log = database.FinishLog();
Log.Questions(log.GetQuestions());
Log.Result(result);
Log.Dump(database);
}
internal NativeEvaluator EvaluateCallArgs(string actionName, NativeAction action, IEnumerable <string> parameters, IEnumerable <ParameterEvaluator> evaluators)
{
var actionId = NativeActionPrefix + actionName;
_nativeActions.Add(actionId, action);
AddSpanElement(actionId);
return(e =>
{
var evaluatedConstraints = new Constraints();
foreach (var parameter in parameters.Zip(evaluators, Tuple.Create))
{
var evaluatedParameter = parameter.Item2(e, parameter.Item1);
if (evaluatedParameter == null)
{
return null;
}
evaluatedConstraints = evaluatedConstraints.AddValue(parameter.Item1, evaluatedParameter);
}
return SemanticItem.From(e.Item.Question, actionId, evaluatedConstraints);
});
}
protected void logPush(SemanticItem item)
{
if (_queryLog.Count == 0)
{
//logging is not enabled
return;
}
Log.QueryPush(item);
var peek = _queryLog.Peek();
if (peek.Query == item)
{
_queryLog.Push(peek);
}
else
{
var log = new QueryLog(item);
if (_expectDependencyQuery)
{
log.IsDependency = true;
_expectDependencyQuery = false;
}
peek.AddSubquery(log);
_queryLog.Push(log);
}
}
protected override SemanticItem transformItem(SemanticItem queryItem, SemanticItem resultItem)
{
var transformedItem = base.transformItem(queryItem, resultItem);
var evalutor = getEvaluator(transformedItem.Answer);
if (evalutor == null)
{
//keep the item without changes
return(transformedItem);
}
if (_contextStack.Count == 0)
{
//push root context
_contextStack.Push(new EvaluationContext(null, this, queryItem));
}
var evaluationContext = new EvaluationContext(_contextStack.Peek(), this, transformedItem);
_contextStack.Push(evaluationContext);
try
{
var evaluationResult = evalutor(evaluationContext);
return(evaluationResult);
}
finally
{
_contextStack.Pop();
if (_contextStack.Count == 1)
{
//root context is popped out
_contextStack.Pop();
}
}
}
internal IEnumerable <SemanticItem> Query(string variable, string question)
{
var substiution = GetSubstitutionValue(variable);
var queryItem = SemanticItem.AnswerQuery(question, new Constraints().AddInput(substiution));
return(Query(queryItem));
}
internal IEnumerable <SemanticItem> Query(SemanticItem queryItem)
{
var result = new List <SemanticItem>();
logPush(queryItem);
if (_debugTriggers.Contains(queryItem.Id))
{
queryItem = queryItem;
}
var matchingEntries = fetchMatchingEntries(queryItem);
foreach (var matchingEntry in matchingEntries)
{
var resultEntry = transformItem(queryItem, matchingEntry);
if (resultEntry != null)
{
result.Add(resultEntry);
}
}
logPop(result);
_evaluationHistory.Add(new EvaluationLogEntry(queryItem.Constraints.Input, queryItem.Question, result));
return(result);
}
private SemanticItem _the(EvaluationContext item)
{
var evaluations = Db.EvaluationHistory.Reverse().Take(10).ToArray();
var something = item.GetSubstitutionValue("$something");
//find evaluation in context
SemanticItem referencedValue = null;
foreach (var evaluation in evaluations)
{
if (!evaluation.Result.Any())
{
continue;
}
if (evaluation.Question != Question.HowToEvaluate)
{
continue;
}
if (evaluation.Input.Contains(something))
{
referencedValue = evaluation.Result.First();
}
}
return(referencedValue);
}
internal IEnumerable <SemanticItem> Generate(SemanticItem input)
{
var inputText = input.InstantiateInputWithEntityVariables();
var inputTokens = tokenize(inputText);
initializeParts(inputText);
while (true)
{
var item = generateCurrentState(inputTokens, _pattern.Constraints);
if (item != null)
{
yield return(item);
}
var i = 0;
while (!_parts[i].ShiftNext())
{
i += 1;
if (i >= _parts.Length)
{
yield break;
}
_parts[i - 1].Reset();
}
}
}
private bool _fireEvent(SemanticItem item)
{
var evt = item.GetSubstitutionValue("$event");
FireEvent(evt);
return(true);
}
internal void Add(SemanticItem item)
{
foreach (var phrase in item.Phrases)
{
_phraseIndex.Add(phrase);
}
_data.Add(item);
}
internal DataContainer Add(string[] patterns, string question, string answer)
{
foreach (var pattern in patterns)
{
Add(SemanticItem.From(question, answer, Constraints.WithInput(pattern)));
}
return(this);
}
private bool _print(SemanticItem item)
{
var something = item.GetSubstitution("$something");
Print(something.ReadableRepresentation());
return(true);
}
public Constraints AddValue(string variable, string value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
return(AddValue(variable, SemanticItem.Entity(value)));
}
private bool _writeSlot(SemanticItem item)
{
var slot = item.GetSubstitutionValue("$slot");
var value = item.GetSubstitution("$value");
_slots[slot] = value;
return(true);
}
private SemanticItem _joinPhrases(EvaluationContext context)
{
var something1 = context.EvaluateOne("$something").Answer;
var something2 = context.EvaluateOne("$something2").Answer;
var joinedPhrase = something1 + " " + something2;
return(SemanticItem.Entity(joinedPhrase));
}
internal static void QueryPush(SemanticItem item)
{
if (!PrintDatabaseInfo)
{
return;
}
Writeln("QUERY: " + item.ToString(), HeadlineColor);
_currentIndentation += 1;
}
private bool _and(SemanticItem item)
{
var action1 = item.GetSubstitutionValue("$action1");
var action2 = item.GetSubstitutionValue("$action2");
var action1Result = ExecuteCommand(action1);
var action2Result = action1Result && ExecuteCommand(action2);
return(action1Result && action2Result);
}
public Constraints AddValue(string variable, SemanticItem item)
{
item = item ?? throw new ArgumentNullException(nameof(item));
var values = new Dictionary <string, SemanticItem>(_variableValues);
values[variable] = item;
return(new Constraints(values, Conditions));
}
private bool _outputChanger(SemanticItem item)
{
var pattern = item.GetSubstitutionValue("$pattern");
var replacement = item.GetSubstitutionValue("$replacement");
_outputReplacements.Add(pattern, replacement);
Print("ok");
return(true);
}
private SemanticItem encodeCall(string nativeActionId, List <Tuple <string, SemanticItem> > evaluatedValues)
{
var arguments = new Constraints();
foreach (var value in evaluatedValues)
{
arguments = arguments.AddValue(value.Item1, value.Item2);
}
return(SemanticItem.Entity(nativeActionId).WithConstraints(arguments));
}
internal SemanticItem EvaluateOne(string variable)
{
var many = Evaluate(variable);
if (many.Count() > 1)
{
throw new NotImplementedException();
}
return(many.FirstOrDefault() ?? SemanticItem.Entity(GetSubstitutionValue(variable)));
}
private bool executeCall(SemanticItem command)
{
var nativeAction = Db.GetNativeAction(command.Answer);
if (nativeAction == null)
{
return(false);
}
return(nativeAction(command));
}
internal SemanticItem ChooseOption(string question, IEnumerable <string> columns)
{
if (columns.Contains(_inputValue))
{
return(SemanticItem.Entity(_inputValue));
}
//TODO many strategies can be here
var result = EvaluationContext.Query(SemanticItem.AnswerQuery(question, Constraints.WithInput(_inputValue)));
return(result.FirstOrDefault());
}
internal bool IsTrue(string variable)
{
var substiution = GetSubstitutionValue(variable);
var queryItem = SemanticItem.AnswerQuery(Question.IsItTrue, Item.Constraints.AddInput(substiution));
var rawResult = _db.SpanQuery(queryItem);
if (!rawResult.Any())
{
return(false);
}
return(rawResult.Last().Answer == SemanticItem.Yes.Answer);
}
private object[] decodeArguments(IEnumerable <ModuleField> parameters, SemanticItem call)
{
var result = new List <object>();
foreach (var parameter in parameters)
{
var semanticValue = call.Constraints.GetSubstitution(parameter.Name);
var argument = parameter.GetInterpretation(semanticValue);
result.Add(argument);
}
return(result.ToArray());
}
internal void HandleEvent(string eventDescription)
{
Log.EventHandler(eventDescription);
var commands = Db.Query(SemanticItem.AnswerQuery(Question.WhatShouldAgentDoNow, Constraints.WithCondition(eventDescription))).ToArray();
foreach (var command in commands)
{
var result = ExecuteCommand(command.Answer);
/*if (!result)
* throw new NotImplementedException("Handle failed command");*/
}
}
internal EmptyAgent()
{
Body.Db.Container
.Pattern("when $condition then $action")
.HowToDo("add $action to trigger $condition")
.Pattern("no output is available")
.IsTrue("output is missing")
.Pattern("say $something")
.HowToDo("print $something")
.Pattern("ask $something")
.HowToDo("print $something joined with ?")
.Pattern("say $something and $something2")
.HowToDo("print $something joined with $something2")
.Pattern("user said $something")
.IsTrue("history contains $something")
.Pattern("you know $something")
.IsTrue("user said $something or $something is defined")
.Pattern(
"i think $something",
"a $something",
"an $something",
"maybe $something",
"probably $something",
"it is $something"
)
.HowToSimplify("$something")
.Pattern("it")
.HowToEvaluate("It", e =>
{
//TODO this is a simple workaround - allows to point to input only
return(SemanticItem.Entity(Body.InputHistory.Last()));
})
.Pattern("say $something instead of $something2")
.HowToDo("use $something instead of $something2 in output")
;
AddPolicy("when user input is received and it is a command then execute it");
AddPolicy("when output is missing then ask for help");
AddPolicy("when question was asked and user input can be an answer then fire event answer is provided");
AddPolicy("when answer is provided then accept the advice");
AddPolicy("when the last command failed and advice was received then repeat the last command");
}
private int rank(SemanticItem item)
{
var result = 0;
foreach (var phrase in item.Phrases)
{
if (_phraseIndex.Contains(phrase))
{
result += 1;
}
}
return(result);
}
internal IEnumerable <SemanticItem> Match(SemanticItem pattern, SemanticItem input)
{
pattern = pattern.WithConstraints(pattern.Constraints.AddConditions(input.Constraints.Conditions));
var matchFactory = getMatchFactory(pattern);
if (matchFactory == null)
{
return(new SemanticItem[0]);
}
var result = matchFactory.Generate(input).ToArray();
return(result);
}
