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); }
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)); }
public Constraints AddValue(string variable, string value) { if (value == null) { throw new ArgumentNullException(nameof(value)); } return(AddValue(variable, SemanticItem.Entity(value))); }
internal SemanticItem EvaluateOne(string variable) { var many = Evaluate(variable); if (many.Count() > 1) { throw new NotImplementedException(); } return(many.FirstOrDefault() ?? SemanticItem.Entity(GetSubstitutionValue(variable))); }
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 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 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"); }
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); }
private SemanticItem _userInput(EvaluationContext context) { return(SemanticItem.Entity(_inputHistory.Last())); }
internal bool ExecuteCommand(string utterance) { return(executeCommand(SemanticItem.Entity(utterance))); }
private IEnumerable <SemanticItem> fetchMatchingEntries(SemanticItem queryItem) { if (queryItem.Question == null) { throw new NotImplementedException(); } if (queryItem.Answer != null) { throw new NotImplementedException(); } var result = new List <SemanticItem>(); if (queryItem.Question == Question.IsItTrue) { //TODO conditions should be more general thing var inputConditions = new HashSet <string>(queryItem.Constraints.Conditions); var condition = queryItem.InstantiateInputWithEntityVariables(); logDependency(condition); if (inputConditions.Contains(condition)) { //condition is met because of input result.Add(SemanticItem.Entity(YesAnswer)); } var negatedCondition = Constraints.Negate(condition); if (inputConditions.Contains(negatedCondition)) { //we have got a negative result result.Add(SemanticItem.Entity(NoAnswer)); } } if (result.Count > 0) { return(result); } foreach (var item in GetData()) { if (item.Question != queryItem.Question) { continue; } /*if ((item.Constraints.Input == null) != (queryItem.Constraints == null)) * //when input is provided it should be considered * continue;*/ if (item.Constraints.Input != null) { var matcher = new InputMatcher(); var itemMatches = matcher.Match(item, queryItem).ToArray(); var matchedItems = new List <SemanticItem>(); foreach (var match in itemMatches) { if (meetConditions(queryItem, match)) { matchedItems.Add(match); } } result.AddRange(matchedItems.OrderByDescending(i => rank(i))); } else { if (meetConditions(queryItem, item)) { result.Add(item); } } if (result.Count > 0) { break; } } return(result); }