Dropping support for Python 2

axelrod/__init__.py

@@ -1,4 +1,3 @@
-from __future__ import absolute_import
 import os
 
 on_windows = os.name == 'nt'

axelrod/deterministic_cache.py

@@ -1,9 +1,4 @@
-try:
-    # Python 2.x
-    from UserDict import UserDict
-except ImportError:
-    # Python 3.x
-    from collections import UserDict
+from collections import UserDict
 import pickle
 
 from axelrod import Player
@@ -41,7 +36,7 @@ def __init__(self, file_name=None):
         file_name : string
             Path to a previously saved cache file
         """
-        UserDict.__init__(self)
+        super().__init__()
         self.mutable = True
         if file_name is not None:
             self.load(file_name)
@@ -56,13 +51,13 @@ def _key_transform(self, key):
         return key[0].name, key[1].name, key[2]
 
     def __delitem__(self, key):
-        return UserDict.__delitem__(self, self._key_transform(key))
+        return super().__delitem__(self._key_transform(key))
 
     def __getitem__(self, key):
-        return UserDict.__getitem__(self, self._key_transform(key))
+        return super().__getitem__(self._key_transform(key))
 
     def __contains__(self, key):
-        return UserDict.__contains__(self, self._key_transform(key))
+        return super().__contains__(self._key_transform(key))
 
     def __setitem__(self, key, value):
         """Overrides the UserDict.__setitem__ method in order to validate
@@ -78,7 +73,7 @@ def __setitem__(self, key, value):
             raise ValueError(
                 'Value must be a list with length equal to turns attribute')
 
-        UserDict.__setitem__(self, self._key_transform(key), value)
+        super().__setitem__(self._key_transform(key), value)
 
     def _is_valid_key(self, key):
         """Validate a proposed dictionary key

axelrod/ecosystem.py

@@ -24,10 +24,10 @@ def __init__(self, results, fitness=None, population=None):
             elif len(population) != self.nplayers:
                 raise TypeError("Population vector must be same size as number of players")
             else:
-                norm = float(sum(population))
+                norm = sum(population)
                 self.population_sizes = [[p / norm for p in population]]
         else:
-            self.population_sizes = [[1.0 / self.nplayers for i in range(self.nplayers)]]
+            self.population_sizes = [[1 / self.nplayers for i in range(self.nplayers)]]
 
         # This function is quite arbitrary and probably only influences the
         # kinetics for the current code.

axelrod/interaction_utils.py

@@ -46,7 +46,7 @@ def compute_final_score_per_turn(interactions, game=None):
         return None
 
     final_score_per_turn = tuple(
-        sum([score[player_index] for score in scores]) / (float(num_turns))
+        sum([score[player_index] for score in scores]) / num_turns
         for player_index in [0, 1])
     return final_score_per_turn
 
@@ -83,7 +83,7 @@ def compute_normalised_cooperation(interactions):
     num_turns = len(interactions)
     cooperation = compute_cooperations(interactions)
 
-    normalised_cooperation = tuple([c / float(num_turns) for c in cooperation])
+    normalised_cooperation = tuple([c / num_turns for c in cooperation])
 
     return normalised_cooperation
 
@@ -129,30 +129,27 @@ def compute_normalised_state_distribution(interactions):
         return None
 
     interactions_count = Counter(interactions)
-    total = sum(interactions_count.values(), 0.0)
-    # By starting the sum with 0.0 we make sure total is a floating point value,
-    # avoiding the Python 2 floor division behaviour of / with integer operands
-    # (Stack Overflow)
+    total = sum(interactions_count.values(), 0)
 
     normalized_count = Counter({key: value / total for key, value in
                                 interactions_count.items()})
     return normalized_count
 
 
-def sparkline(actions, c_symbol=u'█', d_symbol=u' '):
-    return u''.join([
+def sparkline(actions, c_symbol='█', d_symbol=' '):
+    return ''.join([
         c_symbol if play == 'C' else d_symbol for play in actions])
 
 
-def compute_sparklines(interactions, c_symbol=u'█', d_symbol=u' '):
+def compute_sparklines(interactions, c_symbol='█', d_symbol=' '):
     """Returns the sparklines for a set of interactions"""
     if len(interactions) == 0:
         return None
 
     histories = list(zip(*interactions))
     return (
         sparkline(histories[0], c_symbol, d_symbol) +
-        u'\n' +
+        '\n' +
         sparkline(histories[1], c_symbol, d_symbol))
 
 

axelrod/match.py

@@ -171,7 +171,7 @@ def normalised_state_distribution(self):
         """
         return iu.compute_normalised_state_distribution(self.result)
 
