Merge pull request #36 from nasa/24-allow-for-dynamic-plugins

24 allow for dynamic plugins

driver.py

@@ -14,7 +14,7 @@
 import pytest
 import coverage
 # coverage started early to see all lines in all files (def and imports were being missed with programmatic runs)
-cov = coverage.Coverage(source=['onair'], branch=True)
+cov = coverage.Coverage(source=['onair','plugins'], branch=True)
 cov.start()
 
 import os

onair/config/default_config.ini

@@ -6,6 +6,7 @@ TelemetryFiles = ['700_crash_to_earth_1.csv']
 ParserFileName = csv_parser
 ParserName = CSV
 SimName = CSV
+PluginList = {'generic_plugin':'plugins/generic/generic_plugin.py'}
 
 [RUN_FLAGS]
 IO_Flag = true

onair/src/data_driven_components/data_driven_learning.py

@@ -10,18 +10,22 @@
 """
 Data driven learning class for managing all data driven AI components
 """
-import importlib
+import importlib.util
+import importlib.util
 
 from ..util.data_conversion import *
 
 class DataDrivenLearning:
- def __init__(self, headers, _ai_plugins:list=[]):
- assert(len(headers)>0)
+ def __init__(self, headers, _ai_plugins={}):
+ assert(len(headers)>0), 'Headers are required'
  self.headers = headers
- self.ai_constructs = [
- importlib.import_module('onair.src.data_driven_components.' + plugin_name + '.' + f'{plugin_name}_plugin').Plugin(plugin_name, headers) for plugin_name in _ai_plugins
- ]
-
+ self.ai_constructs = []
+ for module_name in list(_ai_plugins.keys()):
+ spec = importlib.util.spec_from_file_location(module_name, _ai_plugins[module_name])
+ module = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ self.ai_constructs.append(module.Plugin(module_name,headers))
+
  def update(self, curr_data, status):
  input_data = curr_data
  output_data = status_to_oneHot(status)

onair/src/reasoning/agent.py

@@ -15,9 +15,9 @@
 from ..reasoning.diagnosis import Diagnosis
 
 class Agent:
- def __init__(self, vehicle):
+ def __init__(self, vehicle, plugin_list):
  self.vehicle_rep = vehicle
- self.learning_systems = DataDrivenLearning(self.vehicle_rep.get_headers())
+ self.learning_systems = DataDrivenLearning(self.vehicle_rep.get_headers(),plugin_list)
  self.mission_status = self.vehicle_rep.get_status()
  self.bayesian_status = self.vehicle_rep.get_bayesian_status()
 
@@ -29,7 +29,7 @@ def reason(self, frame):
 
  def diagnose(self, time_step):
  """ Grab the mnemonics from the """
