def __init__(self, data=None, **attr): # the init could be # graph = Graph(g) where g is a Graph # graph = Graph((v,e)) where v is Graph.v like and e is Graph.e like # graph = Graph(({},e)) for an edgelist with no specified nodes # others with classmethods like # Graph.from_adjacency_matrix(m) # Graph.from_adjacency_list(l) # # should abstract the data here self._nodedata = {} # empty node attribute dict self._adjacency = {} # empty adjacency dict # the interface is n,e,a,data self.n = Nodes(self._nodedata, self._adjacency) # rename to self.nodes self.e = Edges(self._nodedata, self._adjacency) # rename to self.edges self.a = Adjacency(self._adjacency) # rename to self.adjacency self.data = {} # dictionary for graph attributes # load with data if hasattr(data,'n') and not hasattr(data,'name'): # it is a new graph self.n.update(data.n) self.e.update(data.e) self.data.update(data.data) data = None try: nodes,edges = data # containers of edges and nodes self.n.update(nodes) self.e.update(edges) except: # old style if data is not None: convert.to_networkx_graph(data, create_using=self) # load __init__ graph attribute keywords self.data.update(attr)
class Scene: def __init__(self): self.reset(gen_uuid()) def update(self, nodes): current_time = rospy.Time.now() for node in nodes: node.last_update.data = current_time if node.parent not in self.__nodes: node.parent = self.root_id() self.__nodes.update(nodes) return [n.id for n in nodes if n.name != "root"] def remove(self, ids): self.__nodes.remove(ids) return ids def root_id(self): return self.__root_id def nodes(self): return self.__nodes def reset(self, root_id): self.__root_id = root_id if not hasattr(self, '__nodes'): node_ids = [] self.__nodes = Nodes() else: node_ids = self.__nodes.ids() self.__nodes.reset() root = Node(id=self.__root_id, name="root") root.position.pose.orientation.w = 1.0 self.__nodes.update([root]) return node_ids
def test_remove_table(self): nodes = Nodes() nodes.tables.append({"BBBBBBBB": {"BBBBBBBB": 1}}) EXPECTED = [{"nodeself": {"nodeself": 0}}] ARG1 = "BBBBBBBB" nodes.remove_table(ARG1) actual = nodes.tables self.assertEqual(EXPECTED, actual)
def NodeInitialization (x_rob,x_ped,weight,theta,p1_goal,p2_goal,v): gScore_ = [0,0] gScore = np.dot(gScore_,weight) initial_node = Nodes() initial_node.parent = 0 initial_node.
def test_add_table_byte(self): nodes = Nodes() EXPECTED = [{"nodeself": {"nodeself": 0}}, {"BBBBBBBB": {"BBBBBBBB": 1}}] ARG1 = bytearray("\x42\x42\x42\x42\x42\x42\x42\x42\x30\x30") ARG2 = 1 nodes.add_table_byte(ARG1, ARG2) actual = nodes.tables self.assertEqual(EXPECTED, actual)
def reset(self, root_id): self.__root_id = root_id if not hasattr(self, '__nodes'): node_ids = [] self.__nodes = Nodes() else: node_ids = self.__nodes.ids() self.__nodes.reset() root = Node(id=self.__root_id, name="root") root.position.pose.orientation.w = 1.0 self.__nodes.update([root]) return node_ids
def test_get_nearest_neighbor(self): nodes = Nodes() TABLES = [{"BBBBBBBB": {"BBBBBBBB": 1, "CCCCCCCC": 4, "DDDDDDDD": 2, "EEEEEEEE": 3}}, {"CCCCCCCC": {"BBBBBBBB": 4, "CCCCCCCC": 1, "DDDDDDDD": 3, "EEEEEEEE": 2}}] TARGET = "EEEEEEEE" nodes.tables.extend(TABLES) EXPECTED = "CCCCCCCC" actual = nodes.get_nearest_neighbor(TARGET) self.assertEqual(EXPECTED, actual)
def __init__(self, name=None): self.log_color = 'red' self.name = name or random_string(8) self.events = Events() events.e = self.events self.nodes = Nodes() self.register = Register(machine=self, events=self.events)
def logout(): body = request.get_json() res = Nodes().remove_node(body['username'], body['password']) if type(res) is dict: return jsonify(res['message']), res['code'] else: return res["message"], res['code']
def __init__(self, parent=None): QtWidgets.QDialog.__init__(self, parent, QtCore.Qt.WindowStaysOnTopHint) self._cfg = Config.get() self._nodes = Nodes.instance() self._db = Database.instance() self._notification_callback.connect(self._cb_notification_callback) self._notifications_sent = {} self.setupUi(self) self.dbFileButton.setVisible(False) self.dbLabel.setVisible(False) self.acceptButton.clicked.connect(self._cb_accept_button_clicked) self.applyButton.clicked.connect(self._cb_apply_button_clicked) self.cancelButton.clicked.connect(self._cb_cancel_button_clicked) self.popupsCheck.clicked.connect(self._cb_popups_check_toggled) self.dbFileButton.clicked.connect(self._cb_file_db_clicked) if QtGui.QIcon.hasThemeIcon("emblem-default") == False: self.applyButton.setIcon(self.style().standardIcon( getattr(QtWidgets.QStyle, "SP_DialogApplyButton"))) self.cancelButton.setIcon(self.style().standardIcon( getattr(QtWidgets.QStyle, "SP_DialogCloseButton"))) self.acceptButton.setIcon(self.style().standardIcon( getattr(QtWidgets.QStyle, "SP_DialogSaveButton"))) self.dbFileButton.setIcon(self.style().standardIcon( getattr(QtWidgets.QStyle, "SP_DirOpenIcon")))
def __init__(self, data=None, **attr): # the init could be # graph = Graph(g) where g is a Graph # graph = Graph((v,e)) where v is Graph.v like and e is Graph.e like # graph = Graph(({},e)) for an edgelist with no specified nodes # others with classmethods like # Graph.from_adjacency_matrix(m) # Graph.from_adjacency_list(l) # # should abstract the data here self._nodedata = {} # empty node attribute dict self._adjacency = {} # empty adjacency dict # the interface is n,e,a,data self.n = Nodes(self._nodedata, self._adjacency) # rename to self.nodes self.e = Edges(self._nodedata, self._adjacency) # rename to self.edges self.a = Adjacency(self._adjacency) # rename to self.adjacency self.data = {} # dictionary for graph attributes # load with data if hasattr(data, "n") and not hasattr(data, "name"): # it is a new graph self.n.update(data.n) self.e.update(data.e) self.data.update(data.data) data = None try: nodes, edges = data # containers of edges and nodes self.n.update(nodes) self.e.update(edges) except: # old style if data is not None: convert.to_networkx_graph(data, create_using=self) # load __init__ graph attribute keywords self.data.update(attr)
def run_route_planner(): """Runs the whole program.""" # Initialize global settings and screen. settings = Settings() pygame.init() screen = pygame.display.set_mode( (settings.screen_width, settings.screen_height)) pygame.display.set_caption("Route Planner 1.1") # Make a next button. next_button = Button(settings, screen, "Next") # Hard coded map. world = World(settings.map_width, settings.map_height) """world.matrix = [["601000", "100100", "100010", "100001", "100000", "100000"], ["100000", "100000", "100100", "100000", "100000", "100000"], ["100000", "100000", "100000", "100000", "100000", "100000"], ["100000", "100000", "100000", "100000", "100000", "100000"], ["100000", "100000", "100000", "100000", "100000", "100000"], ["100000", "100000", "100000", "100000", "100000", "100000"]]""" world.matrix = [["601000", "500100", "310010", "610001", "600000", "610000"], ["530000", "400000", "310000", "510000", "530000", "100000"], ["100000", "100000", "100000", "530000", "620000", "100000"], ["100000", "100000", "100000", "100000", "100000", "100000"], ["100000", "100000", "100000", "100000", "100000", "100000"], ["100000", "100000", "100000", "100000", "100000", "100000"]] # Create nodes for the world matrix. nodes = Nodes(world.matrix) # Make a new robot instance. robot = Robot() # Init and subscribe to mqtt broker. mqtt = Mqtt(settings.broker, settings.get_client_id(), settings.username, settings.password, settings.topic) buttons = [] # Print out nodes to check if algoritm is correct. """ for node in nodes.nodes_dict: print(node + " : ", nodes.nodes_dict[node]) """ while True: # main loop rf.update_map(world.matrix, nodes, mqtt.msgs, robot) rf.check_events(settings, robot, buttons, next_button, mqtt) rf.update_robot_route(world.matrix, nodes.nodes_dict, robot) buttons = rf.update_screen(screen, settings, world.matrix, nodes, next_button, robot) """for node in nodes.nodes_dict: print(node + " : ", nodes.nodes_dict[node])""" # if no more tasks are left, the mission is complete. if len(robot.goals) == 0: print("Mission Complete!") mqtt.client.loop_stop() mqtt.client.disconnect() break
def setUp(self): self.Graph = nxGraph # build dict-of-dict-of-dict K3 ed1, ed2, ed3 = ({}, {}, {}) self.k3adj = { 0: { 1: ed1, 2: ed2 }, 1: { 0: ed1, 2: ed3 }, 2: { 0: ed2, 1: ed3 } } self.k3edges = [(0, 1), (0, 2), (1, 2)] self.k3nodes = [0, 1, 2] self.K3 = self.Graph() self.K3.adj = self.K3._adjacency = self.K3.edge = self.k3adj self.K3.node = self.K3._nodedata = {} self.K3.node[0] = {} self.K3.node[1] = {} self.K3.node[2] = {} self.K3.n = Nodes(self.K3._nodedata, self.K3._adjacency) self.K3.e = Edges(self.K3._nodedata, self.K3._adjacency) self.K3.a = Adjacency(self.K3._adjacency)
def test_get_full_table_byte(self): nodes = Nodes() TABLES = [{"BBBBBBBB": {"BBBBBBBB": 1, "CCCCCCCC": 4, "DDDDDDDD": 2, "EEEEEEEE": 3}}, {"CCCCCCCC": {"BBBBBBBB": 4, "CCCCCCCC": 1, "DDDDDDDD": 3, "EEEEEEEE": 2}}] nodes.tables.extend(TABLES) EXPECTED = b"\x42\x42\x42\x42\x42\x42\x42\x42\x30\x31" EXPECTED += b"\x43\x43\x43\x43\x43\x43\x43\x43\x30\x31" EXPECTED += b"\x44\x44\x44\x44\x44\x44\x44\x44\x30\x32" EXPECTED += b"\x45\x45\x45\x45\x45\x45\x45\x45\x30\x32" actual = nodes.get_full_table_byte() self.assertEqual(EXPECTED, actual)
def test_get_full_table(self): nodes = Nodes() TABLES = [{"BBBBBBBB": {"BBBBBBBB": 1, "CCCCCCCC": 4, "DDDDDDDD": 2, "EEEEEEEE": 3}}, {"CCCCCCCC": {"BBBBBBBB": 4, "CCCCCCCC": 1, "DDDDDDDD": 3, "EEEEEEEE": 2}}] nodes.tables.extend(TABLES) EXPECTED = {"BBBBBBBB": 1, "CCCCCCCC": 1, "DDDDDDDD": 2, "EEEEEEEE": 2} actual = nodes.get_full_table() self.assertEqual(EXPECTED, actual)
def start(self): logging.info('Start') self.nodes = Nodes() self.worker_q = queue.Queue() self.worker = threading.Thread(target=node_worker, args=(self, self._addr, 'slave', self.worker_q)) self.worker.daemon = True self._syncObjConf = SyncObjConf( onReady=lambda: self._onReady(), onStateChanged=lambda os, ns: self._stateChanged(os, ns)) self._syncObj = SyncObj( f'{self._addr}:{self._raft_port}', [f'{p}:{self._raft_port}' for p in self._peers], consumers=[self.logs, self.nodes], conf=self._syncObjConf)
def parse(filename): """ Parse a OSM file """ with open(filename, "rb") as osm: # Find element # http://stackoverflow.com/questions/222375/elementtree-xpath-select-element-based-on-attribute tree = ET.parse(osm) nodes_tree = tree.findall(".//node") ways_tree = tree.findall(".//way") bounds_elem = tree.find(".//bounds") bounds = [bounds_elem.get("minlat"), bounds_elem.get("minlon"), bounds_elem.get("maxlat"), bounds_elem.get("maxlon")] # Parse nodes and ways. Only read the ways that have the tags specified in valid_highways streets = Streets() street_nodes = Nodes() street_network = OSM(street_nodes, streets, bounds) for node in nodes_tree: mynode = Node(node.get("id"), node.get("lat"), node.get("lon")) street_network.add_node(mynode) valid_highways = {'primary', 'secondary', 'tertiary', 'residential'} for way in ways_tree: highway_tag = way.find(".//tag[@k='highway']") oneway_tag = way.find(".//tag[@k='oneway']") ref_tag = way.find(".//tag[@k='ref']") if highway_tag is not None and highway_tag.get("v") in valid_highways: node_elements = filter(lambda elem: elem.tag == "nd", list(way)) nids = [node.get("ref") for node in node_elements] # Sort the nodes by longitude. if street_nodes.get(nids[0]).lng > street_nodes.get(nids[-1]).lng: nids = nids[::-1] street = Street(way.get("id"), nids) if oneway_tag is not None: street.set_oneway_tag('yes') else: street.set_oneway_tag('no') street.set_ref_tag(ref_tag) street_network.add_way(street) return street_network
def __init__(self, graph, subnodes): # TODO Can we replace nbunch_iter with set(subnodes) & set(graph)? # We lose the Error messages... self._subnodes = set(self._nbunch_iter(graph, subnodes)) self._nodedata = SubNbrDict(self._subnodes, graph._nodedata) self._adjacency = SubAdjacency(self._subnodes, graph._adjacency) self.data = graph.data self.n = Nodes(self._nodedata, self._adjacency) self.e = Edges(self._nodedata, self._adjacency) self.a = self._adjacency
def init_nodes(locations): nodes = [] for i in range(lnt): nodes.append(Nodes(locations[i][0], locations[i][1], i, lnt)) for i in range(lnt): current_node = nodes[i] print("node", str(i), "'s distance sort started") for j in range(lnt): dst_sqr_x = (current_node.x - nodes[j].x) * (current_node.x - nodes[j].x) dst_sqr_y = (current_node.y - nodes[j].y) * (current_node.y - nodes[j].y) dst = sqrt(dst_sqr_x + dst_sqr_y) nodes[i].fill_distance(int(round(dst)), j) return nodes
def __init__(self, system_settings, websocket, snmp_websocket, **kwargs): super(SleepyMeshBase, self).__init__(**kwargs) if 'last_syncs' not in self._defaults: self._defaults.update({'last_syncs': list()}) # Internal Members # self._mesh_awake = True self._sync_type = 'timeout' self._save_in_progress = False self._sync_average = None self._delay_average = None # Instances # # TODO: Eliminate as many dependencies as possible self.system_settings = system_settings self.websocket = websocket self.snmp_websocket = snmp_websocket self.modbus_server = ModbusServer() self.snmp_server = SNMPTrapServer(self) self.update_interfaces = UpdateInterfaces(self) self.update_in_progress = self.update_interfaces.update_in_progress self.bridge = Bridge(self.system_settings) self.uploader = Uploader(self) self.nodes = Nodes(self.system_settings) self.platforms = Platforms(self.nodes) self.networks = Networks(self) self.error = BaseError(self.system_settings) if self.system_settings.modbus_enable: system_settings_dict = self.system_settings.attr_dict() # LOGGER.debug('Modbus Attribute Dictionary: ' + str(system_settings_dict)) self.modbus_server.start(system_settings_dict) if self.system_settings.snmp_enable: self.snmp_server.start() # Overload Node Error Methods (SNMP Error Methods)# NodeError.send_snmp = self.snmp_server.send_snmp NodeError.clear_snmp = self.snmp_server.clear_snmp
def __init__(self, parent=None, _rule=None): super(RulesEditorDialog, self).__init__(parent) QtWidgets.QDialog.__init__(self, parent, QtCore.Qt.WindowStaysOnTopHint) self._notifications_sent = {} self._nodes = Nodes.instance() self._db = Database.instance() self._notification_callback.connect(self._cb_notification_callback) self._old_rule_name = None self.setupUi(self) self.buttonBox.button( QtWidgets.QDialogButtonBox.Reset).clicked.connect( self._cb_reset_clicked) self.buttonBox.button( QtWidgets.QDialogButtonBox.Close).clicked.connect( self._cb_close_clicked) self.buttonBox.button( QtWidgets.QDialogButtonBox.Apply).clicked.connect( self._cb_apply_clicked) self.buttonBox.button(QtWidgets.QDialogButtonBox.Help).clicked.connect( self._cb_help_clicked) self.selectListButton.clicked.connect( self._cb_select_list_button_clicked) self.protoCheck.toggled.connect(self._cb_proto_check_toggled) self.procCheck.toggled.connect(self._cb_proc_check_toggled) self.cmdlineCheck.toggled.connect(self._cb_cmdline_check_toggled) self.dstPortCheck.toggled.connect(self._cb_dstport_check_toggled) self.uidCheck.toggled.connect(self._cb_uid_check_toggled) self.dstIPCheck.toggled.connect(self._cb_dstip_check_toggled) self.dstHostCheck.toggled.connect(self._cb_dsthost_check_toggled) self.dstListsCheck.toggled.connect(self._cb_dstlists_check_toggled) if QtGui.QIcon.hasThemeIcon("emblem-default") == False: self.actionAllowRadio.setIcon(self.style().standardIcon( getattr(QtWidgets.QStyle, "SP_DialogApplyButton"))) self.actionDenyRadio.setIcon(self.style().standardIcon( getattr(QtWidgets.QStyle, "SP_DialogCancelButton"))) if _rule != None: self._load_rule(rule=_rule)
def __init__(self, app, on_exit): super(UIService, self).__init__() self._cfg = Config.init() self._db = Database.instance() self._db.initialize( dbfile=self._cfg.getSettings(self._cfg.DEFAULT_DB_FILE_KEY) ) self._db_sqlite = self._db.get_db() self._last_ping = None self._version_warning_shown = False self._asking = False self._connected = False self._path = os.path.abspath(os.path.dirname(__file__)) self._app = app self._on_exit = on_exit self._exit = False self._msg = QtWidgets.QMessageBox() self._prompt_dialog = PromptDialog() self._stats_dialog = StatsDialog(dbname="general", db=self._db) self._remote_lock = Lock() self._remote_stats = {} self._setup_interfaces() self._setup_slots() self._setup_icons() self._setup_tray() self.check_thread = Thread(target=self._async_worker) self.check_thread.daemon = True self.check_thread.start() self._nodes = Nodes.instance() self._last_stats = {} self._last_items = { 'hosts':{}, 'procs':{}, 'addrs':{}, 'ports':{}, 'users':{} }
def __init__(self, parent=None): super(ProcessDetailsDialog, self).__init__(parent) QtWidgets.QDialog.__init__(self, parent, QtCore.Qt.WindowStaysOnTopHint) self.setWindowFlags(QtCore.Qt.Window) self.setupUi(self) self._app_name = None self._app_icon = None self._apps_parser = LinuxDesktopParser() self._nodes = Nodes.instance() self._notification_callback.connect(self._cb_notification_callback) self._nid = None self._pid = "" self._notifications_sent = {} self.cmdClose.clicked.connect(self._cb_close_clicked) self.cmdAction.clicked.connect(self._cb_action_clicked) self.comboPids.currentIndexChanged.connect(self._cb_combo_pids_changed) self.TABS[self.TAB_STATUS]['text'] = self.textStatus self.TABS[self.TAB_DESCRIPTORS]['text'] = self.textOpenedFiles self.TABS[self.TAB_IOSTATS]['text'] = self.textIOStats self.TABS[self.TAB_MAPS]['text'] = self.textMappedFiles self.TABS[self.TAB_STACK]['text'] = self.textStack self.TABS[self.TAB_ENVS]['text'] = self.textEnv self.TABS[self.TAB_DESCRIPTORS]['text'].setFont( QtGui.QFont("monospace")) self.iconStart = QtGui.QIcon.fromTheme("media-playback-start") self.iconPause = QtGui.QIcon.fromTheme("media-playback-pause") if QtGui.QIcon.hasThemeIcon("window-close") == False: self.cmdClose.setIcon(self.style().standardIcon( getattr(QtWidgets.QStyle, "SP_DialogCloseButton"))) self.iconStart = self.style().standardIcon( getattr(QtWidgets.QStyle, "SP_MediaPlay")) self.iconPause = self.style().standardIcon( getattr(QtWidgets.QStyle, "SP_MediaPause"))
def make_sidewalks(street_network): # Go through each street and create sidewalks on both sides of the road. sidewalks = Sidewalks() sidewalk_nodes = Nodes() sidewalk_network = OSM(sidewalk_nodes, sidewalks, street_network.bounds) for street in street_network.ways.get_list(): sidewalk_1_nodes = [] sidewalk_2_nodes = [] # Create sidewalk nodes for prev_nid, curr_nid, next_nid in window(street.nids, 3, padding=1): curr_node = street_network.nodes.get(curr_nid) prev_node = street_network.nodes.get(prev_nid) next_node = street_network.nodes.get(next_nid) n1, n2 = make_sidewalk_nodes(street, prev_node, curr_node, next_node) sidewalk_network.add_node(n1) sidewalk_network.add_node(n2) sidewalk_1_nodes.append(n1) sidewalk_2_nodes.append(n2) # Keep track of parent-child relationship between streets and sidewalks. # And set nodes' adjacency information sidewalk_1_nids = [node.id for node in sidewalk_1_nodes] sidewalk_2_nids = [node.id for node in sidewalk_2_nodes] sidewalk_1 = Sidewalk(None, sidewalk_1_nids, "footway") sidewalk_2 = Sidewalk(None, sidewalk_2_nids, "footway") sidewalk_1.set_street_id(street.id) sidewalk_2.set_street_id(street.id) street.append_sidewalk_id(sidewalk_1.id) street.append_sidewalk_id(sidewalk_2.id) # Add sidewalks to the network sidewalk_network.add_way(sidewalk_1) sidewalk_network.add_way(sidewalk_2) return sidewalk_network
class Machine(Base): ''' The machine connects the nodes and manages the addition and removal of nodes to the network. ''' def __init__(self, name=None): self.log_color = 'red' self.name = name or random_string(8) self.events = Events() events.e = self.events self.nodes = Nodes() self.register = Register(machine=self, events=self.events) def set_listeners(self): ''' provide machine event listeners ''' self.events.listen('add_conditions') def activate_node(self, node): _n = node.integrate(self) self.nodes.append(_n) self.log('Integrating node', _n) ''' Loop an iterable to add Conditiond into the network for a node ''' # Write node into register. # n=node.get_name() # add weak reference in register. self.register.add_node(_n) _n.react(self) return _n def render_nodes(self, nodes): self.log('Add nodes to network') for node in nodes: n = node # Create the node is the element is not an instance if inspect.isclass(node): n = node() self.activate_node(n) def start(self, nodes=None): if nodes is not None: self.render_nodes(nodes) print '\n--- Run ---\n' self.started(nodes) def started(self, nodes): ''' Override for easy start reference. Passed are the initial nodes provides to the machine. ''' pass def __str__(self): return '%s "%s"' % (self.__class__.__name__, self.name, )
from nodes import Nodes import numpy as np import time # mapper_dict = {0: 1, # 1: 2} # callibration_dict = {0: 0.05, # 1: 0.042} active_robots = ['3803', '3735'] nodes = Nodes(active_robots) nodes.callibrate() nodes.pendle_experiment() # for tag in nodes.nodes: # # tag = 1 # # print(nodes.nodes[tag].orien) # # start_pose = nodes.nodes[tag].pose # # start_time = nodes.nodes[tag].odomMsg_time # # nodes.nodes[tag].publish_greenLed(np.array([30])) # # nodes.nodes[tag].publish_motor_vlt(np.array([10, 10])) # # time.sleep(2) # # end_pose = nodes.nodes[tag].pose # # end_time = nodes.nodes[tag].odomMsg_time # # nodes.nodes[tag].publish_motor_vlt() # # nodes.nodes[tag].publish_greenLed() # # print(nodes.nodes[tag].orien) #
class DHTClient(threading.Thread): def __init__(self, max_node_qsize): threading.Thread.__init__(self) self.setDaemon(True) self.max_node_qsize = max_node_qsize self.nid = random_id() self.nodes = Nodes(self.nid) def send_krpc(self, msg, address): try: self.ufd.sendto(bencode(msg), address) except Exception as msg: print("DHTClient.send_krpc error: ", msg) def send_find_node(self, address, target_id=random_id()): nid = self.nid tid = entropy(TID_LENGTH) target_id = nid msg = { 't': tid, 'y': 'q', 'q': 'find_node', 'a': { 'id': nid, 'target': target_id } } self.send_krpc(msg, address) def auto_send_find_node(self): while True: try: if self.nodes.mutex.acquire(1): for bucket in self.nodes.buckets: for node in bucket: self.send_find_node((node.ip, node.port)) self.nodes.mutex.release() except Exception as msg: if DEBUG: print("re_join_find_node: ", msg) time.sleep(0.1) def join_DHT(self): for address in BOOTSTRAP_NODES: self.send_find_node(address) def send_ping(self, address, nid): tid = entropy(TID_LENGTH) msg = { 't': tid, 'y': 'q', 'q': 'ping', 'a': { 'id': self.nid, } } self.send_krpc(msg, address) def process_find_node_response(self, msg, address): nodes = decode_nodes(msg['r']['nodes']) for node in nodes: (nid, ip, port) = node if len(nid) != 20: continue if ip == self.bind_ip: continue n = KNode(nid, ip, port) self.nodes.store(n)
def __init__(self, max_node_qsize): threading.Thread.__init__(self) self.setDaemon(True) self.max_node_qsize = max_node_qsize self.nid = random_id() self.nodes = Nodes(self.nid)
def NavigationActionSampling(parent, dt, traj_duration, agentID, v, sm, p1_goal, p2_goal, ang_num, sp_num, num_obs): t = np.dot(range(0, int(traj_duration / dt)), dt) ang_del = 37.5 / 360 * np.pi sp_del = 0.4 count = 0 act_num = (2 * ang_num + 1) * (2 * sp_num + 1) Actions = [] dv_ = np.dot(range(-sp_num, sp_num + 1), sp_del) ang_accel_ = np.dot(range(-ang_num, ang_num + 1), ang_del) dv_mesh, ang_mesh = np.meshgrid(dv_, ang_accel_) dv_sampled = dv_mesh.reshape(1, len(dv_) * len(ang_accel_)) ang_sampled = ang_mesh.reshape(1, len(dv_) * len(ang_accel_)) #plt.cla() #plt.axis('equal') #plt.grid(True) #plt.autoscale(False) #print 'len(dv_), len(ang_accel_) = {},{}'.format(len(dv_),len(ang_accel_)) for i in range(len(dv_) * len(ang_accel_)): action = Nodes(parent, parent.end_time, parent.end_time + traj_duration, [], [], [], parent.theta_new) dv = dv_sampled[0][i] #print 'dv = {}'.format(dv) ang_accel = ang_sampled[0][i] count = count + 1 #initialization if (agentID == 1): init_x_ped = parent.x_ped[0] init_y_ped = parent.x_ped[1] pos = [init_x_ped, init_y_ped, 0, 0] vx_ind = 2 vy_ind = 3 #vTravellerx = pos[2] #vTravellery = pos[3] vTx = p1_goal[0][0] - pos[0] vTy = p1_goal[0][1] - pos[1] vTx = parent.x_ped[2] vTy = parent.x_ped[3] else: init_x_rob = parent.x_rob[0] init_y_rob = parent.x_rob[1] pos = [init_x_rob, init_y_rob, 0, 0] vx_ind = 5 vy_ind = 6 #vTravellerx = pos[5] #vTravellery = pos[6] vTx = p2_goal[0][0] - pos[0] vTy = p2_goal[0][1] - pos[1] vTx = parent.x_rob[2] vTy = parent.x_rob[3] #print 'x_rob = {},{}'.format(parent.x_rob[2],parent.x_rob[3]) vTx_ = vTx / np.sqrt(vTx**2 + vTy**2) * (v + dv) vTy_ = vTy / np.sqrt(vTx**2 + vTy**2) * (v + dv) trajx = [] #trajx.append(pos[0]) trajy = [] #trajy.append(pos[1]) velx = np.dot(vTx_, np.cos(np.dot(t, ang_accel))) + np.dot( vTy_, np.sin(np.dot(t, ang_accel))) vely = -np.dot(vTx_, np.sin(np.dot(t, ang_accel))) + np.dot( vTy_, np.cos(np.dot(t, ang_accel))) for j in range(0, len(t)): pos[0] = pos[0] + velx[j] * dt pos[1] = pos[1] + vely[j] * dt trajx.append(pos[0]) trajy.append(pos[1]) #plt.plot(pos[0],pos[1],'ok') time = np.add(t, parent.end_time) action.trajt = time if dv < 0: action.intent = 1 else: action.intent = 0 if agentID == 1: action.human_trajx = trajx action.human_trajy = trajy action.human_velx = velx action.human_vely = vely x_ped_ = [] x_ped_.append(pos[0]) x_ped_.append(pos[1]) x_ped_.append(velx[-1]) x_ped_.append(vely[-1]) action.x_ped = x_ped_ else: action.robot_trajx = trajx action.robot_trajy = trajy action.robot_velx = velx action.robot_vely = vely action.robot_angz = [ang_accel for k in range(len(t))] x_rob_ = [] x_rob_.append(pos[0]) x_rob_.append(pos[1]) x_rob_.append(velx[-1]) x_rob_.append(vely[-1]) action.x_rob = x_rob_ Actions.append(action) Actions_ = [] for i in range(max(num_obs, 1)): Actions_.append(Actions) #print 'Actions_[0][0].rob_pos = {}' plt.pause(0.01) return Actions_
class Graph(object): def __init__(self, data=None, **attr): # the init could be # graph = Graph(g) where g is a Graph # graph = Graph((v,e)) where v is Graph.v like and e is Graph.e like # graph = Graph(({},e)) for an edgelist with no specified nodes # others with classmethods like # Graph.from_adjacency_matrix(m) # Graph.from_adjacency_list(l) # # should abstract the data here self._nodedata = {} # empty node attribute dict self._adjacency = {} # empty adjacency dict # the interface is n,e,a,data self.n = Nodes(self._nodedata, self._adjacency) # rename to self.nodes self.e = Edges(self._nodedata, self._adjacency) # rename to self.edges self.a = Adjacency(self._adjacency) # rename to self.adjacency self.data = {} # dictionary for graph attributes # load with data if hasattr(data,'n') and not hasattr(data,'name'): # it is a new graph self.n.update(data.n) self.e.update(data.e) self.data.update(data.data) data = None try: nodes,edges = data # containers of edges and nodes self.n.update(nodes) self.e.update(edges) except: # old style if data is not None: convert.to_networkx_graph(data, create_using=self) # load __init__ graph attribute keywords self.data.update(attr) def s(self, nbunch): H = Subgraph(self, nbunch) return H # crazy use of call - get subgraph? def __call__(self, nbunch): return self.s(nbunch) # rewrite these in terms of new interface def __iter__(self): return iter(self.n) def __len__(self): return len(self.n) def clear(self): self.name = '' self.n.clear() self.e.clear() self.data.clear() def copy(self, with_data=True): if with_data: return deepcopy(self) G = self.__class__() G.n.update(self.n) G.e.update(self.e) return G def is_multigraph(self): """Return True if graph is a multigraph, False otherwise.""" return False def is_directed(self): """Return True if graph is directed, False otherwise.""" return False def order(self): return len(self.n) def size(self, weight=None): s = sum(d for v, d in self.n.degree(weight=weight)) # If `weight` is None, the sum of the degrees is guaranteed to be # even, so we can perform integer division and hence return an # integer. Otherwise, the sum of the weighted degrees is not # guaranteed to be an integer, so we perform "real" division. return s // 2 if weight is None else s / 2 @classmethod def from_adjacency_matrix(self, matrix): import numpy as np kind_to_python_type={'f':float, 'i':int, 'u':int, 'b':bool, 'c':complex, 'S':str, 'V':'void'} try: # Python 3.x blurb = chr(1245) # just to trigger the exception kind_to_python_type['U']=str except ValueError: # Python 2.6+ kind_to_python_type['U']=unicode n,m=matrix.shape if n!=m: raise nx.NetworkXError("Adjacency matrix is not square.", "nx,ny=%s"%(matrix.shape,)) dt=matrix.dtype try: python_type=kind_to_python_type[dt.kind] except: raise TypeError("Unknown numpy data type: %s"%dt) # Make sure we get even the isolated nodes of the graph. nodes = range(n) # Get a list of all the entries in the matrix with nonzero entries. These # coordinates will become the edges in the graph. edges = zip(*(np.asarray(matrix).nonzero())) # handle numpy constructed data type if python_type is 'void': # Sort the fields by their offset, then by dtype, then by name. fields = sorted((offset, dtype, name) for name, (dtype, offset) in matrix.dtype.fields.items()) triples = ((u, v, {name: kind_to_python_type[dtype.kind](val) for (_, dtype, name), val in zip(fields, matrix[u, v])}) for u, v in edges) else: # basic data type triples = ((u, v, dict(weight=python_type(matrix[u, v]))) for u, v in edges) graph = self((nodes, triples)) return graph @classmethod def from_adjacency_list(self, adjlist): nodes = range(len(adjlist)) edges = [(node,n) for node,nbrlist in enumerate(adjlist) for n in nbrlist] return self((nodes,edges))
ndtags = ['23', '21'] count = 0 for ndvote in ndvotes: count += int(ndvote['type']) input = { 'nodeDisplay': 'TestNode4', 'nodeDescription': 'Third node for Nodes Class', 'nodeTags': ndtags, 'nodeParents': ndparents, 'nodeChildren': ndchildren, 'nodeVotes': ndvotes, 'nodeStatus': count } """ client = Nodes() # client.create(**input) # node = client.retrieveById('0cd16aed4e20f18b') # for ent in node: # print ent, ': ', node[ent] ''' list = client.retrieveAll() for node in list: for ent in node: print ent, ': ', node[ent] print ''' ''' update_input = { '_id': '0cd16aed4e20f18b',
def nodes(s): return Nodes(s.__maas, uri=u'/tags/%s/' % s.name, op='nodes')
def nodes_allocated(s): return Nodes(s, op='list_allocated')
def nodes(s): return Nodes(s)
display_width = 800 display_height = 600 gameDisplay = pygame.display.set_mode((display_width, display_height)) pygame.display.set_caption('Visual Path Finder') black = (40, 40, 40) white = (255, 255, 255) shadow = (192, 192, 192) green = (0, 200, 0) red = (255, 0, 0) blue = (0, 220, 255) yellow = (255, 255, 125) Nodes.create_nodes() clock = pygame.time.Clock() gameExit = False left_Mouse = False right_Mouse = False old_left_Mouse = False # Maybe I should initialize the Menu with the first menu titles and then have it going by itself? Menu.create_menu() while not gameExit: old_left_Mouse = left_Mouse gameDisplay.fill(shadow)
def __init__(self, nodes_file): self.nodes = Nodes(nodes_file=nodes_file) self.multi_client = MultiClient(self.nodes)
from flask import Flask, jsonify, request from blockchain import Blockchain from consensus import Consensus from hash import Hash from nodes import Nodes from proof import Proof # Initialise a Node and generate a globally unique address app = Flask(__name__) node_id = str(uuid4()).replace('-', '') blockchain = Blockchain() proof = Proof() nodes = Nodes() consensus = Consensus() @app.route('/mine', methods=['GET']) def mine(): ''' Mine a new block. ''' # Get the previous block and proof and find the new proof. previous_block = blockchain.last_block previous_proof = previous_block["proof"] new_proof = proof.proof_of_work(previous_proof) # Because the user is mining a block, we want to reward them with a block,
class Graph(object): def __init__(self, data=None, **attr): # the init could be # graph = Graph(g) where g is a Graph # graph = Graph((v,e)) where v is Graph.v like and e is Graph.e like # graph = Graph(({},e)) for an edgelist with no specified nodes # others with classmethods like # Graph.from_adjacency_matrix(m) # Graph.from_adjacency_list(l) # # should abstract the data here self._nodedata = {} # empty node attribute dict self._adjacency = {} # empty adjacency dict # the interface is n,e,a,data self.n = Nodes(self._nodedata, self._adjacency) # rename to self.nodes self.e = Edges(self._nodedata, self._adjacency) # rename to self.edges self.a = Adjacency(self._adjacency) # rename to self.adjacency self.data = {} # dictionary for graph attributes # load with data if hasattr(data, "n") and not hasattr(data, "name"): # it is a new graph self.n.update(data.n) self.e.update(data.e) self.data.update(data.data) data = None try: nodes, edges = data # containers of edges and nodes self.n.update(nodes) self.e.update(edges) except: # old style if data is not None: convert.to_networkx_graph(data, create_using=self) # load __init__ graph attribute keywords self.data.update(attr) def s(self, nbunch): H = Subgraph(self, nbunch) return H # crazy use of call - get subgraph? def __call__(self, nbunch): return self.s(nbunch) # rewrite these in terms of new interface def __iter__(self): return iter(self.n) def __len__(self): return len(self.n) def clear(self): self.name = "" self.n.clear() self.e.clear() self.data.clear() def copy(self, with_data=True): if with_data: return deepcopy(self) G = self.__class__() G.n.update(self.n) G.e.update(self.e) return G def is_multigraph(self): """Return True if graph is a multigraph, False otherwise.""" return False def is_directed(self): """Return True if graph is directed, False otherwise.""" return False def order(self): return len(self.n) def size(self, weight=None): s = sum(d for v, d in self.n.degree(weight=weight)) # If `weight` is None, the sum of the degrees is guaranteed to be # even, so we can perform integer division and hence return an # integer. Otherwise, the sum of the weighted degrees is not # guaranteed to be an integer, so we perform "real" division. return s // 2 if weight is None else s / 2 @classmethod def from_adjacency_matrix(self, matrix): import numpy as np kind_to_python_type = {"f": float, "i": int, "u": int, "b": bool, "c": complex, "S": str, "V": "void"} try: # Python 3.x blurb = chr(1245) # just to trigger the exception kind_to_python_type["U"] = str except ValueError: # Python 2.6+ kind_to_python_type["U"] = unicode n, m = matrix.shape if n != m: raise nx.NetworkXError("Adjacency matrix is not square.", "nx,ny=%s" % (matrix.shape,)) dt = matrix.dtype try: python_type = kind_to_python_type[dt.kind] except: raise TypeError("Unknown numpy data type: %s" % dt) # Make sure we get even the isolated nodes of the graph. nodes = range(n) # Get a list of all the entries in the matrix with nonzero entries. These # coordinates will become the edges in the graph. edges = zip(*(np.asarray(matrix).nonzero())) # handle numpy constructed data type if python_type is "void": # Sort the fields by their offset, then by dtype, then by name. fields = sorted((offset, dtype, name) for name, (dtype, offset) in matrix.dtype.fields.items()) triples = ( ( u, v, {name: kind_to_python_type[dtype.kind](val) for (_, dtype, name), val in zip(fields, matrix[u, v])}, ) for u, v in edges ) else: # basic data type triples = ((u, v, dict(weight=python_type(matrix[u, v]))) for u, v in edges) graph = self((nodes, triples)) return graph @classmethod def from_adjacency_list(self, adjlist): nodes = range(len(adjlist)) edges = [(node, n) for node, nbrlist in enumerate(adjlist) for n in nbrlist] return self((nodes, edges))