Betting

Pipfile

@@ -15,3 +15,5 @@ pytest = "*"
 pycrypto = "==2.6.1"
 scrypt = "==0.8.0"
 aiohttp = "*"
+yarl = "*"
+async-timeout = "*"

scorum/graphenebase/betting/__init__.py

@@ -1,4 +1,5 @@
 from .game import Game
 from .market import Market
+from .wincase import Wincase
 
-__all__ = ["Game", "Market"]
+__all__ = ["Game", "Market", "Wincase"]

scorum/graphenebase/betting/game.py

@@ -1,13 +1,21 @@
-import struct
-from enum import Enum
+from scorum.graphenebase.objects import GrapheneObject, StaticVariantObject
 
+GAMES = [
+    'soccer_game',
+    'hockey_game'
+]
 
-class Game(Enum):
-    soccer = 0
-    hockey = 1
 
-    def __bytes__(self):
-        return struct.pack("<B", self.value)
+class Game(StaticVariantObject):
+    def __init__(self, game_type):
+        super().__init__(game_type, GAMES)
+        self.name = self.get_name(game_type) + "_game"
+        self.id = self.get_id(self.name)
 
-    def __str__(self):
-        return "{0}".format(self.name)
+
+class Soccer(GrapheneObject):
+    pass
+
+
+class Hockey(GrapheneObject):
+    pass

scorum/graphenebase/betting/market.py

@@ -1,50 +1,32 @@
-import json
-import re
 from collections import OrderedDict
 
-from scorum.graphenebase.graphene_types import Id, Uint16
-from scorum.graphenebase.objects import GrapheneObject
+from scorum.graphenebase.graphene_types import Int16
+from scorum.graphenebase.objects import GrapheneObject, StaticVariantObject
 
 MARKETS = [
-    "result_home_market",
-    "result_draw_market",
-    "result_away_market",
-    "round_market",
-    "handicap_market",
-    "correct_score_market",
-    "correct_score_parametrized_market",
-    "goal_market",
-    "total_market",
-    "total_goals_market",
+    "result_home",
+    "result_draw",
+    "result_away",
+    "round_home",
+    "handicap",
+    "correct_score_home",
+    "correct_score_draw",
+    "correct_score_away",
+    "correct_score",
+    "goal_home",
+    "goal_both",
+    "goal_away",
+    "total",
+    "total_goals_home",
+    "total_goals_away"
 ]
 
 
-class Market:
+class Market(StaticVariantObject):
     def __init__(self, market_type):
-        self.market_type = market_type
-        self.name = self.get_market_name(market_type)
-        self.id = self.get_market_id(self.name)
-
-    @staticmethod
-    def get_market_id(name: str):
-        try:
-            return MARKETS.index(name)
-        except ValueError:
-            raise Exception("no such market %s" % name)
-
-    @staticmethod
-    def get_market_name(market_type):
-        """ Take a name of a class, like ResultHome and turn it into method name like result_home_market. """
-        class_name = type(market_type).__name__  # also store name
-        words = re.findall('[A-Z][^A-Z]*', class_name)
-
-        return '_'.join(map(str.lower, words)) + "_market"
-
-    def __bytes__(self):
-        return bytes(Id(self.id)) + bytes(self.market_type)
-
-    def __str__(self):
-        return json.dumps([self.name, self.market_type.toJson()])
+        super().__init__(market_type, MARKETS)
+        self.name = self.get_name(market_type)
+        self.id = self.get_id(self.name)
 
 
 class ResultHome(GrapheneObject):
@@ -59,41 +41,64 @@ class ResultAway(GrapheneObject):
     pass
 
 
-class Round(GrapheneObject):
+class RoundHome(GrapheneObject):
     pass
 
 
 class Handicap(GrapheneObject):
     def __init__(self, threshold=0):
-        self.data = OrderedDict({"threshold": Uint16(threshold)})
+        self.data = OrderedDict([("threshold", Int16(threshold))])
 
         super(Handicap, self).__init__(self.data)
 
 
-class CorrectScore(GrapheneObject):
+class CorrectScoreHome(GrapheneObject):
+    pass
+
+
+class CorrectScoreDraw(GrapheneObject):
+    pass
+
+
+class CorrectScoreAway(GrapheneObject):
     pass
 
 
-class CorrectScoreParametrized(GrapheneObject):
+class CorrectScore(GrapheneObject):
     def __init__(self, home=0, away=0):
-        self.data = OrderedDict({"home": Uint16(home), "away": Uint16(away)})
+        self.data = OrderedDict([("home", Int16(home)), ("away", Int16(away))])
+
+        super(CorrectScore, self).__init__(self.data)
+
 
-        super(CorrectScoreParametrized, self).__init__(self.data)
+class GoalHome(GrapheneObject):
+    pass
 
 
-class Goal(GrapheneObject):
+class GoalBoth(GrapheneObject):
+    pass
+
+
+class GoalAway(GrapheneObject):
     pass
 
 
 class Total(GrapheneObject):
     def __init__(self, threshold=0):
-        self.data = OrderedDict({"threshold": Uint16(threshold)})
+        self.data = OrderedDict([("threshold", Int16(threshold))])
 
         super(Total, self).__init__(self.data)
 
 
-class TotalGoals(GrapheneObject):
+class TotalGoalsHome(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(TotalGoalsHome, self).__init__(self.data)
+
+
+class TotalGoalsAway(GrapheneObject):
     def __init__(self, threshold=0):
-        self.data = OrderedDict({"threshold": Uint16(threshold)})
+        self.data = OrderedDict([("threshold", Int16(threshold))])
 
-        super(TotalGoals, self).__init__(self.data)
+        super(TotalGoalsAway, self).__init__(self.data)