- learning_system_results = self.learning_systems.render_reasoning() 
+ learning_system_results = self.learning_systems.render_reasoning()
  diagnosis = Diagnosis(time_step, 
  learning_system_results,
  self.bayesian_status,

onair/src/run_scripts/execution_engine.py

@@ -18,6 +18,7 @@
 import shutil
 from distutils.dir_util import copy_tree
 from time import gmtime, strftime 
+import ast
 
 from ...data_handling.time_synchronizer import TimeSynchronizer
 from ..run_scripts.sim import Simulator
@@ -49,6 +50,9 @@ def __init__(self, config_file='', run_name='', save_flag=False):
  self.sim_name = ''
  self.processedSimData = None
  self.sim = None
+
+ # Init plugins
+ self.plugin_list = ['']
 
  self.save_flag = save_flag
  self.save_name = run_name
@@ -60,40 +64,52 @@ def __init__(self, config_file='', run_name='', save_flag=False):
  self.setup_sim()
 
  def parse_configs(self, config_filepath):
- # print("Using config file: {}".format(config_filepath))
-
  config = configparser.ConfigParser()
+
  if len(config.read(config_filepath)) == 0:
  raise FileNotFoundError(f"Config file at '{config_filepath}' could not be read.")
 
  try:
- ## Sort Required Data: Telementry Data & Configuration
+ ## Parse Required Data: Telementry Data & Configuration
  self.dataFilePath = config['DEFAULT']['TelemetryDataFilePath']
  self.metadataFilePath = config['DEFAULT']['TelemetryMetadataFilePath']
  self.metaFiles = config['DEFAULT']['MetaFiles'] # Config for vehicle telemetry
  self.telemetryFiles = config['DEFAULT']['TelemetryFiles'] # Vehicle telemetry data
 
- ## Sort Required Data: Names
+ ## Parse Required Data: Names
  self.parser_file_name = config['DEFAULT']['ParserFileName']
  self.parser_name = config['DEFAULT']['ParserName']
  self.sim_name = config['DEFAULT']['SimName']
+
+ ## Parse Required Data: Plugin name to path dict
+ config_plugin_list = config['DEFAULT']['PluginList']
+ ast_plugin_list = ast.parse(config_plugin_list, mode='eval')
+ if isinstance(ast_plugin_list.body, ast.Dict) and len(ast_plugin_list.body.keys) > 0:
+ temp_plugin_list = ast.literal_eval(config_plugin_list)
+ else:
+ raise ValueError(f"{config_plugin_list} is an invalid PluginList. It must be a dict of at least 1 key/value pair.")
+ for plugin_name in temp_plugin_list.values():
+ if not(os.path.exists(plugin_name)):
+ raise FileNotFoundError(f"In config file '{config_filepath}', path '{plugin_name}' does not exist or is formatted incorrectly.")
+ self.plugin_list = temp_plugin_list
  except KeyError as e:
  new_message = f"Config file: '{config_filepath}', missing key: {e.args[0]}"
  raise KeyError(new_message) from e
 
- ## Sort Optional Data: Flags
+ ## Parse Optional Data: Flags
  self.IO_Flag = config['RUN_FLAGS'].getboolean('IO_Flag')
  self.Dev_Flag = config['RUN_FLAGS'].getboolean('Dev_Flag')
  self.SBN_Flag = config['RUN_FLAGS'].getboolean('SBN_Flag')
  self.Viz_Flag = config['RUN_FLAGS'].getboolean('Viz_Flag')
 
- ## Sort Optional Data: Benchmarks
+ ## Parse Optional Data: Benchmarks
  try:
  self.benchmarkFilePath = config['DEFAULT']['BenchmarkFilePath']
  self.benchmarkFiles = config['DEFAULT']['BenchmarkFiles'] # Vehicle telemetry data
  self.benchmarkIndices = config['DEFAULT']['BenchmarkIndices']
  except:
  pass
+
 
  def parse_data(self, parser_name, parser_file_name, dataFilePath, metadataFilePath, subsystems_breakdown=False):
  parser = importlib.import_module('onair.data_handling.parsers.' + parser_file_name)
@@ -104,7 +120,7 @@ def parse_data(self, parser_name, parser_file_name, dataFilePath, metadataFilePa
  self.processedSimData = TimeSynchronizer(*parsed_data.get_sim_data())
 
  def setup_sim(self):
- self.sim = Simulator(self.sim_name, self.processedSimData, self.SBN_Flag)
+ self.sim = Simulator(self.sim_name, self.processedSimData, self.plugin_list, self.SBN_Flag)
  try:
  fls = ast.literal_eval(self.benchmarkFiles)
  fp = os.path.dirname(os.path.realpath(__file__)) + '/../..' + self.benchmarkFilePath

onair/src/run_scripts/sim.py

@@ -25,7 +25,7 @@
 DIAGNOSIS_INTERVAL = 100
 
 class Simulator:
- def __init__(self, simType, parsedData, SBN_Flag):
+ def __init__(self, simType, parsedData, plugin_list, SBN_Flag):
  self.simulator = simType
  vehicle = VehicleRepresentation(*parsedData.get_vehicle_metadata())
 
@@ -39,7 +39,7 @@ def __init__(self, simType, parsedData, SBN_Flag):
 
  else:
  self.simData = DataSource(parsedData.get_sim_data())
- self.agent = Agent(vehicle)
+ self.agent = Agent(vehicle, plugin_list)
 
  def run_sim(self, IO_Flag=False, dev_flag=False, viz_flag = True):
  if IO_Flag == True: print_sim_header()

plugins/generic/__init__.py

@@ -0,0 +1 @@
+from .generic_plugin import Plugin

plugins/generic/generic_plugin.py

@@ -0,0 +1,30 @@
+# GSC-19165-1, "The On-Board Artificial Intelligence Research (OnAIR) Platform"
+#
+# Copyright © 2023 United States Government as represented by the Administrator of
+# the National Aeronautics and Space Administration. No copyright is claimed in the
+# United States under Title 17, U.S. Code. All Other Rights Reserved.
+#
+# Licensed under the NASA Open Source Agreement version 1.3
+# See "NOSA GSC-19165-1 OnAIR.pdf"
+
+import numpy as np
+from onair.src.data_driven_components.ai_plugin_abstract.core import AIPlugIn
+
+class Plugin(AIPlugIn):
+ def apriori_training(self,batch_data=[]):
+ """
+ Given data, system should learn any priors necessary for realtime diagnosis.
+ """
+ pass
+
+ def update(self,frame=[]):
+ """
+ Given streamed data point, system should update internally
+ """
+ pass
+
+ def render_reasoning(self):
+ """
+ System should return its diagnosis
+ """
+ pass

plugins/kalman_plugin/__init__.py

@@ -0,0 +1 @@
+from .kalman_plugin import Plugin

onair/src/data_driven_components/kalman/kalman_plugin.py → plugins/kalman_plugin/kalman_plugin.py

@@ -9,7 +9,7 @@
 
 import simdkalman
 import numpy as np
-from ...data_driven_components.generic_component import AIPlugIn
+from onair.src.data_driven_components.ai_plugin_abstract.core import AIPlugIn
 
 class Plugin(AIPlugIn):
  def __init__(self, name, headers, window_size=3):

test/src/data_driven_components/generic_component/test_core.py → test/onair/src/data_driven_components/ai_plugin_abstract/test_core.py

@@ -11,8 +11,8 @@
 import pytest
 from mock import MagicMock
 
-import onair.src.data_driven_components.generic_component.core as core
-from onair.src.data_driven_components.generic_component.core import AIPlugIn
+import onair.src.data_driven_components.ai_plugin_abstract.core as core
+from onair.src.data_driven_components.ai_plugin_abstract.core import AIPlugIn
 
 class FakeAIPlugIn(AIPlugIn):
  def __init__(self, _name, _headers):

test/src/data_driven_components/test_data_driven_learning.py → test/onair/src/data_driven_components/test_data_driven_learning.py

@@ -15,12 +15,13 @@
 from onair.src.data_driven_components.data_driven_learning import DataDrivenLearning
 
 import importlib
+from typing import Dict
 
 # __init__ tests
 def test_DataDrivenLearning__init__sets_instance_headers_to_given_headers_and_does_nothing_else_when_given__ai_plugins_is_empty(mocker):
  # Arrange
  arg_headers = []
- arg__ai_plugins = []
+ arg__ai_plugins = {}
 
  num_fake_headers = pytest.gen.randint(1, 10) # arbitrary, from 1 to 10 headers (0 has own test)
  for i in range(num_fake_headers):
@@ -34,64 +35,67 @@ def test_DataDrivenLearning__init__sets_instance_headers_to_given_headers_and_do
  # Assert
  assert cut.headers == arg_headers
 
-def test_DataDrivenLearning__init__sets_instance_ai_constructs_to_a_list_of_the_calls_AIPlugIn_with_plugin_and_given_headers_for_each_item_in_given__ai_plugins(mocker):
+def test_DataDrivenLearning__init__throws_AttributeError_when_given_module_file_has_no_attribute_Plugin(mocker):
  # Arrange
+ fake_module_name = MagicMock()
  arg_headers = []
- arg__ai_plugins = []
 
- num_fake_headers = pytest.gen.randint(1, 10) # arbitrary, from 1 to 10 headers (0 has own test)
- for i in range(num_fake_headers):
- arg_headers.append(MagicMock())
- fake_imported_module = MagicMock()
- num_fake_ai_plugins = pytest.gen.randint(1, 10) # arbitrary, from 1 to 10 (0 has own test)
- for i in range(num_fake_ai_plugins):
- arg__ai_plugins.append(str(MagicMock()))
-
- mocker.patch('importlib.import_module', return_value=fake_imported_module)
+ arg__ai_plugins = {MagicMock()}
 
- cut = DataDrivenLearning.__new__(DataDrivenLearning)
+
 
  # Act
- cut.__init__(arg_headers, arg__ai_plugins)
 
  # Assert
- assert importlib.import_module.call_count == num_fake_ai_plugins
- for i in range(num_fake_ai_plugins):
- assert importlib.import_module.call_args_list[i].args == ('onair.src.data_driven_components.' + arg__ai_plugins[i] + '.' + arg__ai_plugins[i] + '_plugin',)
 
 def test_DataDrivenLearning__init__sets_instance_ai_constructs_to_a_list_of_the_calls_AIPlugIn_with_plugin_and_given_headers_for_each_item_in_given__ai_plugins_when_given__ai_plugins_is_occupied(mocker):
  # Arrange
  arg_headers = []
- arg__ai_plugins = []
+ arg__ai_plugins = {}
+ fake_spec_list = []
+ fake_module_list = []
 
  num_fake_headers = pytest.gen.randint(1, 10) # arbitrary, from 1 to 10 headers (0 has own test)
  for i in range(num_fake_headers):
  arg_headers.append(MagicMock())
- fake_imported_module = MagicMock()
  num_fake_ai_plugins = pytest.gen.randint(1, 10) # arbitrary, from 1 to 10 (0 has own test)
  for i in range(num_fake_ai_plugins):
- arg__ai_plugins.append(str(MagicMock()))
+ arg__ai_plugins[str(MagicMock())] = str(MagicMock())
+ fake_spec_list.append(MagicMock())
+ fake_module_list.append(MagicMock())
+
 
  expected_ai_constructs = []
  for i in range(num_fake_ai_plugins):
  expected_ai_constructs.append(MagicMock())
 
- mocker.patch('importlib.import_module', return_value=fake_imported_module)
- mocker.patch.object(fake_imported_module, 'Plugin', side_effect=expected_ai_constructs)
+ # mocker.patch('importlib.import_module', return_value=fake_imported_module)
+ mocker.patch('importlib.util.spec_from_file_location',side_effect=fake_spec_list)
+ mocker.patch('importlib.util.module_from_spec',side_effect=fake_module_list)
+ for spec in fake_spec_list:
+ mocker.patch.object(spec,'loader.exec_module')
+ for i, module in enumerate(fake_module_list):
+ mocker.patch.object(module,'Plugin',return_value=expected_ai_constructs[i])
 
  cut = DataDrivenLearning.__new__(DataDrivenLearning)
 
  # Act
  cut.__init__(arg_headers, arg__ai_plugins)
 
  # Assert
- assert importlib.import_module.call_count == num_fake_ai_plugins
- for i in range(num_fake_ai_plugins):
- assert importlib.import_module.call_args_list[i].args == (f'onair.src.data_driven_components.{arg__ai_plugins[i]}.{arg__ai_plugins[i]}_plugin',)
- assert fake_imported_module.Plugin.call_count == num_fake_ai_plugins
+ assert importlib.util.spec_from_file_location.call_count == len(arg__ai_plugins)
+ assert importlib.util.module_from_spec.call_count == len(fake_spec_list)
+
  for i in range(num_fake_ai_plugins):
- assert fake_imported_module.Plugin.call_args_list[i].args == (arg__ai_plugins[i], arg_headers)
-
+ fake_name = list(arg__ai_plugins.keys())[i]
+ fake_path = arg__ai_plugins[fake_name]
+ assert importlib.util.spec_from_file_location.call_args_list[i].args == (fake_name,fake_path)
+ assert importlib.util.module_from_spec.call_args_list[i].args == (fake_spec_list[i],)
+ assert fake_spec_list[i].loader.exec_module.call_count == 1
+ assert fake_spec_list[i].loader.exec_module.call_args_list[0].args == (fake_module_list[i],)
+ assert fake_module_list[i].Plugin.call_count == 1
+ assert fake_module_list[i].Plugin.call_args_list[0].args == (fake_name,arg_headers)
+
  assert cut.ai_constructs == expected_ai_constructs
 
 # update tests

test/src/reasoning/test_agent.py → test/onair/src/reasoning/test_agent.py

@@ -23,6 +23,7 @@ def test_Agent__init__sets_vehicle_rep_to_given_vehicle_and_learning_systems_and
  fake_learning_systems = MagicMock()
  fake_mission_status = MagicMock()
  fake_bayesian_status = MagicMock()
+ fake_plugin_list = MagicMock()
 
  mocker.patch.object(arg_vehicle, 'get_headers', return_value=fake_headers)
  mocker.patch(agent.__name__ + '.DataDrivenLearning', return_value=fake_learning_systems)
@@ -32,14 +33,14 @@ def test_Agent__init__sets_vehicle_rep_to_given_vehicle_and_learning_systems_and
  cut = Agent.__new__(Agent)
 
  # Act
- result = cut.__init__(arg_vehicle)
+ result = cut.__init__(arg_vehicle, fake_plugin_list)
 
  # Assert
  assert cut.vehicle_rep == arg_vehicle
  assert arg_vehicle.get_headers.call_count == 1
  assert arg_vehicle.get_headers.call_args_list[0].args == ()
  assert agent.DataDrivenLearning.call_count == 1
- assert agent.DataDrivenLearning.call_args_list[0].args == (fake_headers, )
+ assert agent.DataDrivenLearning.call_args_list[0].args == (fake_headers, fake_plugin_list)
  assert cut.learning_systems == fake_learning_systems
  assert arg_vehicle.get_status.call_count == 1
  assert arg_vehicle.get_status.call_args_list[0].args == ()