Index: stbatch/sans/batch/data_processor.py
===================================================================
--- testbatch/sans/batch/data_processor.py	(revision c1274d0cf6178e5f119ad428a1edcaae22e45ce1)
+++ 	(revision )
@@ -1,160 +1,0 @@
-"""
-This module implement a class that generates values given some inputs. The User apply a function to a sequence 
-of inputs and outputs are generated.
-"""
-import numpy
-
-
-class DataTable(object):
-    """
-    This class is store inputs as a dictionary of key (string) and values list of python objects.
-    It generates outputs given some function and its current inputs.
-    if an output object has an attribute "extract"   function returning attributes names and values 
-    relevant to this output then DataTable will map them  accordingly.
-    """
-    def __init__(self, inputs):
-        """
-        """
-        #array of inputs
-        self.__inputs_data = None
-        #array of outputs 
-        self.__outputs_data = None
-        #contains combinations of inputs and outputs
-        self__data = None
-        #the selected map function
-        self.__function = map
-        #the number of row in the array
-        self.length = 0
-        
-    def set_inputs(self, inputs):
-        """
-        Checks that inputs is a dictionary.
-        Checks that all values are list of same length.
-        Creates an array of dimension n x m and stores into self.__inputs_data
-        :param inputs: a dictionary of string as keys and values (list)  of same length
-        :example: inputs= {"data":[1, 2], "temperature":[30, 40]}
-                    result = self.set_value(inputs)
-                    assert result == [   ["data" "temperature"]
-                                        [1         30        ]
-                                        [2          40       ]]
-        """
-        
-    def get_inputs(self):
-        """
-        return array of inputs
-        """
-    def get_outputs(self):
-        """
-        return array of output value
-        """
-    def get_value(self):
-        """
-        Return current saved inputs and outputs
-        """
-        return self.__data
-    
-    def _mapply(self, arguments):
-        """
-        Receive a list of arguments where the fist item in the list is a function pointer
-        and the rest of items are argument to the function
-        :param arguments: arguments[0] is a function pointer
-                            arguments[1:] is possible parameters of that function
-        """
-        return apply(arguments[0], arguments[1:])
-    
-    def _compute(self, instance, func_name, *args):
-        """
-        Receive an instance of a class , a function name  and some possible arguments for the function
-        Generate result from that function
-        """
-        return getattr(instance, func)(*args)
-    
-    def compute(self,instances, func_names):
-        """
-        compute a series of values , the set the value of self.__outputs_data and self.__data
-        :param instances: list of instance of object
-        :param func_names: name of the function to use for mapping
-        
-        """
-        
-    def _extract_output(self, output):
-        """
-        receive an output which is a python object request extract_output function
-        in order to extract additional information about the output. If the output does
-        not have extract_output has attribute, the output is return as it is else
-        a dictionary of output attribute names is return as well as their corresponding
-        values 
-        :example:  class OutPut:
-                        a = 2
-                        b = 3
-                        out = OutPut()
-                    result = self.extract_output(out)
-                    assert result == {"a":2, "b":3}
-        """
-        
-    def select_map_function(self, mapper="default"):
-        """
-        given a key word defined [mapper] a map function is used to map object
-        available map functions are: built-in python map , processing map etc...
-        """
-  
-class DataProcessor(object):
-    """
-    Implement a singleton of DataTable
-    """
-    __data_table = DataTable()
-    
-    def set_inputs(self, inputs):
-        self.__data_table.set_inputs(inputs)
-        
-    def select_map_function(self, mapper="default"):
-        self.__data_table.select_map_function(mapper)
-        
-    def compute(self,instance, func_name):
-        return self.__data_table.compute(instance, func_name)
-        
-    def get_inputs(self):
-        """
-        return array of inputs
-        """
-        return self.__data_table.get_inputs()
-    
-    def get_outputs(self):
-        """
-        return array of output value
-        """
-        return self.__data_table.get_outputs()
-    
-    def get_value(self):
-        """
-        Return current saved inputs and outputs
-        """
-        return self.__data_table.get_value()
-    
-      
-  
-  
-if __name__ == "__main__":
-    a = numpy.array([['c','d']])  
-    c = numpy.array([2,3]) 
-    d = numpy.array([4,5])  
-    m = numpy.column_stack([c, d])
-    print numpy.concatenate((a, m))
-    # the way set_value will work
-    my_dict = {"c":[2,3], "d":[4, 5]}
-    if my_dict:
-        length = len(my_dict.values()[0])
-        index = []
-        for item in my_dict.values():
-            assert len(item) == length 
-        data = numpy.concatenate((numpy.array([my_dict.keys()]), numpy.column_stack( my_dict.values())))
-        print "Data"
-        print data
-        print data[1:]
-        print zip(data[1:1].T)
-        
-        
-        
-        
-    
-    
