def _get_neurons(neurons_dict):
"""
Get a list of Neuron object from a neuron dict
:param neurons_dict:
:return:
"""
neurons = list()
for neuron_dict in neurons_dict:
if isinstance(neuron_dict, dict):
if ConfigurationChecker().check_neuron_dict(neuron_dict):
# print "Neurons dict ok"
for neuron_name in neuron_dict:
name = neuron_name
parameters = neuron_dict[name]
# print parameters
new_neuron = Neuron(name=name, parameters=parameters)
neurons.append(new_neuron)
else:
# the neuron does not have parameter
if ConfigurationChecker().check_neuron_dict(neuron_dict):
new_neuron = Neuron(name=neuron_dict)
neurons.append(new_neuron)
return neurons
def _get_event_or_order_from_dict(signal_or_event_dict):
"""
The signal is either an Event or an Order
:param signal_or_event_dict: A dict of event or signal
:type signal_or_event_dict: dict
:return: The object corresponding to An Order or an Event
:rtype: An Order or an Event
:Example:
event_or_order = cls._get_event_or_order_from_dict(signal_dict)
.. seealso:: Event, Order
.. warnings:: Static method and Private
"""
if 'event' in signal_or_event_dict:
# print "is event"
event = signal_or_event_dict["event"]
if ConfigurationChecker.check_event_dict(event):
return Event(period=event)
if 'order' in signal_or_event_dict:
order = signal_or_event_dict["order"]
if ConfigurationChecker.check_order_dict(order):
return Order(sentence=order)
def get_brain(cls, file_path=None):
"""
return a brain object from YAML settings
:return: Brain object
:rtype: Brain
"""
# get the brain with dict
dict_brain = cls.get_yaml_config(file_path)
# create a new brain
brain = Brain()
# create list of Synapse
synapses = list()
for synapses_dict in dict_brain:
# print synapses_dict
# if the synapse is a list, it come from an include
if isinstance(synapses_dict, list):
synapses_dict = synapses_dict[0]
if ConfigurationChecker().check_synape_dict(synapses_dict):
# print "synapses_dict ok"
name = synapses_dict["name"]
neurons = cls._get_neurons(synapses_dict["neurons"])
signals = cls._get_signals(synapses_dict["signals"])
new_synapse = Synapse(name=name, neurons=neurons, signals=signals)
synapses.append(new_synapse)
brain.synapses = synapses
if file_path is None:
brain.brain_file = cls._get_root_brain_path()
else:
brain.brain_file = file_path
# check that no synapse have the same name than another
if ConfigurationChecker().check_synapes(synapses):
return brain
return None
def test_check_neuron_dict(self):
valid_neuron = {'say': {'message': ['test message']}}
invalid_neuron = {'not_existing_neuron': {'message': ['test message']}}
self.assertTrue(ConfigurationChecker.check_neuron_dict(valid_neuron))
with self.assertRaises(ModuleNotFoundError):
ConfigurationChecker.check_neuron_dict(invalid_neuron)
def test_check_event_dict(self):
valid_event = '0 * * * *'
invalid_event = None
invalid_event2 = ""
self.assertTrue(ConfigurationChecker.check_event_dict(valid_event))
with self.assertRaises(NoEventPeriod):
ConfigurationChecker.check_event_dict(invalid_event)
with self.assertRaises(NoEventPeriod):
ConfigurationChecker.check_event_dict(invalid_event2)
def test_check_order_dict(self):
valid_order = 'test_order'
invalid_order = ''
invalid_order2 = None
self.assertTrue(ConfigurationChecker.check_order_dict(valid_order))
with self.assertRaises(NoValidOrder):
ConfigurationChecker.check_order_dict(invalid_order)
with self.assertRaises(NoValidOrder):
ConfigurationChecker.check_order_dict(invalid_order2)
def test_check_signal_dict(self):
valid_signal_with_order = {'order': 'test_order'}
valid_signal_with_event = {'event': '0 * * * *'}
invalid_signal = {'invalid_option': 'test_order'}
self.assertTrue(
ConfigurationChecker.check_signal_dict(valid_signal_with_order))
self.assertTrue(
ConfigurationChecker.check_signal_dict(valid_signal_with_event))
with self.assertRaises(NoValidSignal):
ConfigurationChecker.check_signal_dict(invalid_signal)
def test_check_synapes(self):
synapse_1 = Synapse(name="test")
synapse_2 = Synapse(name="test2")
synapse_3 = Synapse(name="test")
valid_synapse_list = [synapse_1, synapse_2]
invalid_synapse_list = [synapse_1, synapse_3]
self.assertTrue(ConfigurationChecker.check_synapes(valid_synapse_list))
with self.assertRaises(MultipleSameSynapseName):
ConfigurationChecker.check_synapes(invalid_synapse_list)
def _get_event_or_order_from_dict(signal_or_event_dict):
if 'event' in signal_or_event_dict:
# print "is event"
event = signal_or_event_dict["event"]
if ConfigurationChecker.check_event_dict(event):
return Event(period=event)
if 'order' in signal_or_event_dict:
order = signal_or_event_dict["order"]
if ConfigurationChecker.check_order_dict(order):
return Order(sentence=order)
def get_brain(cls, file_path=None):
"""
Class Methods which loads default or the provided YAML file and return a Brain
:param file_path: the brain file path to load
:type file_path: String
:return: The loaded Brain
:rtype: Brain
:Example:
brain = BrainLoader.get_brain(file_path="/var/tmp/brain.yml")
.. seealso:: Brain
.. warnings:: Class Method
"""
# Instantiate a brain
brain = Brain.Instance()
logger.debug("Is brain already loaded ? %r" % brain.is_loaded)
if brain.is_loaded is False:
# get the brain with dict
dict_brain = cls.get_yaml_config(file_path)
brain.brain_yaml = dict_brain
# create list of Synapse
synapses = list()
for synapses_dict in dict_brain:
if "includes" not in synapses_dict: # we don't need to check includes as it's not a synapse
if ConfigurationChecker().check_synape_dict(synapses_dict):
# print "synapses_dict ok"
name = synapses_dict["name"]
neurons = cls._get_neurons(synapses_dict["neurons"])
signals = cls._get_signals(synapses_dict["signals"])
new_synapse = Synapse(name=name,
neurons=neurons,
signals=signals)
synapses.append(new_synapse)
brain.synapses = synapses
if file_path is None:
brain.brain_file = cls._get_root_brain_path()
else:
brain.brain_file = file_path
# check that no synapse have the same name than another
if not ConfigurationChecker().check_synapes(synapses):
brain = None
# The Brain Singleton is loaded
brain.is_loaded = True
return brain
def _get_signals(cls, signals_dict):
"""
Get a list of Signal object from a signals dict
:param signals_dict: Signal name or dictionary of Signal_name/Signal_parameters
:type signals_dict: String or dict
:return: A list of Event and/or Order
:rtype: List
:Example:
signals = cls._get_signals(synapses_dict["signals"])
.. seealso:: Event, Order
.. warnings:: Class method and Private
"""
# print signals_dict
signals = list()
for signal_dict in signals_dict:
if ConfigurationChecker().check_signal_dict(signal_dict):
# print "Signals dict ok"
event_or_order = cls._get_event_or_order_from_dict(signal_dict)
signals.append(event_or_order)
return signals
def get_brain(self):
"""
Class Methods which loads default or the provided YAML file and return a Brain
:return: The loaded Brain
:rtype: Brain
:Example:
brain = BrainLoader.get_brain(file_path="/var/tmp/brain.yml")
.. seealso:: Brain
.. warnings:: Class Method
"""
# Instantiate a brain
brain = Brain()
# get the brain with dict
dict_brain = self.get_yaml_config()
brain.brain_yaml = dict_brain
# create list of Synapse
synapses = list()
for synapses_dict in dict_brain:
if "includes" not in synapses_dict: # we don't need to check includes as it's not a synapse
if ConfigurationChecker().check_synape_dict(synapses_dict):
# print "synapses_dict ok"
name = synapses_dict["name"]
neurons = self._get_neurons(synapses_dict["neurons"])
signals = self._get_signals(synapses_dict["signals"])
new_synapse = Synapse(name=name,
neurons=neurons,
signals=signals)
synapses.append(new_synapse)
brain.synapses = synapses
if self.file_path is None:
brain.brain_file = self._get_root_brain_path()
else:
brain.brain_file = self.file_path
# check that no synapse have the same name than another
if not ConfigurationChecker().check_synapes(synapses):
brain = None
return brain
def _get_signals(cls, signals_dict):
# print signals_dict
signals = list()
for signal_dict in signals_dict:
if ConfigurationChecker().check_signal_dict(signal_dict):
# print "Signals dict ok"
event_or_order = cls._get_event_or_order_from_dict(signal_dict)
signals.append(event_or_order)
return signals
def test_check_synape_dict(self):
valid_synapse_dict = {
'signals': [{
'order': 'test_order'
}],
'neurons': [{
'say': {
'message': ['test message']
}
}],
'name': 'test'
}
synapse_dict_without_name = {
'signals': [{
'order': 'test_order'
}],
'neurons': [{
'say': {
'message': ['test message']
}
}]
}
synapse_dict_without_neurons = {
'signals': [{
'order': 'test_order'
}],
'name': 'test'
}
synapse_dict_without_signals = {
'neurons': [{
'say': {
'message': ['test message']
}
}],
'name': 'test'
}
self.assertTrue(
ConfigurationChecker.check_synape_dict(valid_synapse_dict))
with self.assertRaises(NoSynapeName):
ConfigurationChecker.check_synape_dict(synapse_dict_without_name)
with self.assertRaises(NoSynapeNeurons):
ConfigurationChecker.check_synape_dict(
synapse_dict_without_neurons)
with self.assertRaises(NoSynapeSignals):
ConfigurationChecker.check_synape_dict(
synapse_dict_without_signals)
def _get_neurons(neurons_dict):
"""
Get a list of Neuron object from a neuron dict
:param neurons_dict: Neuron name or dictionary of Neuron_name/Neuron_parameters
:type neurons_dict: String or dict
:return: A list of Neurons
:rtype: List
:Example:
neurons = cls._get_neurons(synapses_dict["neurons"])
.. seealso:: Neuron
.. warnings:: Static and Private
"""
neurons = list()
for neuron_dict in neurons_dict:
if isinstance(neuron_dict, dict):
if ConfigurationChecker().check_neuron_dict(neuron_dict):
# print "Neurons dict ok"
for neuron_name in neuron_dict:
name = neuron_name
parameters = neuron_dict[name]
# print parameters
new_neuron = Neuron(name=name, parameters=parameters)
neurons.append(new_neuron)
else:
# the neuron does not have parameter
if ConfigurationChecker().check_neuron_dict(neuron_dict):
new_neuron = Neuron(name=neuron_dict)
neurons.append(new_neuron)
return neurons