|  | @@ -1,11 +1,11 @@
 | 
	
		
			
				|  |  |  # coding: utf8
 | 
	
		
			
				|  |  |  import re
 | 
	
		
			
				|  |  | +from collections import Counter
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  from core.Utils import Utils
 | 
	
		
			
				|  |  |  from core.ConfigurationManager.BrainLoader import BrainLoader
 | 
	
		
			
				|  |  |  from core.Models import Order
 | 
	
		
			
				|  |  |  from core.NeuroneLauncher import NeuroneLauncher
 | 
	
		
			
				|  |  | -from Cosine import *
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  import logging
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -23,6 +23,8 @@ class OrderAnalyser:
 | 
	
		
			
				|  |  |          """
 | 
	
		
			
				|  |  |          self.main_controller = main_controller
 | 
	
		
			
				|  |  |          self.order = order
 | 
	
		
			
				|  |  | +        if isinstance(self.order, str):
 | 
	
		
			
				|  |  | +            self.order = order.decode('utf-8')
 | 
	
		
			
				|  |  |          if brain_file is None:
 | 
	
		
			
				|  |  |              self.brain = BrainLoader.get_brain()
 | 
	
		
			
				|  |  |          else:
 | 
	
	
		
			
				|  | @@ -31,6 +33,7 @@ class OrderAnalyser:
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |      def start(self):
 | 
	
		
			
				|  |  |          synapses_found = False
 | 
	
		
			
				|  |  | +        problem_in_neuron_found = False
 | 
	
		
			
				|  |  |          for synapse in self.brain.synapses:
 | 
	
		
			
				|  |  |              for signal in synapse.signals:
 | 
	
		
			
				|  |  |                  if type(signal) == Order:
 | 
	
	
		
			
				|  | @@ -50,53 +53,41 @@ class OrderAnalyser:
 | 
	
		
			
				|  |  |                                      logger.debug("The neuron wait for parameter")
 | 
	
		
			
				|  |  |                                      # check that the user added parameters to his order
 | 
	
		
			
				|  |  |                                      if params is None:
 | 
	
		
			
				|  |  | -                                        # TODO: raise an error and break the program?
 | 
	
		
			
				|  |  | +                                        # we don't raise an error and break the program but we don't run the neuron
 | 
	
		
			
				|  |  | +                                        problem_in_neuron_found = True
 | 
	
		
			
				|  |  |                                          Utils.print_danger("Error: The neuron %s is waiting for argument. "
 | 
	
		
			
				|  |  |                                                             "Argument found in bracket in the given order" % neuron.name)
 | 
	
		
			
				|  |  |                                      else:
 | 
	
		
			
				|  |  |                                          # we add wanted arguments the existing neuron parameter dict
 | 
	
		
			
				|  |  |                                          for arg in neuron.parameters["args"]:
 | 
	
		
			
				|  |  |                                              if arg in params:
 | 
	
		
			
				|  |  | +                                                problem_in_neuron_found = True
 | 
	
		
			
				|  |  |                                                  logger.debug("Parameter %s added to the current parameter "
 | 
	
		
			
				|  |  |                                                               "of the neuron: %s" % (arg, neuron.name))
 | 
	
		
			
				|  |  |                                                  neuron.parameters[arg] = params[arg]
 | 
	
		
			
				|  |  |                                                  print params[arg]
 | 
	
		
			
				|  |  |                                              else:
 | 
	
		
			
				|  |  | -                                                # TODO: raise an error and break the program?
 | 
	
		
			
				|  |  | +                                                # we don't raise an error and break the program but
 | 
	
		
			
				|  |  | +                                                # we don't run the neuron
 | 
	
		
			
				|  |  |                                                  Utils.print_danger("Error: Argument \"%s\" not found in the"
 | 
	
		
			
				|  |  |                                                                     " order" % arg)
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -                            # neuron.parameters = dict(neuron.parameters.items() + params.items())
 | 
	
		
			
				|  |  | -                            print neuron.parameters
 | 
	
		
			
				|  |  | -                            NeuroneLauncher.start_neurone(neuron)
 | 
	
		
			
				|  |  | +                            # if no error detected, we run the neuron
 | 
	
		
			
				|  |  | +                            if not problem_in_neuron_found:
 | 
	
		
			
				|  |  | +                                NeuroneLauncher.start_neurone(neuron)
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |          if not synapses_found:
 | 
	
		
			
				|  |  |              Utils.print_info("No synapse match the captured order: %s" % self.order)
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -    def _spelt_order_match_brain_order(self, order_to_test):
 | 
	
		
			
				|  |  | -        """
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | -        test if the current order match the order spelt by the user
 | 
	
		
			
				|  |  | -        :param order_to_test:
 | 
	
		
			
				|  |  | -        :return:
 | 
	
		
			
				|  |  | -        """
 | 
	
		
			
				|  |  | -        # TODO : In "order_to_test" should we remove double brace and variable name before checking to optimise the cosine ?
 | 
	
		
			
				|  |  | -        user_vector = text_to_vector(self.order)
 | 
	
		
			
				|  |  | -        order_vector = text_to_vector(order_to_test)
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | -        cosine = get_cosine(user_vector, order_vector)
 | 
	
		
			
				|  |  | -        logger.debug("the cosine : %s, pour user_vector: %s , order_vector: %s" % (cosine, self.order, order_to_test))
 | 
	
		
			
				|  |  | -        return cosine >= 0.9
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  |      def _associate_order_params_to_values(self, order_to_check):
 | 
	
		
			
				|  |  |          """
 | 
	
		
			
				|  |  |          Associate the variables from the order to the incoming user order
 | 
	
		
			
				|  |  | -        :param order: the order to check
 | 
	
		
			
				|  |  | +        :param order_to_check: the order to check
 | 
	
		
			
				|  |  |          :return: the dict corresponding to the key / value of the params
 | 
	
		
			
				|  |  |          """
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | +        pattern = '\s+(?=[^\{\{\}\}]*\}\})'
 | 
	
		
			
				|  |  |          # Remove white spaces (if any) between the variable and the double brace then split
 | 
	
		
			
				|  |  | -        list_word_in_order = re.sub('\s+(?=[^\{\{\}\}]*\}\})', '', order_to_check).split()
 | 
	
		
			
				|  |  | +        list_word_in_order = re.sub(pattern, '', order_to_check).split()
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |          # get the order, defined by the first words before {{
 | 
	
		
			
				|  |  |          # /!\ Could be empty if order starts with double brace
 | 
	
	
		
			
				|  | @@ -107,38 +98,39 @@ class OrderAnalyser:
 | 
	
		
			
				|  |  |          truncate_list_word_said = truncate_user_sentence.split()
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |          # make dict var:value
 | 
	
		
			
				|  |  | -        dictVar = {}
 | 
	
		
			
				|  |  | +        dict_var = {}
 | 
	
		
			
				|  |  |          for idx, ow in enumerate(list_word_in_order):
 | 
	
		
			
				|  |  |              if self._is_containing_bracket(ow):
 | 
	
		
			
				|  |  |                  # remove bracket and grab the next value / stop value
 | 
	
		
			
				|  |  | -                varname = ow.replace("{{", "").replace("}}", "")
 | 
	
		
			
				|  |  | -                stopValue = self._get_next_value_list(list_word_in_order[idx:])
 | 
	
		
			
				|  |  | -                if stopValue is None:
 | 
	
		
			
				|  |  | -                    dictVar[varname] = " ".join(truncate_list_word_said)
 | 
	
		
			
				|  |  | +                var_name = ow.replace("{{", "").replace("}}", "")
 | 
	
		
			
				|  |  | +                stop_value = self._get_next_value_list(list_word_in_order[idx:])
 | 
	
		
			
				|  |  | +                if stop_value is None:
 | 
	
		
			
				|  |  | +                    dict_var[var_name] = " ".join(truncate_list_word_said)
 | 
	
		
			
				|  |  |                      break
 | 
	
		
			
				|  |  |                  for word_said in truncate_list_word_said:
 | 
	
		
			
				|  |  | -                    if word_said == stopValue: break
 | 
	
		
			
				|  |  | -                    if varname in dictVar:
 | 
	
		
			
				|  |  | -                        dictVar[varname] += " " + word_said
 | 
	
		
			
				|  |  | +                    if word_said == stop_value:
 | 
	
		
			
				|  |  | +                        break
 | 
	
		
			
				|  |  | +                    if var_name in dict_var:
 | 
	
		
			
				|  |  | +                        dict_var[var_name] += " " + word_said
 | 
	
		
			
				|  |  |                          truncate_list_word_said = truncate_list_word_said[1:]
 | 
	
		
			
				|  |  |                      else:
 | 
	
		
			
				|  |  | -                        dictVar[varname] = word_said
 | 
	
		
			
				|  |  | +                        dict_var[var_name] = word_said
 | 
	
		
			
				|  |  |              truncate_list_word_said = truncate_list_word_said[1:]
 | 
	
		
			
				|  |  | -        return dictVar
 | 
	
		
			
				|  |  | +        return dict_var
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |      @staticmethod
 | 
	
		
			
				|  |  |      def _is_containing_bracket(sentence):
 | 
	
		
			
				|  |  |          # print "sentence to test %s" % sentence
 | 
	
		
			
				|  |  |          pattern = r"{{|}}"
 | 
	
		
			
				|  |  |          # prog = re.compile(pattern)
 | 
	
		
			
				|  |  | -        bool = re.search(pattern, sentence)
 | 
	
		
			
				|  |  | -        if bool is not None:
 | 
	
		
			
				|  |  | +        check_bool = re.search(pattern, sentence)
 | 
	
		
			
				|  |  | +        if check_bool is not None:
 | 
	
		
			
				|  |  |              return True
 | 
	
		
			
				|  |  |          return False
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |      @staticmethod
 | 
	
		
			
				|  |  | -    def _get_next_value_list(list):
 | 
	
		
			
				|  |  | -        ite = list.__iter__()
 | 
	
		
			
				|  |  | +    def _get_next_value_list(list_to_check):
 | 
	
		
			
				|  |  | +        ite = list_to_check.__iter__()
 | 
	
		
			
				|  |  |          next(ite, None)
 | 
	
		
			
				|  |  |          return next(ite, None)
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -153,10 +145,8 @@ class OrderAnalyser:
 | 
	
		
			
				|  |  |          split_order_without_bracket = self._get_split_order_without_bracket(order_to_analyse)
 | 
	
		
			
				|  |  |          print split_order_without_bracket
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -        number_of_word_in_order = len(split_order_without_bracket)
 | 
	
		
			
				|  |  |          # if all words in the list of what the user said in in the list of word in the order
 | 
	
		
			
				|  |  | -        # return len(set(split_order_without_bracket).intersection(list_word_user_said)) == number_of_word_in_order
 | 
	
		
			
				|  |  | -        return self._counterSubset(split_order_without_bracket, list_word_user_said)
 | 
	
		
			
				|  |  | +        return self._counter_subset(split_order_without_bracket, list_word_user_said)
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |      @staticmethod
 | 
	
		
			
				|  |  |      def _get_split_order_without_bracket(order):
 | 
	
	
		
			
				|  | @@ -176,7 +166,7 @@ class OrderAnalyser:
 | 
	
		
			
				|  |  |          return split_order
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |      @staticmethod
 | 
	
		
			
				|  |  | -    def _counterSubset(list1, list2):
 | 
	
		
			
				|  |  | +    def _counter_subset(list1, list2):
 | 
	
		
			
				|  |  |          """
 | 
	
		
			
				|  |  |          check if the number of occurrences matches
 | 
	
		
			
				|  |  |          :param list1:
 | 
	
	
		
			
				|  | @@ -187,4 +177,4 @@ class OrderAnalyser:
 | 
	
		
			
				|  |  |          for k, n in c1.items():
 | 
	
		
			
				|  |  |              if n > c2[k]:
 | 
	
		
			
				|  |  |                  return False
 | 
	
		
			
				|  |  | -        return True
 | 
	
		
			
				|  |  | +        return True
 |