extend interface + implement scrappy model parser(to be reworked)

DataParserFactory.py

@@ -24,12 +24,24 @@ class AbstractParser:
     def get_fi_curve_spiketimes(self):
         raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
 
+    def get_fi_frequency_traces(self):
+        raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
+
     def get_sampling_interval(self):
         raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
 
     def get_recording_times(self):
         raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
 
+    def traces_available(self) -> bool:
+        raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
+
+    def spiketimes_available(self) -> bool:
+        raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
+
+    def frequencies_available(self) -> bool:
+        raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
+
 
 class DatParser(AbstractParser):
 
@@ -42,6 +54,15 @@ class DatParser(AbstractParser):
         self.fi_recording_times = []
         self.sampling_interval = -1
 
+    def traces_available(self) -> bool:
+        return True
+
+    def frequencies_available(self) -> bool:
+        return False
+
+    def spiketimes_available(self) -> bool:
+        return True
+
     def cell_get_metadata(self):
         raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
 
@@ -62,6 +83,10 @@ class DatParser(AbstractParser):
     def get_fi_curve_traces(self):
         return self.__get_traces__("FICurve")
 
+    def get_fi_frequency_traces(self):
+        raise NotImplementedError("Not possible in .dat data type.\n"
+                                  "Please check availability with the x_available functions.")
+
     # TODO clean up/ rewrite
     def get_fi_curve_spiketimes(self):
         spiketimes = []
@@ -208,15 +233,69 @@ class DatParser(AbstractParser):
             raise RuntimeError(self.fi_file + " file doesn't exist!")
 
 
+# MODEL PARSER: ------------------------------
 
 class ModelParser(AbstractParser):
 
     def __init__(self, model: AbstractModel):
         self.model = model
 
+    def cell_get_metadata(self):
+        raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
+
+    def get_baseline_traces(self):
+        raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
+
+    def get_fi_curve_traces(self):
+        if not self.model.simulates_voltage_trace():
+            raise NotImplementedError("Model doesn't simulated voltage traces!")
 
+        traces = []
+        for stimulus in self.model.get_stimuli_for_fi_curve():
+            self.model.simulate(stimulus, self.model.total_stimulation_time_fi_curve)
+            traces.append(self.model.get_voltage_trace())
+
+        return traces
+
+    def get_fi_curve_spiketimes(self):
+        if not self.model.simulates_spiketimes():
+            raise NotImplementedError("Model doesn't simulated spiketimes!")
+
+        all_spiketimes = []
+        for stimulus in self.model.get_stimuli_for_fi_curve():
+            self.model.simulate(stimulus, self.model.total_stimulation_time_fi_curve)
+            all_spiketimes.append(self.model.get_spiketimes())
+
+        return all_spiketimes
+
+    def get_fi_frequency_traces(self):
+        if not self.model.simulates_frequency():
+            raise NotImplementedError("Model doesn't simulated frequency!")
+
+        frequency_traces = []
+        for stimulus in self.model.get_stimuli_for_fi_curve():
+            self.model.simulate(stimulus, self.model.total_stimulation_time_fi_curve)
+            frequency_traces.append(self.model.get_frequency())
+
+        return frequency_traces
+
+    def get_sampling_interval(self):
+        self.model.get_sampling_interval()
+
+    def get_recording_times(self):
+        raise NotImplementedError("NOT YET OVERRIDDEN FROM ABSTRACT CLASS")
+
+    def traces_available(self) -> bool:
+        return self.model.simulates_voltage_trace()
+
+    def spiketimes_available(self) -> bool:
+        return self.model.simulates_spiketimes()
+
+    def frequencies_available(self) -> bool:
+        return self.model.simulates_frequency()
 
 # TODO ####################################
+
 class NixParser(AbstractParser):
 
     def __init__(self, nix_file_path):
@@ -232,9 +311,9 @@ def get_parser(data_path) -> AbstractParser:
         return DatParser(data_path)
     elif data_format == NIX_FORMAT:
         return NixParser(data_path)
-    elif MODEL:
+    elif data_format == MODEL:
         return ModelParser(data_path)
-    elif UNKNOWN:
+    elif data_format == UNKNOWN:
         raise TypeError("DataParserFactory:get_parser(data_path):\nCannot determine type of data for:" + data_path)