def __init__(self, ocp_client, sampling_client): self.ocp_client = ocp_client self.sampling_client = sampling_client # Define an estimator self.estimator = Networks(NX, NU, x_range=np.array([X_MIN, X_MAX]), u_range=np.array([U_MIN, U_MAX]))
def __init__(self, params): self.batch_size = params.batch_size self.batch_size_val = params.batch_size_val self.initial_temperature = params.temperature self.decay_temperature = params.decay_temperature self.num_epochs = params.num_epochs self.loss_type = params.loss_type self.num_classes = params.num_classes self.w_gauss = params.w_gaussian self.w_categ = params.w_categorical self.w_recon = params.w_reconstruction self.decay_temp_rate = params.decay_temp_rate self.gaussian_size = params.gaussian_size self.min_temperature = params.min_temperature self.temperature = params.temperature # current temperature self.verbose = params.verbose self.sess = tf.Session() self.network = Networks(params) self.losses = LossFunctions() self.learning_rate = tf.placeholder(tf.float32, []) self.lr = params.learning_rate self.decay_epoch = params.decay_epoch self.lr_decay = params.lr_decay self.dataset = params.dataset self.metrics = Metrics()
def set_plugin_parameters(status: bool = False, alerts: bool = False): # Store args and monitor_plugins for lazy loading. global default_args, pool_collection, node_info if not default_args: # Create plugin instance and set default args default_monitor_plugins = PluginCollection('plugins') parser = argparse.ArgumentParser() parser.add_argument("-v", "--verbose", default=(os.environ.get( 'VERBOSE', 'False').lower() == 'true'), action="store_true") default_monitor_plugins.get_parse_args(parser) default_args, unknown = parser.parse_known_args() enable_verbose(default_args.verbose) pool_collection = PoolCollection(default_args.verbose, Networks()) node_info = FetchStatus(default_args.verbose, pool_collection) # Create namespace with default args and load them into api_args api_args = argparse.Namespace() for name, value in default_args._get_kwargs(): setattr(api_args, name, value) # Set api_args with the values from the parameters setattr(api_args, 'status', status) setattr(api_args, 'alerts', alerts) # Create and load plugins with api_args monitor_plugins = PluginCollection('plugins') monitor_plugins.load_all_parse_args(api_args) return monitor_plugins
def networks(): try: from .config import Config from .networks import Networks from .tracks import Tracks except SystemError: from config import Config from networks import Networks from tracks import Tracks def dummy(bla): return test_data = get_client_test_data()[2] test_config = Config(None).default_config networks = Networks(test_config) networks.notify_add_list["map"] = dummy networks.notify_add_list["network_list"] = dummy networks.notify_remove_list["map"] = dummy networks.notify_remove_list["network_list"] = dummy for x in range(2): for data in test_data: if data is not None and data[0] == "bssid": networks.add_bssid_data(data[1], 0) data[1]["lasttime"] = data[1]["lasttime"] + 1 for data in test_data: if data is not None and data[0] == "ssid": networks.add_ssid_data(data[1]) data[1]["lasttime"] = data[1]["lasttime"] + 1 tmp_csv_file = "%s%stest-%s.csv" % (tempfile.gettempdir(), os.sep, int(time.time())) tmp_csv = open(tmp_csv_file, "w") tmp_csv.write("""Network;NetType;ESSID;BSSID;Info;Channel;Cloaked;Encryption;Decrypted;MaxRate;MaxSeenRate;Beacon;LLC;Data;Crypt;Weak;Total;Carrier;Encoding;FirstTime;LastTime;BestQuality;BestSignal;BestNoise;GPSMinLat;GPSMinLon;GPSMinAlt;GPSMinSpd;GPSMaxLat;GPSMaxLon;GPSMaxAlt;GPSMaxSpd;GPSBestLat;GPSBestLon;GPSBestAlt;DataSize;IPType;IP; 1;infrastructure;asd;11:22:33:44:55:66;;3;No;WEP,WPA,PSK,AES-CCM;No;18.0;1000;25600;148;0;0;0;148;IEEE 802.11g;;Thu Jan 22 05:48:23 2009;Thu Jan 22 05:51:46 2009;0;65;-98;52.123456;13.123456;120.120003;0.000000;52.123456;13.123456;120.120003;2.934490;0.000000;0.000000;0.000000;0;None;0.0.0.0;""") tmp_csv.close() for x in range(2): networks.import_networks("csv", tmp_csv_file) networks.import_networks("netxml", "") tmp_tracks_file = "%s%stest-tracks-%s.json" % (tempfile.gettempdir(), os.sep, int(time.time())) test_tracks = Tracks(tmp_tracks_file) networks_file = "%s%snetworks-%s.json" % (tempfile.gettempdir(), os.sep, int(time.time())) networks.save(networks_file) networks.load(networks_file) networks.import_networks("networks",networks_file) networks.apply_filters() networks.save(networks_file) networks.export_networks_netxml(tempfile.gettempdir() + os.sep + "test.netxml", networks.networks) networks.import_networks("netxml", tempfile.gettempdir() + os.sep + "test.netxml") networks.export_networks_kmz(tempfile.gettempdir() + os.sep + "test.kmz", networks.networks, tracks=test_tracks, filtered=False) networks.export_networks_kmz(tempfile.gettempdir() + os.sep + "test.kmz", networks.networks, tracks=test_tracks, filtered=True) return networks
def __init__(self): """ Create ROS clients and a the estimator model """ self.ocp_client = actionlib.SimpleActionClient( OPT_CONTROL_ACTION_SERVER, OptControlAction) self.ocp_client.wait_for_server() rospy.loginfo('End of wait for ocp action server') rospy.wait_for_service('create_samples') self.sampling_client = rospy.ServiceProxy('create_samples', Samples) self.estimator = Networks(NX, NU, x_range=np.array([X_MIN, X_MAX]), u_range=np.array([U_MIN, U_MAX]))
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): self.estimator = Networks(NX, NU, x_range=np.array([X_MIN, X_MAX]), u_range=np.array([U_MIN, U_MAX])) self.estimator.load() # Last state trajectory calculated self.X = np.array([]) self.U = np.array([]) self.time = 0 self.current_state = np.zeros(NX) self.end = np.zeros(NX) # time from the start of the current trajectory in ns self.t = 0 # useless as attribute? self.t_idx = 0 self.client = actionlib.SimpleActionClient(OPT_CONTROL_ACTION_SERVER, OptControlAction) self.client.wait_for_server() self.pub = rospy.Publisher('controller', Control, queue_size=10)
def __init__(self): """ Load the irepa built estimator then create clients for simulation and optimal control nodes """ self.estimator = Networks(NX, NU, x_range=np.array([X_MIN, X_MAX]), u_range=np.array([U_MIN, U_MAX])) self.estimator.load() # Last state trajectory calculated self.X = np.array([]) self.U = np.array([]) self.u = np.zeros(NU) self.time = 0 self.current_state = np.zeros(NX) self.end_state = np.zeros(NX) # time from the start of the current trajectory in ns self.t_idx = 0 # update trajectory every update_times iteration self.update_times = int(CPS / TUPS) self.ocp_client = actionlib.SimpleActionClient(OPT_CONTROL_SERVER, OptControlAction) self.ocp_client.wait_for_server() self.pub = rospy.Publisher(COMMAND_TOPIC, Command, queue_size=10) rospy.Subscriber(CURRENT_STATE_TOPIC, State, self.update_current_state) rospy.Subscriber(END_STATE_TOPIC, State, self.update_end_state) # test state rate self.t1 = rospy.get_rostime() self.t2 = rospy.get_rostime() # control steps self.stop_update = False self.stop_controls = False self.started = False
# iterate through all the years print("Loading team databases ...") all_teams = pd.read_csv( 'http://igem.org/Team_List.cgi?year=all&team_list_download=1') all_teams = all_teams.rename( columns={c: c.replace(' ', '') for c in all_teams.columns}) if YEARS: years = [int(i) for i in YEARS.split(',')] else: years = all_teams['Year'].unique() if NETWORKS: Networks = Networks(all_teams) # print(YEARS) # print(years) for y in years: if y not in all_teams['Year'].unique(): continue if y < 2008: continue # We parse the data # y = year.split('.')[0] print(("Grabbing team list for year: %s" % y)) # df = pd.read_csv('Teams/%s' % year) df = all_teams[(all_teams['Year'] == y) & (all_teams['Status'] == 'Accepted')] teams = df['Team'].values
help= "The privileged DID seed to use for the ledger requests. Can be specified using the 'SEED' environment variable. If DID seed is not given the request will run anonymously." ) parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose logging.") monitor_plugins = PluginCollection('plugins') monitor_plugins.get_parse_args(parser) args, unknown = parser.parse_known_args() monitor_plugins.load_all_parse_args(args) enable_verbose(args.verbose) log("Starting from the command line ...") if args.list_nets: print(json.dumps(Networks.get_networks(), indent=2)) exit() log("indy-vdr version:", indy_vdr.version()) did_seed = None if not args.seed else args.seed ident = create_did(did_seed) networks = Networks() pool_collection = PoolCollection(args.verbose, networks) network = networks.resolve(args.net, args.genesis_url, args.genesis_path) node_info = FetchLedgerTX(args.verbose, pool_collection) result = asyncio.get_event_loop().run_until_complete( node_info.fetch(network.id, monitor_plugins, ident)) print(json.dumps(result, indent=2))
def __init__(self): user_dir = "%s%s.kismon%s" % (os.path.expanduser("~"), os.sep, os.sep) if not os.path.isdir(user_dir): print("Creating Kismon user directory %s" % user_dir) os.mkdir(user_dir) config_file = "%skismon.conf" % user_dir self.config_handler = Config(config_file) self.config_handler.read() self.config = self.config_handler.config self.sources = {} self.crypt_cache = {} self.networks = Networks(self.config) self.client_threads = {} self.init_client_threads() self.tracks = Tracks("%stracks.json" % user_dir) self.tracks.load() if "--disable-map" in sys.argv: self.map_error = "--disable-map used" else: self.map_error = check_osmgpsmap() if self.map_error is not None: self.map_error = "%s\nMap disabled" % self.map_error print(self.map_error, "\n") self.init_map() self.main_window = MainWindow(self.config, self.client_start, self.client_stop, self.map, self.networks, self.sources, self.tracks, self.client_threads) self.main_window.log_list.add("Kismon", "started") if self.map_error is not None: self.main_window.log_list.add("Kismon", self.map_error) self.networks_file = "%snetworks.json" % user_dir if os.path.isfile(self.networks_file): try: self.networks.load(self.networks_file) except: error = sys.exc_info()[1] print(error) dialog_message = "Could not read the networks file '%s':\n%s\n\nDo you want to continue?" % ( self.networks_file, error) dialog = Gtk.MessageDialog(self.main_window.gtkwin, Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.ERROR, Gtk.ButtonsType.YES_NO, dialog_message) def dialog_response(dialog, response_id): self.dialog_response = response_id dialog.connect("response", dialog_response) dialog.run() dialog.destroy() if self.dialog_response == -9: print("exit") self.clients_stop() self.main_window.gtkwin = None return self.networks.set_autosave(self.config["networks"]["autosave"], self.networks_file, self.main_window.log_list.add) if self.map is not None: self.networks.notify_add_list["map"] = self.add_network_to_map self.networks.notify_remove_list["map"] = self.map.remove_marker GLib.timeout_add(100, self.map.set_last_from_config) self.main_window.network_list.crypt_cache = self.crypt_cache GLib.timeout_add(500, self.queues_handler) GLib.timeout_add(300, self.queues_handler_networks) GLib.idle_add(self.networks.apply_filters)
def __init__(self): user_dir = "%s%s.kismon%s" % (os.path.expanduser("~"), os.sep, os.sep) if not os.path.isdir(user_dir): print("Creating Kismon user directory %s" % user_dir) os.mkdir(user_dir) config_file = "%skismon.conf" % user_dir self.config_handler = Config(config_file) self.config_handler.read() self.config = self.config_handler.config self.marker_text = """Encryption: %s MAC: %s Manuf: %s Type: %s Channel: %s First seen: %s Last seen: %s""" self.sources = {} self.crypt_cache = {} self.networks = Networks(self.config) self.init_client_thread() if self.config["kismet"]["connect"] is True: self.client_start() if "--disable-map" in sys.argv: self.map_error = "--disable-map used" else: self.map_error = check_osmgpsmap() if self.map_error is not None: self.map_error = "%s\nMap disabled" % self.map_error print(self.map_error, "\n") self.init_map() self.main_window = MainWindow(self.config, self.client_start, self.client_stop, self.map, self.networks, self.sources, self.client_thread.client) self.main_window.log_list.add("Kismon started") if self.map_error is not None: self.main_window.log_list.add(self.map_error) self.networks_file = "%snetworks.json" % user_dir if os.path.isfile(self.networks_file): try: self.networks.load(self.networks_file) except: error = sys.exc_info()[1] print(error) dialog_message = "Could not read the networks file '%s':\n%s\n\nDo you want to continue?" % (self.networks_file, error) dialog = Gtk.MessageDialog(self.main_window.gtkwin, Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.ERROR, Gtk.ButtonsType.YES_NO, dialog_message) def dialog_response(dialog, response_id): self.dialog_response = response_id dialog.connect("response", dialog_response) dialog.run() dialog.destroy() if self.dialog_response == -9: print("exit") self.client_thread.stop() self.main_window.gtkwin = None return self.networks.set_autosave(self.config["networks"]["autosave"], self.networks_file, self.main_window.log_list.add) if self.map is not None: self.networks.notify_add_list["map"] = self.add_network_to_map self.networks.notify_remove_list["map"] = self.map.remove_marker self.main_window.network_list.crypt_cache = self.crypt_cache self.battery_max = None self.battery = None path = "/proc/acpi/battery/" if os.path.exists(path): for name in os.listdir(path): self.battery = name f = open("%s%s/info" % (path, name)) for line in f.readlines(): if line.startswith("last full capacity:"): max = line.split(":")[1].strip() self.battery_max = int(max.split()[0]) break GObject.timeout_add(30000, self.update_battery_bar) break self.update_battery_bar() GLib.timeout_add(500, self.queue_handler) GLib.timeout_add(300, self.queue_handler_networks) GLib.idle_add(self.networks.apply_filters)
from irepa import NX, NU, X_MIN, X_MAX, U_MIN, U_MAX from roadmap.msg import OptControlAction, OptControlGoal plt.rc('legend', **{'fontsize': 10}) OPT_CONTROL_SERVER = 'solve_ocp' rospy.init_node('ocp_solve_client') ocp_client = actionlib.SimpleActionClient(OPT_CONTROL_SERVER, OptControlAction) ocp_client.wait_for_server() rospy.loginfo('End of wait for rocket') print('Creating NN') estimator = Networks(NX, NU, x_range=np.array([X_MIN, X_MAX]), u_range=np.array([U_MIN, U_MAX])) estimator.load() print('Weights loaded') Xs = [] Vs = [] def callback(state, resp): global Xs global Vs X = np.array(resp.states).reshape(len(resp.states) // NX, NX) U = np.array(resp.controls).reshape(len(resp.controls) // NU, NU) print() print()