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