Remove custom serialization methods for evolvable players

Author: marcharper

axelrod/strategies/ann.py

@@ -278,21 +278,6 @@ def crossover(self, other):
         weights = crossover_lists(self.weights, other.weights)
         return self.create_new(weights=weights)
 
-    def serialize_parameters(self):
-        return "{}:{}:{}".format(
-                self.num_features,
-                self.num_hidden,
-                ':'.join(map(str, self.weights))
-            )
-
-    @classmethod
-    def deserialize_parameters(cls, serialized):
-        elements = list(map(float, serialized.split(':')))
-        num_features = int(elements[0])
-        num_hidden = int(elements[1])
-        weights = elements[2:]
-        return cls(num_features, num_hidden, weights)
-
 
 class EvolvedANN(ANN):
     """

axelrod/strategies/cycler.py

@@ -165,22 +165,6 @@ def crossover(self, other):
         cycle, _ = self._normalize_parameters(cycle)
         return self.create_new(cycle=cycle)
 
-    def serialize_parameters(self):
-        return "{}:{}:{}".format(
-                actions_to_str(self.cycle),
-                str(self.mutation_probability),
-                str(self.mutation_potency)
-        )
-
-    @classmethod
-    def deserialize_parameters(cls, serialized):
-        cycle, mutation_probability, mutation_potency = list(serialized.split(':'))
-        return cls(
-            cycle=cycle,
-            mutation_probability=float(mutation_probability),
-            mutation_potency=int(mutation_potency)
-        )
-
 
 class CyclerDC(Cycler):
     """

axelrod/strategies/finite_state_machines.py

@@ -290,44 +290,6 @@ def create_vector_bounds(self):
         ub = [1] * size
         return lb, ub
 
-    @staticmethod
-    def repr_rows(rows):
-        ss = []
-        for row in rows:
-            ss.append("_".join(list(map(str, row))))
-        return "|".join(ss)
-
-    def serialize_parameters(self):
-        return "{}:{}:{}:{}".format(
-            self.num_states,
-            self.initial_state,
-            self.initial_action,
-            self.repr_rows(self.fsm.transitions())
-        )
-
-    @classmethod
-    def deserialize_parameters(cls, serialized):
-        rows = []
-        lines = serialized.split(':')
-        num_states = int(lines[0])
-        initial_state = int(lines[1])
-        initial_action = Action.from_char(lines[2])
-
-        for line in lines[3].split('|'):
-            row = []
-            for element in line.split('_'):
-                try:
-                    row.append(Action.from_char(element))
-                except UnknownActionError:
-                    row.append(int(element))
-            rows.append(tuple(row))
-        return cls(
-            transitions=tuple(rows),
-            initial_state=initial_state,
-            initial_action=initial_action,
-            num_states=num_states
-        )
-
 
 class Fortress3(FSMPlayer):
     """Finite state machine player specified in http://DOI.org/10.1109/CEC.2006.1688322.

axelrod/strategies/gambler.py

@@ -99,24 +99,6 @@ def mutate_value(cls, value):
             value = 1
         return value
 
-    def serialize_parameters(self):
-        self_depth, op_depth, op_openings_depth = self.parameters
-        return "{}:{}:{}:{}:{}".format(
-            self_depth,
-            op_depth,
-            op_openings_depth,
-            '|'.join(str(v) for v in self.pattern),
-            actions_to_str(self.initial_actions)
-        )
-
-    @classmethod
-    def deserialize_parameters(cls, serialized):
-        s = serialized.split(':')
-        parameters = tuple(map(int, s[0:3]))
-        pattern = list(map(float, s[3].split('|')))
-        initial_actions = str_to_actions(s[4])
-        return cls(parameters=parameters, pattern=pattern, initial_actions=initial_actions)
-
     def receive_vector(self, vector):
         """Receives a vector and updates the player's pattern. Ignores extra parameters."""
         self.pattern = vector

axelrod/strategies/hmm.py

@@ -346,53 +346,6 @@ def create_vector_bounds(self):
         ub = [1.0] * vec_len
         return lb, ub
 
-    @classmethod
-    def repr_rows(cls, rows):
-        ss = []
-        for row in rows:
-            ss.append("_".join(list(map(str, row))))
-        return "|".join(ss)
-
-    def serialize_parameters(self):
-        return "{}:{}:{}:{}:{}".format(
-            self.initial_state,
-            self.initial_action,
-            self.repr_rows(self.hmm.transitions_C),
-            self.repr_rows(self.hmm.transitions_D),
-            self.repr_rows([self.hmm.emission_probabilities])
-        )
-
-    @classmethod
-    def parse_vector(cls, line):
-        row = line.split('_')
-        row = list(map(float, row))
-        return row
-
-    @classmethod
-    def parse_matrix(cls, sm):
-        rows = []
-        lines = sm.split('|')
-        for line in lines:
-            rows.append(cls.parse_vector(line))
-        return rows
-
-    @classmethod
-    def deserialize_parameters(cls, serialized):
-        lines = serialized.split(':')
-        initial_state = int(lines[0])
-        initial_action = Action.from_char(lines[1])
-        t_C = cls.parse_matrix(lines[2])
-        t_D = cls.parse_matrix(lines[3])
-        p = cls.parse_vector(lines[4])
-        num_states = len(t_C)
-
-        return cls(num_states=num_states,
-                   transitions_C=t_C,
-                   transitions_D=t_D,
-                   emission_probabilities=p,
-                   initial_state=initial_state,
-                   initial_action=initial_action)
-
 
 class EvolvedHMM5(HMMPlayer):
     """

axelrod/strategies/lookerup.py

@@ -505,30 +505,6 @@ def crossover(self, other):
         lookup_dict = crossover_dictionaries(self.lookup_dict, other.lookup_dict)
         return self.create_new(lookup_dict=lookup_dict)
 
-    def serialize_parameters(self):
-        plays, op_plays, op_start_plays = self.parameters
-        return "{}:{}:{}:{}:{}".format(
-            plays,
-            op_plays,
-            op_start_plays,
-            actions_to_str(self.initial_actions),
-            actions_to_str([v for k, v in sorted(self.lookup_dict.items())])
-        )
-
-    @classmethod
-    def deserialize_parameters(cls, serialized):
-        elements = serialized.split(':')
-        plays, op_plays, op_start_plays = list(map(int, elements[:3]))
-        parameters = (plays, op_plays, op_start_plays)
-        initial_actions = str_to_actions(elements[3])
-        pattern = str_to_actions(elements[4])
-        keys = create_lookup_table_keys(plays, op_plays, op_start_plays)
-        lookup_dict = dict(zip(keys, pattern))
-        return cls(parameters=parameters,
-                   pattern=pattern,
-                   initial_actions=initial_actions,
-                   lookup_dict=lookup_dict)
-
 
 class EvolvedLookerUp1_1_1(LookerUp):
     """