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()