-    def sparklines(self, c_symbol=u'█', d_symbol=u' '):
+    def sparklines(self, c_symbol='█', d_symbol=' '):
         return iu.compute_sparklines(self.result, c_symbol, d_symbol)
 
     def __len__(self):

axelrod/match_generator.py

@@ -1,4 +1,3 @@
-from __future__ import division
 from math import ceil, log
 import random
 
@@ -113,7 +112,7 @@ def __init__(self, players, prob_end, game, repetitions, noise=0):
         noise : float, 0
             The probability that a player's intended action should be flipped
         """
-        super(ProbEndRoundRobinMatches, self).__init__(
+        super().__init__(
             players, turns=float("inf"), game=game, repetitions=repetitions,
             noise=noise)
         self.prob_end = prob_end
@@ -165,7 +164,7 @@ def sample_length(self):
 
     def estimated_size(self):
         """Rough estimate of the number of matches that will be generated."""
-        size = self.__len__() * (1. / self.prob_end) * self.repetitions
+        size = self.__len__() * (1 / self.prob_end) * self.repetitions
         return size
 
 
@@ -221,8 +220,7 @@ def __init__(self, players, turns, game, repetitions, edges, noise=0):
         if not graph_is_connected(edges, players):
             raise ValueError("The graph edges do not include all players.")
         self.edges = edges
-        super(SpatialMatches, self).__init__(players, turns, game, repetitions,
-                                             noise)
+        super().__init__(players, turns, game, repetitions, noise)
 
     def build_match_chunks(self):
         for edge in self.edges:

axelrod/mock_player.py

@@ -12,7 +12,7 @@ class MockPlayer(Player):
     def __init__(self, player, move):
         # Need to retain history for opponents that examine opponents history
         # Do a deep copy just to be safe
-        Player.__init__(self)
+        super().__init__()
         self.history = copy.deepcopy(player.history)
         self.cooperations = player.cooperations
         self.defections = player.defections

axelrod/moran.py

@@ -304,7 +304,7 @@ def __init__(self, players, interaction_graph, reproduction_graph=None,
         match_class: subclass of Match
             The match type to use for scoring
         """
-        MoranProcess.__init__(self, players, turns=turns, noise=noise,
+        super().__init__(players, turns=turns, noise=noise,
                               deterministic_cache=deterministic_cache,
                               mutation_rate=mutation_rate, mode=mode)
         if not reproduction_graph:

axelrod/plot.py

@@ -233,7 +233,7 @@ def stackplot(self, eco, title=None, logscale=True, ax=None):
         ticks = []
         for i, n in enumerate(self.result_set.ranked_names):
             x = -0.01
-            y = (i + 0.5) * 1.0 / self.result_set.nplayers
+            y = (i + 0.5) * 1 / self.result_set.nplayers
             ax.annotate(n, xy=(x, y), xycoords=trans, clip_on=False,
                              va='center', ha='right', fontsize=5)
             ticks.append(y)

axelrod/result_set.py

@@ -200,7 +200,7 @@ def _build_cooperating_rating(self):
                    enumerate(total_length_v_opponent)]
 
         # Max is to deal with edge cases of matches that have no turns
