def put(self, id): """ Updates the AttentionValue (STI, LTI, VLTI) or TruthValue of an atom """ if Handle(id) not in self.atomspace: abort(404, 'Handle not found') # Prepare the atom data data = reqparse.request.get_json() if 'truthvalue' not in data and 'attentionvalue' not in data: abort( 400, 'Invalid request: you must include a truthvalue or ' 'attentionvalue parameter') if 'truthvalue' in data: tv = ParseTruthValue.parse(data) self.atomspace.set_tv(h=Handle(id), tv=tv) if 'attentionvalue' in data: (sti, lti, vlti) = ParseAttentionValue.parse(data) self.atomspace.set_av(h=Handle(id), sti=sti, lti=lti, vlti=vlti) atom = self.atomspace[Handle(id)] return {'atoms': marshal(atom, atom_fields)}
def delete(self, id): """ Removes an atom from the AtomSpace Uri: atoms/[id] :param id: Atom handle :return result: Returns a JSON representation of the result, indicating success or failure. Example: { 'result': { 'handle': 2, 'success': 'true' } } """ if Handle(id) not in self.atomspace: abort(404, 'Handle not found') else: atom = self.atomspace[Handle(id)] status = self.atomspace.remove(atom) response = DeleteAtomResponse(id, status) return {'result': response.format()}
def delete(self, id): """ Removes an atom from the AtomSpace """ if Handle(id) not in self.atomspace: abort(404, 'Handle not found') else: atom = self.atomspace[Handle(id)] status = self.atomspace.remove(atom) response = DeleteAtomResponse(id, status) return {'result': response.format()}
def __get_atoms_in_sti_range( self, focus_atoms, atom_type, least_count, sti_min, sti_max ): """ Choose atoms within proper STI range. :param Type atom_type: type of atoms to choose. :param int least_count: minimum number of atoms to choose. :param float sti_min: min value of sti to choose. :param float sti_max: max value of sti to choose. """ all_atoms = self.a.get_atoms_by_av(sti_min, sti_max) all_atoms_h_set = set( map(lambda atom: atom.handle_uuid(), all_atoms) ) focus_atoms_h_set = set( map(lambda atom: atom.handle_uuid(), focus_atoms) ) atoms_h_set = all_atoms_h_set & focus_atoms_h_set if len(atoms_h_set) < least_count: self.last_status = self.Status.NOT_ENOUGH_ATOMS raise UserWarning('Size of atom list is too small.') self.ret = map(lambda atom_h: self.a[Handle(atom_h)], atoms_h_set) self.ret = filter(lambda atom: atom.is_a(atom_type), self.ret) if len(self.ret) < least_count: self.last_status = self.Status.NOT_ENOUGH_ATOMS raise UserWarning('Size of atom list is too small.')
def test_2(a, n): """Add n nodes and create a complete (fully-connected) graph in atomspace a and returns the number of items processed """ offset = a.add_node(types.ConceptNode, "Starting handle offset") offset = offset.h.value() for i in range(1, n + 1): a.add_node(types.ConceptNode, str(i), TruthValue(.5, .5)) for j in range(1, i): a.add_link( types.HebbianLink, [Handle(i + offset), Handle(j + offset)], TruthValue(.2, .3)) # Number of vertices plus number of edges in a fully connected graph return n + (n**2 - n) / 2
def testAddSolidUnitBlock__PositionOverBorder__GetBlockFailed(self): border = 32768 test_pos1 = (border, 8, 9) test_handle1 = Handle(100) self.testmap.add_solid_unit_block(test_handle1, test_pos1) test_handle2 = self.testmap.get_block(test_pos1) self.assertTrue(test_handle2.is_undefined())
def tree_with_real_atoms(tr, a): #if isinstance(tr.op, Atom): if isinstance(tr.op, FakeAtom): return Atom(Handle(tr.op._handle_value), a) elif tr.is_leaf(): return tr else: return Tree(tr.op, [tree_with_real_atoms(child, a) for child in tr.args])
def get(self, id): """ Returns the atom for the given handle Uri: atoms/[id] :param id: Atom handle :return atoms: Returns a JSON representation of an atom list containing the atom. Example: { 'atoms': { 'handle': 6, 'name': '', 'type': 'InheritanceLink', 'outgoing': [2, 1], 'incoming': [], 'truthvalue': { 'type': 'simple', 'details': { 'count': '0.4000000059604645', 'confidence': '0.0004997501382604241', 'strength': '0.5' } }, 'attentionvalue': { 'lti': 0, 'sti': 0, 'vlti': false } } } """ try: atom = self.atomspace[Handle(id)] except IndexError: abort(404, 'Handle not found') json_data = {'atoms': marshal(atom, atom_fields)} # if callback function supplied, pad the JSON data (i.e. JSONP): args = self.reqparse.parse_args() callback = args.get('callback') if callback is not None: response = str(callback) + '(' + json.dumps(json_data) + ');' return current_app.response_class( response, mimetype='application/javascript') else: return current_app.response_class(json.dumps(json_data), mimetype='application/json')
def get_src_list(self, a): ret = [] src_node_h_int_list = self.src_h_list_str.split(', ') # Delete end of string src_node_h_int_list.pop() for src_node_h_int in src_node_h_int_list: ret.append(a[Handle(int(src_node_h_int))]) return ret
def run_pln_example(a, f): a.clear() testdir = '../tests/reasoning/pln/targets/' datadirs = ['../tests/reasoning/pln/scm/', '../opencog/'] fname = testdir + f config = ConfigParser.ConfigParser() read_files = config.read(fname) if not read_files: raise Exception("no such file:", fname) def get(field): return config.get('PLN_TEST', field) def get_list(field): return get(field).replace(' ', '').split(',') print f def load_axioms(fname): for d in datadirs: kf = d + fname + '.scm' try: tmp = open(kf, 'r') scheme_wrapper.load_scm(a, kf) print kf return except IOError: continue raise IOError("missing data file: " + kf) data_files = get_list('load') for fname in data_files: load_axioms(fname) scm_target = '(cog-handle %s)' % (get('target'), ) print scm_target handle_str = scheme_wrapper.scheme_eval(scm_target) try: h = int(handle_str) except ValueError: print handle_str raise Exception("Scheme error in target") nsteps = int(get('max_steps')) target = Atom(Handle(h), a) try: rule_names = get_list('allowed_rules') except ConfigParser.NoOptionError, e: rule_names = []
def post(self): """ Creates a new atom. If the atom already exists, it updates the atom. """ # Prepare the atom data and validate it data = reqparse.request.get_json() if 'type' in data: if data['type'] in types.__dict__: type = types.__dict__.get(data['type']) else: abort( 400, 'Invalid request: type \'' + type + '\' is not a ' 'valid type') else: abort(400, 'Invalid request: required parameter type is missing') # TruthValue tv = ParseTruthValue.parse(data) # Outgoing set if 'outgoing' in data: if len(data['outgoing']) > 0: outgoing = [Handle(h) for h in data['outgoing']] else: outgoing = None # Name name = data['name'] if 'name' in data else None # Nodes must have names if is_a(type, types.Node): if name is None: abort( 400, 'Invalid request: node type specified and required ' 'parameter name is missing') # Links can't have names else: if name is not None: abort( 400, 'Invalid request: parameter name is not allowed for ' 'link types') try: atom = self.atomspace.add(t=type, name=name, tv=tv, out=outgoing) except TypeError: abort( 500, 'Error while processing your request. Check your ' 'parameters.') return {'atoms': marshal(atom, atom_fields)}
def testBinaryAddandRemove_NormalUnitBlock_AllGetFunctionWork(self): test_pos1 = (7, 8, 9) test_handle1 = Handle(100) self.testmap.add_solid_unit_block(test_handle1, test_pos1) test_handle2 = self.testmap.get_block(test_pos1) self.assertEqual(test_handle1, test_handle2) self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1)) self.testmap.remove_solid_unit_block(test_handle1) test_handle3 = self.testmap.get_block(test_pos1) self.assertTrue(test_handle3.is_undefined()) self.assertIsNone(self.testmap.get_block_location(test_handle1))
def handle_vision_message(self, data): print "handle_visiion_message" #TODO: In Minecraft the up/down direction is y coord # but we should swap y and z in ros node, not here.. for block in data.blocks: swap_y_and_z(block) map_handle, cur_map = self._get_map() for block in data.blocks: old_block_handle = cur_map.get_block((block.x, block.y, block.z)) updated_eval_links = [] if old_block_handle.is_undefined(): blocknode, updated_eval_links = self._build_block_nodes( block, map_handle) else: old_block_type_node = get_predicate( self._atomspace, "material", Atom(old_block_handle, self._atomspace), 1) old_block_type = self._atomspace.get_name( old_block_type_node.h) if old_block_type == str(block.blockid): continue elif block.blockid == 0: blocknode, updated_eval_links = Atom( Handle(-1), self._atomspace), [] else: blocknode, updated_eval_links = self._build_block_nodes( block, map_handle) #TODO: not sure if we should add disappeared predicate here, #It looks reasonable but make the code more messy.. disappeared_link = add_predicate( self._atomspace, "disappeared", Atom(old_block_handle, self._atomspace)) updated_eval_links.append(disappeared_link) self._space_server.add_map_info(blocknode.h, map_handle, False, False, block.ROStimestamp, block.x, block.y, block.z) if old_block_handle.is_undefined(): self._time_server.add_time_info(blocknode.h, block.ROStimestamp, "ROS") self._time_server.add_time_info(blocknode.h, block.MCtimestamp, "MC") for link in updated_eval_links: self._time_server.add_time_info(link.h, block.ROStimestamp, "ROS") self._time_server.add_time_info(link.h, block.MCtimestamp, "MC") #print blocknode #print updated_eval_links print "handle_vision_message end"
def test_container_methods(self): self.assertEquals(len(self.space), 0) h = Handle(100) self.assertRaises(KeyError, self.space.__getitem__, "blah") self.assertRaises(IndexError, self.space.__getitem__, h) a1 = self.space.add_node(types.Node, "test1") a2 = self.space.add_node(types.ConceptNode, "test2") a3 = self.space.add_node(types.PredicateNode, "test3") h1 = a1.h h2 = a2.h self.assertEquals(a1, self.space[h1]) self.assertTrue(h1 in self.space) self.assertTrue(a1 in self.space) self.assertTrue(h2 in self.space) self.assertEquals(len(self.space), 3)
def get(self, id): """ Returns the atom for the given handle Uri: atoms/[id] :param id: Atom handle :return atoms: Returns a JSON representation of an atom list containing the atom. Example: { 'atoms': { 'handle': 6, 'name': '', 'type': 'InheritanceLink', 'outgoing': [2, 1], 'incoming': [], 'truthvalue': { 'type': 'simple', 'details': { 'count': '0.4000000059604645', 'confidence': '0.0004997501382604241', 'strength': '0.5' } }, 'attentionvalue': { 'lti': 0, 'sti': 0, 'vlti': false } } } """ try: atom = self.atomspace[Handle(id)] except IndexError: abort(404, 'Handle not found') return {'atoms': marshal(atom, atom_fields)}
def __get_atoms_in_sti_range(self, focus_atoms, atom_type, least_count, sti_min, sti_max): all_atoms = self.a.get_atoms_by_av(sti_min, sti_max) all_atoms_h_set = set(map(lambda atom: atom.handle_uuid(), all_atoms)) focus_atoms_h_set = set( map(lambda atom: atom.handle_uuid(), focus_atoms)) atoms_h_set = all_atoms_h_set & focus_atoms_h_set if len(atoms_h_set) < least_count: self.last_status = blending_status.NOT_ENOUGH_ATOMS return self.ret = map(lambda atom_h: self.a[Handle(atom_h)], atoms_h_set) self.ret = filter(lambda atom: atom.is_a(atom_type), self.ret) if len(self.ret) < least_count: self.last_status = blending_status.NOT_ENOUGH_ATOMS return
def testSetBlock_AddBlockWithProbabilityControl_GetFunctionsWorkWithProb( self): test_pos1 = (7, 8, 9) test_handle1 = Handle(100) log_odds_threshold = self.testmap.get_occupancy_thres_log() self.testmap.set_unit_block(test_handle1, test_pos1, log_odds_threshold) self.assertEqual(test_handle1, self.testmap.get_block(test_pos1)) self.assertEqual(test_handle1, self.testmap.get_block(test_pos1, log_odds_threshold)) self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1)) self.assertEqual( test_pos1, self.testmap.get_block_location(test_handle1, log_odds_threshold)) self.assertEqual(log_odds_threshold, self.testmap.search(test_pos1).get_log_odds()) #change the occupancy so it's small enough to make getter find nothing self.testmap.set_unit_block(test_handle1, test_pos1, -0.1) self.assertTrue(self.testmap.get_block(test_pos1).is_undefined()) self.assertTrue( self.testmap.get_block(test_pos1, log_odds_threshold).is_undefined()) self.assertIsNone(self.testmap.get_block_location(test_handle1)) self.assertIsNone( self.testmap.get_block_location(test_handle1, log_odds_threshold)) #change the threshold, so the occupancy is large enough to find it self.testmap.set_occupancy_thres(-0.2) log_odds_threshold = self.testmap.get_occupancy_thres_log() self.assertEqual(test_handle1, self.testmap.get_block(test_pos1)) self.assertEqual(test_handle1, self.testmap.get_block(test_pos1, log_odds_threshold)) self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1)) self.assertEqual( test_pos1, self.testmap.get_block_location(test_handle1, log_odds_threshold))
def get_src_list(self, a): """Get a source node list in EqualLinkKey. It converts source node string to list of Atom. Args: a: An instance of AtomSpace to find Atom. :param a: AtomSpace Returns: The atoms that saved in EqualLink. :rtype : list[Atom] """ ret = [] src_node_h_int_list = self.src_h_list_str.split(', ') # Delete end of string src_node_h_int_list.pop() for src_node_h_int in src_node_h_int_list: ret.append(a[Handle(int(src_node_h_int))]) return ret
def get(self, id=""): """ Returns a list of atoms matching the specified criteria Uri: atoms/[id] (or) atoms?type=[type]&name=[name]&filterby=[filterby] &tvStrengthMin=[tvStrengthMin]&tvConfidenceMin=[tvConfidenceMin] &tvCountMin=[tvCountMin]&includeIncoming=[includeIncoming] &includeOutgoing=[includeOutgoing]&callback=[callback] :param id: (optional, int, to specifically request an atom by handle, can be combined with includeIncoming or includeOutgoing only; if specified, other query parameters will have no effect) Atom handle :param type: (optional) Atom type, see http://wiki.opencog.org/w/OpenCog_Atom_types :param name: (optional, string, not allowed for Link types) Atom name If neither type or name are provided, all atoms will be retrieved :param filterby: (optional, can't be combined with type or name) Allows certain predefined filters - The filter 'stirange' allows the additional parameters 'stimin' (required, int) and 'stimax' (optional, int) and returns the atoms in a given STI range - The filter 'attentionalfocus' (boolean) returns the atoms in the AttentionalFocus :param tvStrengthMin: (optional, float) Only return atoms with TruthValue strength greater than this amount :param tvConfidenceMin: (optional, float) Only return atoms with TruthValue confidence greater than this amount :param tvCountMin: (optional, float) Only return atoms with TruthValue count greater than this amount :param includeIncoming: (optional, boolean) Returns the conjunction of the set of atoms and their incoming sets :param includeOutgoing: (optional, boolean) Returns the conjunction of the set of atoms and their outgoing sets. Useful in combination with includeIncoming. :param dot: (optional, boolean) Returns the atom set represented in the DOT graph description language (See opencog/python/graph_description/README.md for details) :param callback: (optional) JavaScript callback function for JSONP support :return result: Returns a JSON representation of an atom list. Example: { 'result': { 'complete': 'true', 'skipped': 'false', 'total': 10, 'atoms': [ { 'handle': 6, 'name': '', 'type': 'InheritanceLink', 'outgoing': [2, 1], 'incoming': [], 'truthvalue': { 'type': 'simple', 'details': { 'count': '0.4000000059604645', 'confidence': '0.0004997501382604241', 'strength': '0.5' } } 'attentionvalue': { 'lti': 0, 'sti': 0, 'vlti': false } }, ... ] } } """ args = self.reqparse.parse_args() type = args.get('type') name = args.get('name') callback = args.get('callback') filter_by = args.get('filterby') sti_min = args.get('stimin') sti_max = args.get('stimax') tv_strength_min = args.get('tvStrengthMin') tv_confidence_min = args.get('tvConfidenceMin') tv_count_min = args.get('tvCountMin') include_incoming = args.get('includeIncoming') include_outgoing = args.get('includeOutgoing') dot_format = args.get('dot') if id != "": try: atom = self.atomspace[Handle(id)] atoms = [atom] except IndexError: atoms = [] # abort(404, 'Handle not found') else: # First, check if there is a valid filter type, and give it # precedence if it exists valid_filter = False if filter_by is not None: if filter_by == 'stirange': if sti_min is not None: valid_filter = True atoms = self.atomspace.get_atoms_by_av( sti_min, sti_max) else: abort( 400, 'Invalid request: stirange filter requires ' 'stimin parameter') elif filter_by == 'attentionalfocus': valid_filter = True atoms = self.atomspace.get_atoms_in_attentional_focus() # If there is not a valid filter type, proceed to select by type # or name if not valid_filter: if type is None and name is None: atoms = self.atomspace.get_atoms_by_type(types.Atom) elif name is None: atoms = self.atomspace.get_atoms_by_type( types.__dict__.get(type)) else: if type is None: type = 'Node' atoms = self.atomspace.get_atoms_by_name( t=types.__dict__.get(type), name=name) # Optionally, filter by TruthValue if tv_strength_min is not None: atoms = [ atom for atom in atoms if atom.tv.mean >= tv_strength_min ] if tv_confidence_min is not None: atoms = [ atom for atom in atoms if atom.tv.confidence >= tv_confidence_min ] if tv_count_min is not None: atoms = [ atom for atom in atoms if atom.tv.count >= tv_count_min ] # Optionally, include the incoming set if include_incoming in ['True', 'true', '1']: atoms = self.atomspace.include_incoming(atoms) # Optionally, include the outgoing set if include_outgoing in ['True', 'true', '1']: atoms = self.atomspace.include_outgoing(atoms) # The default is to return the atom set as JSON atoms. Optionally, a # DOT return format is also supported if dot_format not in ['True', 'true', '1']: atom_list = AtomListResponse(atoms) json_data = {'result': atom_list.format()} # if callback function supplied, pad the JSON data (i.e. JSONP): if callback is not None: response = str(callback) + '(' + json.dumps(json_data) + ');' return current_app.response_class( response, mimetype='application/javascript') else: return current_app.response_class(json.dumps(json_data), mimetype='application/json') else: dot_output = dot.get_dot_representation(atoms) return jsonify({'result': dot_output})
def post(self): """ Creates a new atom. If the atom already exists, it updates the atom. Uri: atoms Include data with the POST request providing a JSON representation of the atom. Valid data elements: type (required) Atom type, see http://wiki.opencog.org/w/OpenCog_Atom_types name (required for Node types, not allowed for Link types) Atom name truthvalue (required) TruthValue, formatted as follows: type (required) TruthValue type (only 'simple' is currently available), see http://wiki.opencog.org/w/TruthValue details (required) TruthValue parameters, formatted as follows: strength (required) count (required) outgoing (optional) The set of arguments of the relation, formatted as a list of Atom handles (only valid for Links, not nodes), see http://wiki.opencog.org/w/Link#Incoming_and_Outgoing_Sets Examples: Node: { 'type': 'ConceptNode', 'name': 'Frog', 'truthvalue': { 'type': 'simple', 'details': { 'strength': 0.8, 'count': 0.2 } } } Link: { 'type': 'InheritanceLink', 'outgoing': [1, 2], 'truthvalue': { 'type': 'simple', 'details': { 'strength': 0.5, 'count': 0.4 } } } :return atoms: Returns a JSON representation of an atom list containing the atom. Example: { 'atoms': { 'handle': 6, 'name': '', 'type': 'InheritanceLink', 'outgoing': [2, 1], 'incoming': [], 'truthvalue': { 'type': 'simple', 'details': { 'count': '0.4000000059604645', 'confidence': '0.0004997501382604241', 'strength': '0.5' } }, 'attentionvalue': { 'lti': 0, 'sti': 0, 'vlti': false } } } """ # Prepare the atom data and validate it data = reqparse.request.get_json() if 'type' in data: if data['type'] in types.__dict__: type = types.__dict__.get(data['type']) else: abort( 400, 'Invalid request: type \'' + type + '\' is not a ' 'valid type') else: abort(400, 'Invalid request: required parameter type is missing') # TruthValue tv = ParseTruthValue.parse(data) # Outgoing set if 'outgoing' in data: if len(data['outgoing']) > 0: outgoing = [Handle(h) for h in data['outgoing']] else: outgoing = None # Name name = data['name'] if 'name' in data else None # Nodes must have names if is_a(type, types.Node): if name is None: abort( 400, 'Invalid request: node type specified and required ' 'parameter name is missing') # Links can't have names else: if name is not None: abort( 400, 'Invalid request: parameter name is not allowed for ' 'link types') try: atom = self.atomspace.add(t=type, name=name, tv=tv, out=outgoing) except TypeError: abort( 500, 'Error while processing your request. Check your ' 'parameters.') return {'atoms': marshal(atom, atom_fields)}
def run_pln_example(a, f): a.clear() testdir = '../tests/reasoning/pln/targets/' datadirs = ['../tests/reasoning/pln/scm/', '../opencog/'] fname = testdir + f config = ConfigParser.ConfigParser() read_files = config.read(fname) if not read_files: raise Exception("no such file:", fname) def get(field): return config.get('PLN_TEST', field) print f def load_axioms(fname): for d in datadirs: kf = d + fname + '.scm' try: tmp = open(kf, 'r') scheme_wrapper.load_scm(a, kf) print kf return except IOError: continue raise IOError("missing data file: " + kf) data_files = get('load').replace(' ', '').split(',') for fname in data_files: load_axioms(fname) scm_target = '(cog-handle %s)' % (get('target'), ) print scm_target handle_str = scheme_wrapper.scheme_eval(scm_target) try: h = int(handle_str) except ValueError: print handle_str raise Exception("Scheme error in target") nsteps = int(get('max_steps')) target = Atom(Handle(h), a) print target import logic import tree # hack - won't work if the Scheme target is some variable that doesn't contain "Demand" if "Demand" in scm_target: # superhack - doesn't care which target you say target_tr = tree.tree_from_atom(target) res = logic.do_planning(a, target_tr) else: c = logic.Chainer(a) target_tr = tree.tree_from_atom(target) res = c.bc(target_tr, nsteps) if len(res): print 'PASSED' passed.append(f) else: print 'FAILED' failed.append(f)
def handle_vision_message(self, data): # print "handle_visiion_message" # TODO: In Minecraft the up/down direction is y coord # but we should swap y and z in ros node, not here.. for block in data.blocks: swap_y_and_z(block) material_dict = {} map_handle, cur_map = self._get_map() for block in data.blocks: old_block_handle = cur_map.get_block((block.x, block.y, block.z)) updated_eval_links = [] # Count how many of each block type we have seen during this vision frame. # Also store the new block material in case it differs from the existing material. # TODO: Use this dict for something or it can be removed, currently # it is created and filled up but not used by anything else. block_material = blocks.get_block(block.blockid, block.metadata).display_name if block_material in material_dict: material_dict[block_material] += 1 else: material_dict[block_material] = 1 # If this is the first time this block has been seen if old_block_handle.is_undefined(): # Create the block in atomspace and set its initial attention # value. blocknode, updated_eval_links = self._build_block_nodes( block, map_handle) # TODO: Make the 200 a constant, this occurs one other place. self._atomspace.set_av(blocknode.h, 200) else: # Block already exists, check to see if it is still the same # type. old_block_type_node = get_predicate( self._atomspace, "material", Atom(old_block_handle, self._atomspace), 1) old_block_type = self._atomspace.get_name( old_block_type_node.h) if old_block_type == block_material: # Add short term importance to this block since it is in # the field of view. cur_sti = self._atomspace.get_av(old_block_handle)['sti'] # TODO: Make these numbers constants. # TODO: Make the amount added be dependendant on the # distance to the block. cur_sti = min(cur_sti + 20, 500) self._atomspace.set_av(old_block_handle, cur_sti) continue elif block.blockid == 0: # Block used to be solid and is now an air block, remove it # from the atomspace and mark the old block as being # disappeared for attention allocation routine to look at. blocknode, updated_eval_links = Atom( Handle(-1), self._atomspace), [] disappeared_link = add_predicate( self._atomspace, "disappeared", Atom(old_block_handle, self._atomspace)) updated_eval_links.append(disappeared_link) else: # NOTE: There is a bit of a bug here since the attention # value does not increase here, but that is ok because this # is rare anyway so skipping an increase is no big deal. blocknode, updated_eval_links = self._build_block_nodes( block, map_handle) disappeared_link = add_predicate( self._atomspace, "disappeared", Atom(old_block_handle, self._atomspace)) updated_eval_links.append(disappeared_link) # Add the block to the spaceserver and the timeserver. self._space_server.add_map_info(blocknode.h, map_handle, False, False, block.ROStimestamp, block.x, block.y, block.z) if old_block_handle.is_undefined(): self._time_server.add_time_info(blocknode.h, block.ROStimestamp, "ROS") self._time_server.add_time_info(blocknode.h, block.MCtimestamp, "MC") for link in updated_eval_links: self._time_server.add_time_info(link.h, block.ROStimestamp, "ROS") self._time_server.add_time_info(link.h, block.MCtimestamp, "MC") # print blocknode # print updated_eval_links # TODO: The code below stores the number of blocks of each type seen in # the current field of view into the atomspace. It is commented out as # it should probably not store this until the code to erase old values # is also added otherwise this data just piles up as new links from the # same root node and it becomes a jumbled mess. # print "\nBlock material summary: saw %s kinds of blocks" % # len(material_dict) """
def put(self, id): """ Updates the AttentionValue (STI, LTI, VLTI) or TruthValue of an atom Uri: atoms/[id] :param id: Atom handle Include data with the PUT request providing a JSON representation of the updated attributes. Valid data elements: truthvalue (optional) TruthValue, formatted as follows: type (required) TruthValue type (only 'simple' is currently available) see http://wiki.opencog.org/w/TruthValue details (required) TruthValue parameters, formatted as follows: strength (required) count (required) attentionvalue (optional) AttentionValue, formatted as follows: sti (optional) Short-Term Importance lti (optional) Long-Term Importance vlti (optional) Very-Long Term Importance Example: { 'truthvalue': { 'type': 'simple', 'details': { 'strength': 0.005, 'count': 0.8 } }, 'attentionvalue': { 'sti': 9, 'lti': 2, 'vlti': True } } :return atoms: Returns a JSON representation of an atom list containing the atom. Example: { 'atoms': { 'handle': 6, 'name': '', 'type': 'InheritanceLink', 'outgoing': [2, 1], 'incoming': [], 'truthvalue': { 'type': 'simple', 'details': { 'count': '0.4000000059604645', 'confidence': '0.0004997501382604241', 'strength': '0.5' } }, 'attentionvalue': { 'lti': 0, 'sti': 0, 'vlti': false } } } } """ if Handle(id) not in self.atomspace: abort(404, 'Handle not found') # Prepare the atom data data = reqparse.request.get_json() if 'truthvalue' not in data and 'attentionvalue' not in data: abort( 400, 'Invalid request: you must include a truthvalue or attentionvalue parameter' ) if 'truthvalue' in data: tv = ParseTruthValue.parse(data) self.atomspace.set_tv(h=Handle(id), tv=tv) if 'attentionvalue' in data: (sti, lti, vlti) = ParseAttentionValue.parse(data) self.atomspace.set_av(h=Handle(id), sti=sti, lti=lti, vlti=vlti) atom = self.atomspace[Handle(id)] return {'atoms': marshal(atom, atom_fields)}
def _get(self, id=""): """ Returns a list of atoms matching the specified criteria """ args = self.reqparse.parse_args() type = args.get('type') name = args.get('name') callback = args.get('callback') filter_by = args.get('filterby') sti_min = args.get('stimin') sti_max = args.get('stimax') tv_strength_min = args.get('tvStrengthMin') tv_confidence_min = args.get('tvConfidenceMin') tv_count_min = args.get('tvCountMin') include_incoming = args.get('includeIncoming') include_outgoing = args.get('includeOutgoing') dot_format = args.get('dot') limit = args.get('limit') if id != "": try: atom = self.atomspace[Handle(id)] atoms = [atom] except IndexError: atoms = [] # abort(404, 'Handle not found') else: # First, check if there is a valid filter type, and give it # precedence if it exists valid_filter = False if filter_by is not None: if filter_by == 'stirange': if sti_min is not None: valid_filter = True atoms = self.atomspace.get_atoms_by_av( sti_min, sti_max) else: abort( 400, 'Invalid request: stirange filter requires ' 'stimin parameter') elif filter_by == 'attentionalfocus': valid_filter = True atoms = self.atomspace.get_atoms_in_attentional_focus() # If there is not a valid filter type, proceed to select by type # or name if not valid_filter: if type is None and name is None: atoms = self.atomspace.get_atoms_by_type(types.Atom) elif name is None: atoms = self.atomspace.get_atoms_by_type( types.__dict__.get(type)) else: if type is None: type = 'Node' atoms = self.atomspace.get_atoms_by_name( t=types.__dict__.get(type), name=name) # Optionally, filter by TruthValue if tv_strength_min is not None: atoms = [ atom for atom in atoms if atom.tv.mean >= tv_strength_min ] if tv_confidence_min is not None: atoms = [ atom for atom in atoms if atom.tv.confidence >= tv_confidence_min ] if tv_count_min is not None: atoms = [ atom for atom in atoms if atom.tv.count >= tv_count_min ] # Optionally, include the incoming set if include_incoming in ['True', 'true', '1']: atoms = self.atomspace.include_incoming(atoms) # Optionally, include the outgoing set if include_outgoing in ['True', 'true', '1']: atoms = self.atomspace.include_outgoing(atoms) # Optionally, limit number of atoms returned if limit is not None: if len(atoms) > limit: atoms = atoms[0:limit] # The default is to return the atom set as JSON atoms. Optionally, a # DOT return format is also supported if dot_format not in ['True', 'true', '1']: atom_list = AtomListResponse(atoms) json_data = {'result': atom_list.format()} # if callback function supplied, pad the JSON data (i.e. JSONP): if callback is not None: response = str(callback) + '(' + json.dumps(json_data) + ');' return current_app.response_class( response, mimetype='application/javascript') else: return current_app.response_class(json.dumps(json_data), mimetype='application/json') else: dot_output = dot.get_dot_representation(atoms) return jsonify({'result': dot_output})