def test_lst_execution(self): atom1 = ConceptNode("atom1") exec_link = ExecutionOutputLink(GroundedSchemaNode("py:ret_lst"), ListLink(atom1, atom1, atom1)) try: execute_atom(self.space, exec_link) self.assertFalse("call should fail") except RuntimeError as e: # Use `nosetests3 --nocapture` to see this print... print("The exception message is " + str(e)) self.assertTrue("did not return Atomese" in str(e))
def test_add_atom_from_grounded_schema_node(self): test_as = create_child_atomspace(self.atomspace) execute_atom( test_as, ExecutionOutputLink(GroundedSchemaNode("py:add_new_link"), ListLink())) self.assertTrue( test_as.is_link_in_atomspace(types.InheritanceLink, [ test_as.add_node(types.ConceptNode, "cat"), test_as.add_node(types.ConceptNode, "animal") ]))
def get_context_actual_truth(atomspace: AtomSpace, cogscm: Atom, i: int) -> TruthValue: """Calculate tv of the context of cognitive schematic cogscm at time i. Given a cognitive schematic of that format BackPredictiveImplicationScope <tv> <vardecl> <expiry> And (or SimultaneousAnd?) <context> Execution <action> <input> [optional] <output> [optional] <goal> calculate the truth value of <context> at time i, where the variables have been properly instantiated. For now the calculation is crisp, either a context is completely true (stv 1 1) or completely false (stv 0 1). """ # Build and run a query to check if the context is true vardecl = get_vardecl(cogscm) present_clauses, virtual_clauses = get_context(cogscm) stamped_present_clauses = [timestamp(pc, i) for pc in present_clauses] body = AndLink(PresentLink(*stamped_present_clauses), IsClosedLink(*stamped_present_clauses), IsTrueLink(*stamped_present_clauses), *virtual_clauses) query = SatisfactionLink(vardecl, body) tv = execute_atom(atomspace, query) return tv
def _get_atoms_by_type(self, type): type_name = get_type_name(type) return execute_atom( self.space, GetLink( VariableList( TypedVariableLink(VariableNode("X"), TypeNode(type_name))), AndLink(VariableNode("X"))))
def test_too_many_args(self): atom1 = ConceptNode("atom1") exec_link = ExecutionOutputLink(GroundedSchemaNode("py:return_concept"), ListLink(atom1, atom1)) try: result = execute_atom(self.space, exec_link) self.assertFalse("call should fail") except RuntimeError as e: self.assertTrue("but 2 were given" in str(e))
def test_too_few_args(self): atom1 = ConceptNode("atom1") exec_link = ExecutionOutputLink(GroundedSchemaNode("py:return_concept"), ListLink()) try: result = execute_atom(self.space, exec_link) self.assertFalse("call should fail") except RuntimeError as e: self.assertTrue("missing 1 required positional argument" in str(e))
def test_tmp_atomspace(self): ListLink(ConceptNode("foo"), ConceptNode("bar")) get = GetLink(VariableNode("x"), AndLink( PresentLink(ListLink (ConceptNode("foo"), (VariableNode("x")))), EvaluationLink(GroundedPredicateNode("py: test_functions.func_one"), ListLink(VariableNode("x"))), EvaluationLink(GroundedPredicateNode( "py: test_functions.func_two"), ListLink (VariableNode ("x"))))) result = execute_atom(self.atomspace, get) self.assertFalse(result.out) self.assertFalse(self.atomspace.is_node_in_atomspace(types.ConceptNode, 'barleycorn')) test_functions.func_one_result = TruthValue(1,1) result = execute_atom(self.atomspace, get) self.assertTrue(result.out) # still should not be in the current namespace self.assertFalse(self.atomspace.is_node_in_atomspace(types.ConceptNode, 'barleycorn'))
def test_good_execution(self): atom1 = ConceptNode("atom1") exec_link = ExecutionOutputLink(GroundedSchemaNode("py:good_tv"), ListLink(atom1, atom1, atom1)) okay = execute_atom(self.space, exec_link) # Use `nosetests3 --nocapture` to see this print... print("The good TV is " + str(okay)) expect = TruthValue(0.5, 0.5) self.assertTrue(okay == expect)
def test_do_execute_value(self): key = PredicateNode("key") atom = ConceptNode("atom") atom.set_value(key, FloatValue([1, 2, 3])) value_of_link = ValueOfLink(atom, key) value = execute_atom(self.atomspace, value_of_link) self.assertEqual(FloatValue([1, 2, 3]), value) self.assertEqual([1, 2, 3], value.to_list())
def test_do_execute_atom(self): (DefineLink( DefinedSchemaNode('add'), LambdaLink(VariableList(VariableNode('$X'), VariableNode('$Y')), PlusLink(VariableNode('$X'), VariableNode('$Y'))))) res = execute_atom( self.atomspace, ExecutionOutputLink(DefinedSchemaNode('add'), ListLink(NumberNode("3"), NumberNode("4")))) self.assertEqual(NumberNode("7"), res)
def test_grounded_cond(self): grounded_cond = CondLink( EvaluationLink(GroundedPredicateNode("py:grounded_cond1"), ListLink()), NumberNode('1'), EvaluationLink(GroundedPredicateNode("py:grounded_cond2"), ListLink()), NumberNode('2')) result = execute_atom(self.space, grounded_cond) baz = NumberNode("2") print("got %s", result) print("expected %s\n", baz) self.assertTrue(result == baz)
def test_execute_atom(self): result = execute_atom(self.atomspace, ExecutionOutputLink( GroundedSchemaNode("py: test_functions.add_link"), ListLink( ConceptNode("one"), ConceptNode("two") ) ) ) list_link = ListLink( ConceptNode("one"), ConceptNode("two") ) self.assertEquals(result, list_link)
def test_run_openpsi(self): openpsi = OpenPsi(atomspace) goal = openpsi.create_goal("goal-run") context = [ InheritanceLink( VariableNode("$APPLE"), ConceptNode("apple")), AbsentLink( InheritanceLink( VariableNode("$APPLE"), ConceptNode("handled"))) ] action = ExecutionOutputLink( GroundedSchemaNode("py: eat_apple"), ListLink( VariableNode("$APPLE"))) component = openpsi.create_component("test-component-run") openpsi.add_rule(context, action, goal, TruthValue(1.0, 1.0), component) openpsi.run(component) # Apples are handled by OpenPsi loop InheritanceLink(ConceptNode("apple-1"), ConceptNode("apple")) InheritanceLink(ConceptNode("apple-2"), ConceptNode("apple")) delay = 5 time.sleep(delay) openpsi.halt(component) handled_apples = GetLink( InheritanceLink( VariableNode("$APPLE"), ConceptNode("handled"))) result_set = execute_atom(atomspace, handled_apples) result1 = result_set.out[0] result2 = result_set.out[1] self.assertEqual(result1, ConceptNode("apple-1")) self.assertEqual(result2, ConceptNode("apple-2"))
def test_bindlink(self): atom = execute_atom(self.atomspace, self.bindlink_atom) print("Bindlink found: " + str(atom)) self._check_result_setlink(atom, 3)
) ) ''' scheme_eval(atomspace, execute_code) print ("execute: cog-execute") if (executed): print ("add_link - executed successfully") else: print ("add_link - did NOT execute") executed = False execute_atom( atomspace, ExecutionOutputLink( GroundedSchemaNode("py: add_link"), ListLink( ConceptNode("one"), ConceptNode("two") ) ) ) print ("execute: execute_atom") if (executed): print ("add_link - executed successfully") else: print ("add_link - did NOT execute") finalize_opencog() del atomspace
def test_satisfying_set(self): atom = execute_atom(self.atomspace, self.getlink_atom) self._check_result_setlink(atom, 3)
def test_execute_atom_no_return_value(self): result = execute_atom(self.atomspace, PutLink(DeleteLink(VariableNode("X")), ConceptNode("deleteme"))) self.assertEquals(result, None)
def test_correct_argcount(self): atom1 = ConceptNode("atom1") exec_link = ExecutionOutputLink(GroundedSchemaNode("py:return_concept"), ListLink(atom1)) result = execute_atom(self.space, exec_link) self.assertTrue(result.name == "test")