Added synchronous implementation of Matches & Tournaments

erik-sn · erik-sn · commit 8570dc9b73cf · 2017-04-19T22:14:39.000-04:00
Created a ViewSet for both Matches and Tournaments, added them to the url
configuration, and created serializers to validate POST data.

These ViewSets inherit a base class that handles the HTTP requests and
pass parameters to their respective axelrod classes (Match/Tournament).

Created a ResultsSerializer class to serialize axelrod results into a
json response.
diff --git a/api/config/urls.py b/api/config/urls.py
@@ -1,7 +1,11 @@
 from django.conf import settings
 from django.conf.urls import url, include
 from rest_framework.routers import DefaultRouter
-from api.core.views import StrategyViewSet
+from api.core.views import (
+    MatchViewSet,
+    StrategyViewSet,
+    TournamentViewSet,
+)
 
 
 urlpatterns = [
@@ -17,7 +21,9 @@
 router = DefaultRouter()
 
 routes = {
-    'strategies': StrategyViewSet
+    'matches': MatchViewSet,
+    'strategies': StrategyViewSet,
+    'tournaments': TournamentViewSet,
 }
 
 for route, viewset in routes.items():
diff --git a/api/core/models.py b/api/core/models.py
@@ -0,0 +1,139 @@
+from rest_framework import serializers
+from django.contrib.postgres.fields import JSONField
+from django.db.models import (
+    AutoField,
+    BooleanField,
+    DateTimeField,
+    CharField,
+    ForeignKey,
+    IntegerField,
+    TextField,
+    FloatField,
+    Model,
+)
+import axelrod
+
+
+CHEATING_NAMES = [strategy.__name__ for strategy in axelrod.cheating_strategies]
+
+# class Tournament(Model):
+
+#     PENDING = 0
+#     RUNNING = 1
+#     SUCCESS = 2
+#     FAILED = 3
+
+#     STATUS_CHOICES = (
+#         (PENDING, 'PENDING'),
+#         (RUNNING, 'RUNNING'),
+#         (SUCCESS, 'SUCCESS'),
+#         (FAILED, 'FAILED'),
+#     )
+
+#     # Fields
+#     created = DateTimeField(auto_now_add=True, editable=False)
+#     last_updated = DateTimeField(auto_now=True, editable=False)
+#     status = IntegerField(choices=STATUS_CHOICES, default=PENDING)
+#     results = JSONField()
+
+
+#     class Meta:
+#         ordering = ('-created',)
+
+#     def __unicode__(self):
+#         return u'%s' % self.id
+
+#     def get_absolute_url(self):
+#         return reverse('core_tournament_detail', args=(self.id,))
+
+#     def get_update_url(self):
+#         return reverse('core_tournament_update', args=(self.id,))
+
+#     def get_results_url(self):
+#         return reverse('core_tournament_results', args=(self.id,))
+
+#     def to_json(self):
+#         json_results = []
+#         if self.results:
+#             for (player, scores) in self.results:
+#                 json_results.append({"player": player, "scores": scores})
+
+#         json_results = {
+#             "results": json_results,
+#             "meta": {
+#                 "definition": self.tournament_definition.to_json(),
+#                 "cheating_strategies": CHEATING_NAMES
+#             }
+#         }
+
+#         return json_results
+
+#     def run(self):
+
+#         if self.status != Tournament.PENDING:
+#             raise Exception(
+#                 u'[tournament %d, current status: %s] SKIPPED !' % (
+#                     self.id, self.get_status_display()))
+
+#         try:
+#             self.status = Tournament.RUNNING
+#             self.save(update_fields=['status', ])
+
+#             start = datetime.now()
+
+#             players = json.loads(self.tournament_definition.players)
+
+#             strategies = []
+#             for strategy_str, number_of_players in players.items():
+#                 for i in range(0, int(number_of_players or 0)):
+#                     strategies.append(getattr(axelrod, strategy_str)())
+
+#             tournament_runner = axelrod.Tournament(
+#                 players=strategies,
+#                 turns=self.tournament_definition.turns,
+#                 repetitions=self.tournament_definition.repetitions,
+#                 noise=self.tournament_definition.noise)
+#             result_set = tournament_runner.play()
+
+#             self.results = []
+#             for rank in result_set.ranking:
+#                 player = tournament_runner.players[rank].name
+#                 scores = result_set.normalised_scores[rank]
+#                 self.results.append((player, scores))
+
+#             end = datetime.now()
+#             duration = (end - start).seconds
+
+#             # TODO: save duration
+#             # self.duration = duration
+#             self.status = Tournament.SUCCESS
+#             self.save(update_fields=['status', 'results'])
+
+#         except Exception as e:
+#             # log errors and set tournament status to aborted
+#             self.status = Tournament.FAILED
+#             self.save(update_fields=['status', ])
+#             # TODO: eventually save error message in model
+
+
+class TournamentDefinition(Model):
+    # Fields
+    name = CharField(max_length=255)
+    created = DateTimeField(auto_now_add=True, editable=False)
+    last_updated = DateTimeField(auto_now=True, editable=False)
+    turns = IntegerField()
+    repetitions = IntegerField()
+    noise = FloatField()
+    with_morality = BooleanField()
+    player_list = serializers.ListField(child=serializers.CharField())
+    players = []
+
+    # Relationship Fields
+    # tournament = ForeignKey('Tournament',)
+
+
+class MatchDefinition(Model):
+    turns = IntegerField()
+    noise = FloatField()
+    player_list = serializers.ListField(child=serializers.CharField())
+    players = []
diff --git a/api/core/serializers.py b/api/core/serializers.py
@@ -1,5 +1,10 @@
+import inspect
+import json
 from rest_framework import serializers
 from rest_framework.reverse import reverse
+from rest_framework.response import Response
+
+from . import models
 
 
 def strategy_id(strategy):
@@ -38,3 +43,52 @@ def get_params(self, strategy):
         if 'memory_depth' in params and params['memory_depth'] == float('inf'):
             params['memory_depth'] = -1
         return params
+
+
+class TournamentSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = models.TournamentDefinition
+        fields = ('name', 'created', 'last_updated', 'turns',
+                  'repetitions', 'noise', 'with_morality', 'players')
+
+
+class MatchSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = models.MatchDefinition
+        fields = ('turns', 'noise', 'players')
+
+
+class ResultsSerializer:
+
+    data = None
+
+    def __init__(self, results):
+        results_object = self.serialize_state_distributions(results)
+        for key, value in results.__dict__.items():
+            try:
+                json.dumps(key)
+                json.dumps(value)
+                results_object[key] = value
+            except TypeError:
+                pass
+        self.data = results_object
+
+    def serialize_state_distributions(self, results):
+        keys = [
+            'state_distribution',
+            'normalised_state_distribution',
+            'state_to_action_distribution',
+            'normalised_state_to_action_distribution'
+        ]
+        return {
+            key: self.serialize_state_distribution(getattr(results, key))
+            for key in keys
+        }
+
+    def serialize_state_distribution(self, state_distribution):
+        distribution = []
+        for row in state_distribution:
+            distribution.append([c.most_common() for c in row])
+        return distribution
diff --git a/api/core/views.py b/api/core/views.py
@@ -3,7 +3,13 @@
 from rest_framework import viewsets
 from rest_framework.response import Response
 import axelrod as axl
-from api.core.serializers import StrategySerializer, strategy_id
+from api.core.serializers import (
+    strategy_id,
+    MatchSerializer,
+    StrategySerializer,
+    TournamentSerializer,
+)
+from api.core.serializers import ResultsSerializer
 
 
 def filter_strategies(request):
@@ -58,3 +64,53 @@ def retrieve(self, request, pk=None):
             raise Http404
         serializer = StrategySerializer(strategy, context={'request': request})
         return Response(serializer.data)
+
+
+class BaseTournamentView:
+    """
+
+    """
+
+    strategies_index = {strategy_id(s): s for s in axl.strategies}
+    _not_found_error = 'Strategy {} was not found'
+
+    def parse_players(self, player_list):
+        players = []
+        for player in player_list:
+            strategy = self.strategies_index[player]
+            players.append(strategy())
+        return players
+
+    def create(self, request):
+        data = request.data
+        serializer = self.serializer(data=data)
+        if serializer.is_valid():
+            tournament_definition = serializer.data
+            try:
+                players = self.parse_players(data['player_list'])
+            except KeyError as e:
+                return Response({'player_list': self._not_found_error.format(e.args[0])})
+
+            results = self.run(players, tournament_definition)
+            return Response(ResultsSerializer(results).data, 200)
+        return Response(serializer.errors, 400)
+
+
+class TournamentViewSet(viewsets.ViewSet, BaseTournamentView):
+
+    serializer = TournamentSerializer
+
+    @staticmethod
+    def run(players, definition):
+        tournament = axl.Tournament(players=players, **definition)
+        return tournament.play()
+
+
+class MatchViewSet(viewsets.ViewSet, BaseTournamentView):
+
+    serializer = MatchSerializer
+
+    @staticmethod
+    def run(players, definition):
+        match = axl.Match(players=players, **definition)
+        return match.play()
