def __load_tfs(self): """ Loads and connects all transfer functions """ self._notify("Loading transfer functions") for tf in self.sim_config.transfer_functions: self._notify("Loading transfer function: {}".format(tf.name)) #tf.code = correct_indentation(tf.code, 0) tf.code = tf.code.strip() + "\n" logger.debug("TF: " + tf.name + "\n" + tf.code + '\n') try: new_code = compile_restricted(tf.code, '<string>', 'exec') # pylint: disable=broad-except except Exception as e: logger.error( "Error while compiling the transfer function {name} in restricted " "mode with error {err}".format(name=tf.name, err=str(e))) tfm.set_flawed_transfer_function(tf.code, tf.name, e) continue try: tfm.set_transfer_function(tf.code, new_code, tf.name, tf.active) except tfm.TFLoadingException as loading_e: logger.error(loading_e) tfm.set_flawed_transfer_function(tf.code, tf.name, loading_e)
def __load_tfs(self): """ Loads and connects all transfer functions """ self._notify("Loading transfer functions") # Create transfer functions import_referenced_python_tfs(self.bibi, self.exc.dir) for i, tf in enumerate(self.bibi.transferFunction): self._notify("Generating transfer function: %i" % (i + 1)) tf_code = generate_tf(tf, self.bibi) self._notify("Loading transfer function: %s" % tf.name) tf_code = correct_indentation(tf_code, 0) tf_code = tf_code.strip() + "\n" logger.debug("TF: " + tf.name + "\n" + tf_code + '\n') try: new_code = compile_restricted(tf_code, '<string>', 'exec') # pylint: disable=broad-except except Exception as e: message = "Error while compiling the updated transfer function named "\ + tf.name +\ " in restricted mode.\n"\ + str(e) logger.error(message) nrp.set_flawed_transfer_function(tf_code, tf.name, e) continue try: nrp.set_transfer_function(tf_code, new_code, tf.name) except nrp.TFLoadingException as loading_e: logger.error(loading_e) nrp.set_flawed_transfer_function(tf_code, tf.name, loading_e)
def test_shutdown(self): self.tfm.robot_adapter = self.rcm self.tfm.brain_adapter = self.bcm # add tf @nrp.MapRobotSubscriber("camera", Husky.Eye.camera) @nrp.MapSpikeSink("device", nrp.brain.actors[1], nrp.leaky_integrator_alpha) @nrp.Robot2Neuron() def camera_trans(t, camera, device): pass # add flawed tf tf_name = "tf_name" tf_src = "def tf_name(self): pass" tf_error = Exception() nrp.set_flawed_transfer_function(tf_src, tf_name, tf_error) self.tfm.initialize("tfnode") self.tfm.shutdown() self.assertEqual(len(self.tfm.n2r), 0) self.assertEqual(len(self.tfm.r2n), 0) self.assertEqual(len(self.tfm.flawed), 0) self.assertEqual(len(self.tfm.global_data), 0) self.assertFalse(self.tfm.initialized)
def test_delete_flawed_tf(self): nrp.start_new_tf_manager() tf_name = "tf_name" tf_src = "def tf_name(self): pass" tf_error = Exception() nrp.set_flawed_transfer_function(tf_src, tf_name, tf_error) result = nrp.delete_flawed_transfer_function(tf_name) self.assertTrue(result) # can't find it anymore self.assertIsNone(nrp.get_flawed_transfer_function(tf_name))
def test_set_flawed_tf(self): nrp.start_new_tf_manager() tf_name = "tf_name" tf_src = "def tf_name(self): pass" tf_error = Exception() nrp.set_flawed_transfer_function(tf_src, tf_name, tf_error) # check if correctly added flawed_tf = nrp.get_flawed_transfer_function(tf_name) self.assertEqual(flawed_tf.name, tf_name) self.assertEqual(flawed_tf.source, tf_src) self.assertTrue(flawed_tf.error is tf_error)
def test_get_transfer_functions(self): tf_name = "tf_name" tf_src = "def tf_name(self): pass" tf_error = Exception() nrp.set_flawed_transfer_function(tf_src, tf_name, tf_error) # get also flawed tfs tfs = self.tfm.transfer_functions(flawed=True) self.assertEqual(tfs[0].name, tf_name) # get only proper tfs tfs = self.tfm.transfer_functions(flawed=False) self.assertEqual(len(tfs), 0)
def __set_transfer_function(self, request, new): """ Patch a transfer function. This method is called when adding or editing a transfer function. :param request: The mandatory rospy request parameter :param new: A boolean indicating whether a transfer function is being added or modified. :return: empty string for a successful compilation in restricted mode (executed synchronously), an error message otherwise. """ new_source = textwrap.dedent(request.transfer_function_source) logger.info( "About to compile transfer function with the following python code: \n" + repr(new_source)) # Make sure the TF has exactly one function definition get_tf_name_outcome, get_tf_name_outcome_value = self.get_tf_name( new_source) if get_tf_name_outcome is True: new_name = get_tf_name_outcome_value else: error_message = get_tf_name_outcome_value self.publish_error(CLEError.SOURCE_TYPE_TRANSFER_FUNCTION, "NoOrMultipleNames", error_message, severity=CLEError.SEVERITY_ERROR) return error_message if not new: original_name = request.transfer_function_name else: original_name = None # Make sure function name is not a duplicate if new or (new_name != original_name): try: self.__check_duplicate_tf_name(new_name) except ValueError as value_e: message = "duplicate Transfer Function name" # Select the correct function to highlight function_name = new_name if original_name is None else original_name self._publish_error_from_exception(value_e, new_name) if new: tf_framework.set_flawed_transfer_function( new_source, function_name, value_e) return message # Compile (synchronously) transfer function's new code in restricted mode new_code = None try: new_code = compile_restricted(new_source, '<string>', 'exec') # pylint: disable=broad-except except Exception as e: message = "Error while compiling the updated" \ + " transfer function named " + new_name \ + " in restricted mode.\n" \ + str(e) if new: tf_framework.set_flawed_transfer_function( new_source, new_name, e) self._publish_error_from_exception(e, new_name) return message # Make sure CLE is stopped. If already stopped, these calls are harmless. # (Execution of updated code is asynchronous) running = self.__cle.running err = "" if running: self.__cle.stop() # Try to load the TF try: # When editing a TF (i.e. not new), delete it before loading the new one if not new and original_name is not None: tf_framework.delete_transfer_function(original_name) tf_framework.set_transfer_function(new_source, new_code, new_name) except TFLoadingException as e: self.publish_error(CLEError.SOURCE_TYPE_TRANSFER_FUNCTION, "Loading", e.message, severity=CLEError.SEVERITY_ERROR, function_name=e.tf_name) err = e.message tf_framework.set_flawed_transfer_function(new_source, new_name, e) if running: self.__cle.start() return err