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 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 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);
}
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 IEnumerable <SemanticItem> Evaluate(string variable)
{
var substiution = GetSubstitution(variable);
if (!substiution.IsEntity)
{
return new[] { substiution }
}
;
var queryItem = SemanticItem.AnswerQuery(Question.HowToEvaluate, new Constraints().AddInput(substiution));
var result = _db.SpanQuery(queryItem);
return(result);
}
private bool meetConditions(SemanticItem queryItem, SemanticItem item)
{
var hasConditions = item.Constraints.Conditions.Any();
if (!hasConditions)
{
return(true);
}
//logPush(item);
var conditionsResult = true;
foreach (var condition in item.Constraints.Conditions)
{
logDependency(condition);
var constraints = queryItem.Constraints.AddInput(condition);
var conditionQueryItem = SemanticItem.AnswerQuery(Question.IsItTrue, constraints);
expectDependencyQuery();
var result = SpanQuery(conditionQueryItem).ToArray();
conditionsResult &= result.LastOrDefault()?.Answer == YesAnswer;
if (!conditionsResult)
{
if (result.FirstOrDefault()?.Answer == NoAnswer)
{
logFailedCondition();
//logRemoveTopSubquery();
}
break;
}
}
// logPop(new SemanticItem[0]);
return(conditionsResult);
}
private bool executeCommand(SemanticItem command)
{
var priorQuestions = Db.CurrentLogRoot.GetQuestions();
var commandQuery = SemanticItem.AnswerQuery(Question.HowToDo, Constraints.WithInput(command));
var commandInterpretations = Db.SpanQuery(commandQuery).ToArray();
foreach (var interpretation in commandInterpretations)
{
if (executeCall(interpretation))
{
//we found a way how to execute the command
return(true);
}
}
var postQuestions = Db.CurrentLogRoot.GetQuestions();
var executionQuestions = postQuestions.Except(priorQuestions).ToArray();
_executionQuestions.AddRange(executionQuestions);
return(false);
}
internal Body()
{
Db.Container
.Pattern("print $something")
.HowToDo("Print", Db.Container.EvaluateCallArgsSpan("Print", _print, "$something"))
.Pattern("$something is a command")
.IsTrue("$something has how to do question specified")
.Pattern("the $something")
.HowToEvaluate("The", _the)
.Pattern("one")
.HowToConvertToNumber("1")
.Pattern("user input")
.HowToEvaluate("UserInput", _userInput)
.Pattern("history contains $something")
.IsTrue("HistoryContains", _historyContains)
.Pattern("write $value into $slot slot")
.HowToDo("WriteSlot", Db.Container.EvaluateCallArgsSpan("WriteSlot", _writeSlot, "$value", "$slot"))
.Pattern("$slot slot is filled")
.IsTrue("IsSlotFilled", _isSlotFilled)
.Pattern("use $replacement instead of $pattern in output")
.HowToDo("OutputChanger", _outputChanger)
.Pattern("$something can be an answer")
.IsTrue("CanBeAnswer", e =>
{
var result = e.Query("$something", Question.CanItBeAnswer).FirstOrDefault();
var canBeAnswer = result == null || result.Answer == Database.YesAnswer;
return(canBeAnswer ? SemanticItem.Yes : SemanticItem.No);
})
.Pattern("execute $something")
.HowToDo("Execute", e =>
{
var something = e.EvaluateOne("$something");
return(something);
})
.Pattern("~ $something")
.IsTrue("Not", _notCond)
.Pattern("$value1 or $value2")
.IsTrue("Or", _orCond)
.Pattern("$action1 and $action2")
.HowToDo("And", _and)
.Pattern("$value1 and $value2")
.IsTrue("And", _andCond)
.Pattern("$something has $question question specified")
.IsTrue("IsQuestionSpecified", e =>
{
var something = e.EvaluateOne("$something");
var question = e.GetSubstitutionValue("$question");
var normalizedQuestion = question + " $@ ?";
var queryItem = SemanticItem.AnswerQuery(normalizedQuestion, Constraints.WithInput(something.Answer));
var result = Db.Query(queryItem);
var answer = result.Any() ? Database.YesAnswer : Database.NoAnswer;
return(SemanticItem.Entity(answer));
})
.Pattern("add $action to trigger $trigger")
.HowToDo("TriggerAdd", _triggerAdd)
.Pattern("fire event $event")
.HowToDo("FireEvent", _fireEvent)
.Pattern("$something joined with $something2")
.HowToEvaluate("JoinPhrases", _joinPhrases)
.Pattern("dump database")
.HowToDo("DumpDatabase", c =>
{
Log.Dump(Db);
Print("ok");
return(true);
})
;
_commandControl = new CommandControlModule(this);
_adviceModule = new AdviceModule(this);
AddModule(_commandControl);
AddModule(_adviceModule);
}
internal SemanticItem GetAnswer(string question, string input)
{
var query = SemanticItem.AnswerQuery(question, Constraints.WithInput(input));
return(EvaluationContext.Query(query).LastOrDefault());
}
/// <summary>
/// Answers of returned items are in span.
/// </summary>
internal IEnumerable <SemanticItem> SpanQuery(SemanticItem queryItem)
{
var result = new List <SemanticItem>();
var itemsToProcess = new Queue <SemanticItem>();
itemsToProcess.Enqueue(queryItem);
itemsToProcess.Enqueue(null);
var depth = 0;
while (itemsToProcess.Count > 0)
{
var item = itemsToProcess.Dequeue();
if (item == null)
{
itemsToProcess.Enqueue(null);
++depth;
if (depth > MaxResolvingDepth)
{
break;
}
continue;
}
if (isInSpan(item.Answer))
{
result.Add(item);
}
else
{
SemanticItem newQuery;
if (item.Answer == null)
{
newQuery = item;
}
else
{
var newConstraints = queryItem.Constraints.MergeWith(item.Constraints);
newConstraints = newConstraints.AddInput(item.Answer);
newQuery = SemanticItem.AnswerQuery(queryItem.Question, newConstraints);
}
var newItems = Query(newQuery).ToArray();
if (newItems.Length == 0)
{
if (item != queryItem)
{
result.Add(item);
}
}
foreach (var newItem in newItems)
{
itemsToProcess.Enqueue(newItem);
}
}
}
return(result);
}
