def test_add_atom_from_grounded_schema_node(self): test_as = 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, cogscm, i): """Calculate tv of the context of cognitive schematic cogscm at time i. Given a cognitive schematic of that format PredictiveImplicationScope <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 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_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_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_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_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_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_satisfying_set(self): atom = execute_atom(self.atomspace, self.getlink_atom) self._check_result_setlink(atom, 3)
def test_bindlink(self): atom = execute_atom(self.atomspace, self.bindlink_atom) print("Bindlink found: " + str(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)
(ExecutionOutputLink (GroundedSchemaNode \"py: add_link\") (ListLink (ConceptNode \"one\") (ConceptNode \"two\") ) ) ) ''' 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
ListLink( ConceptNode("green light") ) ), EvaluationLink( GroundedPredicateNode("py: stop_go"), ListLink( ConceptNode("green light") ) ), EvaluationLink( GroundedPredicateNode("py: stop_go"), ListLink( ConceptNode("red light") ) ), EvaluationLink( GroundedPredicateNode("py: stop_go"), ListLink( ConceptNode("traffic ticket") ) ) ) ) # Perform the actual satisfiability search. result = execute_atom(atomspace, satisfaction_handle) print("Number of green lights:", green) print("Number of red lights:", red)
print("Entering static method with\n", x1) return x1 def forward(self, x1, x2): print("Entering LocalClass with\n", x1, x2) return x1 nn = LocalClass() # local function exlof = ExecutionOutputLink( GroundedSchemaNode("py:local_func"), ListLink(ConceptNode("aa"), ConceptNode("bb"), ConceptNode("cc"))) assert execute_atom( a, exlof) == ConceptNode("cc"), "Failed while calling local function" # local object exloc = ExecutionOutputLink(GroundedSchemaNode("py:nn.forward"), ListLink(ConceptNode("aa"), ConceptNode("bb"))) assert execute_atom( a, exloc) == ConceptNode("aa"), "Failed while calling local object method" # static method exst = ExecutionOutputLink(GroundedSchemaNode("py:LocalClass.static_check"), ListLink(ConceptNode("aa"))) assert execute_atom( a, exst) == ConceptNode("aa"), "Failed while calling static class method"
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")