-        return [sum(cs) / max(1, float(sum(ls))) for cs, ls
+        return [sum(cs) / max(1, sum(ls)) for cs, ls
                 in zip(self.cooperation, lengths)]
 
     @update_progress_bar
@@ -354,7 +354,7 @@ def _build_normalised_state_distribution(self):
             counters = []
             for counter in player:
                 total = sum(counter.values())
-                counters.append(Counter({key: float(value) / total for
+                counters.append(Counter({key: value / total for
                                          key, value in counter.items()}))
             norm.append(counters)
         return norm
@@ -622,7 +622,7 @@ def _build_good_partner_rating(self):
         attribute
         """
         return [sum(self.good_partner_matrix[player]) /
-                max(1, float(self.total_interactions[player]))
+                max(1, self.total_interactions[player])
                 for player in range(self.nplayers)]
 
     @update_progress_bar
@@ -632,7 +632,7 @@ def _build_initial_cooperation_rate(self):
         cooperation rate attribute
         """
         return [self.initial_cooperation_count[player] /
-                max(1, float(self.total_interactions[player]))
+                max(1, self.total_interactions[player])
                 for player in range(self.nplayers)]
 
     def _build_score_related_metrics(self, progress_bar=False,
@@ -783,7 +783,7 @@ def summarise(self):
                 p = sum([opp[state] for j, opp in enumerate(player) if i != j])
                 counts.append(p)
             try:
-                counts = [float(c) / sum(counts) for c in counts]
+                counts = [c / sum(counts) for c in counts]
             except ZeroDivisionError:
                 counts = [0 for c in counts]
             state_prob.append(counts)

axelrod/strategies/_strategies.py

@@ -1,5 +1,3 @@
-from __future__ import absolute_import
-
 from .alternator import Alternator
 from .adaptive import Adaptive
 from .ann import EvolvedANN, EvolvedANN5, EvolvedANNNoise05

axelrod/strategies/adaptive.py

@@ -26,7 +26,7 @@ class Adaptive(Player):
 
     @init_args
     def __init__(self, initial_plays=None):
-        Player.__init__(self)
+        super().__init__()
         if not initial_plays:
             initial_plays = [C] * 6 + [D] * 5
         self.initial_plays = initial_plays
@@ -53,5 +53,5 @@ def strategy(self, opponent):
         return D
 
     def reset(self):
-        Player.reset(self)
+        super().reset()
         self.scores = {C: 0, D: 0}

axelrod/strategies/ann.py

@@ -64,7 +64,7 @@ class ANN(Player):
 
     @init_args
     def __init__(self, weights, num_features, num_hidden):
-        Player.__init__(self)
+        super().__init__()
         (i2h, h2o, bias) = split_weights(weights, num_features, num_hidden)
         self.input_to_hidden_layer_weights = i2h
         self.hidden_to_output_layer_weights = h2o
@@ -192,7 +192,7 @@ class EvolvedANN(ANN):
     @init_args
     def __init__(self):
         num_features, num_hidden, weights = nn_weights["Evolved ANN"]
-        ANN.__init__(self, weights, num_features, num_hidden)
+        super().__init__(weights, num_features, num_hidden)
 
 
 class EvolvedANN5(ANN):
@@ -210,7 +210,7 @@ class EvolvedANN5(ANN):
     @init_args
     def __init__(self):
         num_features, num_hidden, weights = nn_weights["Evolved ANN 5"]
-        ANN.__init__(self, weights, num_features, num_hidden)
+        super().__init__(weights, num_features, num_hidden)
 
 
 class EvolvedANNNoise05(ANN):
@@ -228,4 +228,4 @@ class EvolvedANNNoise05(ANN):
     @init_args
     def __init__(self):
         num_features, num_hidden, weights = nn_weights["Evolved ANN 5 Noise 05"]
-        ANN.__init__(self, weights, num_features, num_hidden)
+        super().__init__(weights, num_features, num_hidden)

axelrod/strategies/apavlov.py

@@ -26,7 +26,7 @@ class APavlov2006(Player):
     }
 
     def __init__(self):
-        Player.__init__(self)
+        super().__init__()
         self.opponent_class = None
 
     def strategy(self, opponent):
@@ -66,7 +66,7 @@ def strategy(self, opponent):
         return C
 
     def reset(self):
-        Player.reset(self)
+        super().reset()
         self.opponent_class = None
 
 
@@ -93,7 +93,7 @@ class APavlov2011(Player):
     }
 
     def __init__(self):
-        Player.__init__(self)
+        super().__init__()
         self.opponent_class = None
 
     def strategy(self, opponent):
@@ -121,5 +121,5 @@ def strategy(self, opponent):
             return D if opponent.history[-1:] == [D] else C
 
     def reset(self):
-        Player.reset(self)
+        super().reset()
         self.opponent_class = None