Add method to get details for the rules for a given game type (#104)

Closes #98 by adding a `game_type_rules` method

Author: jaebradley

docs/api.md

@@ -105,6 +105,14 @@ from draft_kings import Client
 Client().draftables(draft_group_id=41793)
 ```
 
+### Get Rules For A Game Type
+
+```python
+from draft_kings import Client
+
+Client().game_type_rules(game_type_id=1)
+```
+
 ### Usage
 
 To the best of my knowledge, I have not identified an endpoint that delivers data for a window of time. 

draft_kings/client.py

@@ -32,6 +32,10 @@
 from draft_kings.response.schema.regions import RegionsSchema
 from draft_kings.url_builder import URLBuilder
 from draft_kings.utilities import translate_formatted_datetime, from_unix_milliseconds_to_datetime
+from draft_kings.response.schema.game_type_rules import GameTypeRulesSchema
+from draft_kings.output.transformers.game_type_rules import transform_roster_slot, transform_salary_cap, \
+    LineupTemplateTransformer, GameTypeRulesTransformer
+from draft_kings.output.objects.game_type_rules import GameTypeRulesDetails
 
 
 class Client:
@@ -41,13 +45,15 @@ class Client:
     countries_transformer: CountriesTransformer
     regions_transformer: RegionsTransformer
     draftables_transformer: DraftablesTransformer
+    game_type_rules_transformer: GameTypeRulesTransformer
 
     contests_schema: ContestsSchema
     players_schema: PlayersDetailsSchema
     draft_group_schema: DraftGroupResponseSchema
     countries_schema: CountriesSchema
     regions_schema: RegionsSchema
     draftables_schema: DraftablesSchema
+    game_type_rules_schema: GameTypeRulesSchema
 
     http_client: HTTPClient
 
@@ -99,12 +105,20 @@ def __init__(self):
                 draft_alert_transformer=transform_draft_alert,
             )
         )
+        self.game_type_rules_transformer=GameTypeRulesTransformer(
+            salary_cap_transformer=transform_salary_cap,
+            lineup_template_transformer=LineupTemplateTransformer(
+                roster_slot_transformer=transform_roster_slot,
+            )
+        )
         self.contests_schema = ContestsSchema()
         self.players_schema = PlayersDetailsSchema()
         self.draft_group_schema = DraftGroupResponseSchema()
         self.countries_schema = CountriesSchema()
         self.regions_schema = RegionsSchema()
         self.draftables_schema = DraftablesSchema()
+        self.game_type_rules_schema = GameTypeRulesSchema()
+
         self.http_client = HTTPClient(url_builder=URLBuilder())
 
     def contests(self, sport: Sport) -> ContestsDetails:
@@ -137,4 +151,9 @@ def draftables(self, draft_group_id: int) -> DraftablesDetails:
         deserialized_response = self.draftables_schema.loads(response.text)
         return self.draftables_transformer.transform(response_draftables=deserialized_response)
 
+    def game_type_rules(self, game_type_id: int) -> GameTypeRulesDetails:
+        response = self.http_client.game_type_rules(game_type_id=game_type_id)
+        deserialized_response = self.game_type_rules_schema.loads(response.text)
+        return self.game_type_rules_transformer.transform(game_type_rules=deserialized_response)
+
 # pylint: enable=too-many-instance-attributes

draft_kings/http_client.py

@@ -54,3 +54,11 @@ def draftables(self, draft_group_id: int) -> Response:
         response.raise_for_status()
 
         return response
+
+    def game_type_rules(self, game_type_id: int) -> Response:
+        response = requests.get(url=self.url_builder.build_game_type_rules_url(game_type_id=game_type_id),
+                                params={'format': 'json'})
+
+        response.raise_for_status()
+
+        return response

draft_kings/output/objects/game_type_rules.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Optional, List
+
+
+@dataclass(frozen=True)
+class SalaryCapDetails:
+    is_enabled: Optional[bool]
+    maximum_value: Optional[float]
+    minimum_value: Optional[float]
+
+
+@dataclass(frozen=True)
+class RosterSlotDetails:
+    description: Optional[str]
+    name: Optional[str]
+    roster_slot_id: Optional[int]
+
+
+@dataclass(frozen=True)
+class LineupTemplateDetails:
+    roster_slot_details: Optional[RosterSlotDetails]
+
+
+@dataclass(frozen=True)
+class GameTypeRulesDetails:
+    allow_late_swaps: Optional[bool]
+    description: Optional[str]
+    enforce_selecting_unique_players: Optional[bool]
+    draft_type_name: Optional[str]
+    game_type_id: Optional[int]
+    lineup_templates: List[LineupTemplateDetails]
+    name: Optional[str]
+    salary_cap_details: Optional[SalaryCapDetails]

draft_kings/output/schema/game_type_rules.py

@@ -0,0 +1,52 @@
+# pylint: disable=unused-argument, no-self-use
+
+from marshmallow import Schema, fields, post_load
+
+from draft_kings.output.objects.game_type_rules import SalaryCapDetails, RosterSlotDetails, LineupTemplateDetails, \
+    GameTypeRulesDetails
+
+
+class SalaryCapDetailsSchema(Schema):
+    is_enabled = fields.Bool(allow_none=True, required=True)
+    maximum_value = fields.Float(allow_none=True, required=True)
+    minimum_value = fields.Float(allow_none=True, required=True)
+
+    @post_load
+    def make_salary_cap_details(self, data, **kwargs):
+        return SalaryCapDetails(**data)
+
+
+class RosterSlotDetailsSchema(Schema):
+    description = fields.Str(allow_none=True, required=True)
+    name = fields.Str(allow_none=True, required=True)
+    roster_slot_id = fields.Int(allow_none=True, required=True)
+
+    @post_load
+    def make_roster_slot_details(self, data, **kwargs):
+        return RosterSlotDetails(**data)
+
+
+class LineupTemplateDetailsSchema(Schema):
+    roster_slot_details = fields.Nested(RosterSlotDetailsSchema, allow_none=True, required=True)
+
+    @post_load
+    def make_lineup_template(self, data, **kwargs):
+        return LineupTemplateDetails(**data)
+
+
+class GameTypeRulesDetailsSchema(Schema):
+    allow_late_swaps = fields.Bool(allow_none=True, required=True)
+    description = fields.Str(allow_none=True, required=True)
+    enforce_unique_players = fields.Bool(allow_none=True, required=True)
+    draft_type_name = fields.Str(allow_none=True, required=True)
+    game_type_id = fields.Int(allow_none=True, required=True)
+    lineup_templates = fields.List(fields.Nested(LineupTemplateDetailsSchema, allow_none=False, required=True),
+                                   allow_none=False, required=True)
+    name = fields.Str(allow_none=True, required=True)
+    salary_cap_details = fields.Nested(SalaryCapDetailsSchema, allow_none=True, required=True)
+
+    @post_load
+    def make_game_type_details(self, data, **kwargs):
+        return GameTypeRulesDetails(**data)
+
+# pylint: enable=unused-argument, no-self-use

draft_kings/output/transformers/game_type_rules.py

@@ -0,0 +1,57 @@
+from typing import Callable
+
+from draft_kings.response.objects.game_type_rules import SalaryCap as ResponseSalaryCap, RosterSlot as \
+    ResponseRosterSlot, LineupTemplate as ResponseLineupTemplate, GameTypeRules as ResponseGameTypeRules
+from draft_kings.output.objects.game_type_rules import SalaryCapDetails, RosterSlotDetails, LineupTemplateDetails, \
+    GameTypeRulesDetails
+
+
+def transform_salary_cap(salary_cap: ResponseSalaryCap) -> SalaryCapDetails:
+    return SalaryCapDetails(
+        is_enabled=salary_cap.is_enabled,
+        maximum_value=salary_cap.max_value,
+        minimum_value=salary_cap.min_value
+    )
+
+
+def transform_roster_slot(roster_slot: ResponseRosterSlot) -> RosterSlotDetails:
+    return RosterSlotDetails(
+        description=roster_slot.description,
+        name=roster_slot.name,
+        roster_slot_id=roster_slot.roster_slot_id
+    )
+
+
+class LineupTemplateTransformer:
+    def __init__(self, roster_slot_transformer: Callable[[ResponseRosterSlot], RosterSlotDetails]):
+        self.roster_slot_transformer = roster_slot_transformer
+
+    def transform(self, lineup_template: ResponseLineupTemplate) -> LineupTemplateDetails:
+        return LineupTemplateDetails(
+            roster_slot_details=self.roster_slot_transformer(lineup_template.roster_slot) if
+            lineup_template.roster_slot is not None else None
+        )
+
+
+class GameTypeRulesTransformer:
+    def __init__(self, salary_cap_transformer: Callable[[ResponseSalaryCap], SalaryCapDetails],
+                 lineup_template_transformer: LineupTemplateTransformer):
+        self.salary_cap__transformer = salary_cap_transformer
+        self.lineup_template_transformer = lineup_template_transformer
+
+    def transform(self, game_type_rules: ResponseGameTypeRules) -> GameTypeRulesDetails:
+        return GameTypeRulesDetails(
+            allow_late_swaps=game_type_rules.allow_late_swap,
+            description=game_type_rules.description,
+            enforce_selecting_unique_players=game_type_rules.unique_players,
+            draft_type_name=game_type_rules.draft_type,
+            game_type_id=game_type_rules.game_type_id,
+            lineup_templates=list(map(
+                lambda template:
+                self.lineup_template_transformer.transform(lineup_template=template),
+                game_type_rules.lineup_template
+            )),
+            name=game_type_rules.name,
+            salary_cap_details=self.salary_cap__transformer(game_type_rules.salary_cap)
+            if game_type_rules.salary_cap is not None else None
+        )

draft_kings/response/objects/game_type_rules.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Optional, List
+
+
+@dataclass(frozen=True)
+class SalaryCap:
+    is_enabled: Optional[bool]
+    max_value: Optional[float]
+    min_value: Optional[float]
+
+
+@dataclass(frozen=True)
+class RosterSlot:
+    description: Optional[str]
+    name: Optional[str]
+    roster_slot_id: Optional[int]
+
+
+@dataclass(frozen=True)
+class LineupTemplate:
+    roster_slot: Optional[RosterSlot]
+
+
+@dataclass(frozen=True)
+class GameTypeRules:
+    allow_late_swap: Optional[bool]
+    description: Optional[str]
+    draft_type: Optional[str]
+    game_type_id: Optional[int]
+    lineup_template: List[LineupTemplate]
+    name: Optional[str]
+    salary_cap: Optional[SalaryCap]
+    unique_players: Optional[bool]

draft_kings/response/schema/game_type_rules.py

@@ -0,0 +1,62 @@
+# pylint: disable=unused-argument, no-self-use
+
+from marshmallow import Schema, fields, EXCLUDE, post_load
+
+from draft_kings.response.objects.game_type_rules import SalaryCap, RosterSlot, LineupTemplate, GameTypeRules
+
+
+class SalaryCapSchema(Schema):
+    class Meta:
+        unknown = EXCLUDE
+
+    isEnabled = fields.Bool(attribute="is_enabled", missing=None)
+    maxValue = fields.Float(attribute="max_value", missing=None)
+    minValue = fields.Float(attribute="min_value", missing=None)
+
+    @post_load
+    def make_salary_cap(self, data, **kwargs):
+        return SalaryCap(**data)
+
+
+class RosterSlotSchema(Schema):
+    class Meta:
+        unknown = EXCLUDE
+
+    id = fields.Int(attribute="roster_slot_id", missing=None)
+    description = fields.Str(attribute="description", missing=None)
+    name = fields.Str(attribute="name", missing=None)
+
+    @post_load
+    def make_roster_slot(self, data, **kwargs):
+        return RosterSlot(**data)
+
+
+class LineupTemplateSchema(Schema):
+    class Meta:
+        unknown = EXCLUDE
+
+    rosterSlot = fields.Nested(RosterSlotSchema, attribute="roster_slot", missing=None)
+
+    @post_load
+    def make_lineup_template(self, data, **kwargs):
+        return LineupTemplate(**data)
+
+
+class GameTypeRulesSchema(Schema):
+    class Meta:
+        unknown = EXCLUDE
+
+    allowLateSwap = fields.Bool(attribute="allow_late_swap", missing=None)
+    draftType = fields.Str(attribute="draft_type", missing=None)
+    gameTypeDescription = fields.Str(attribute="description", missing=None)
+    gameTypeId = fields.Int(attribute="game_type_id", missing=None)
+    gameTypeName = fields.Str(attribute="name", missing=None)
+    lineupTemplate = fields.List(fields.Nested(LineupTemplateSchema), attribute="lineup_template", missing=[])
+    salaryCap = fields.Nested(SalaryCapSchema, attribute="salary_cap", missing=None)
+    uniquePlayers = fields.Bool(attribute="unique_players", missing=None)
+
+    @post_load
+    def make_game_type_rules(self, data, **kwargs):
+        return GameTypeRules(**data)
+
+# pylint: enable=unused-argument, no-self-use

draft_kings/url_builder.py

@@ -33,3 +33,9 @@ def build_draftables_url(self, draft_group_id: int) -> str:
             API_BASE_URL=self.api_base_path,
             draft_group_id=draft_group_id
         )
+
+    def build_game_type_rules_url(self, game_type_id: int) -> str:
+        return "{API_BASE_URL}/lineups/v1/gametypes/{game_type_id}/rules".format(
+            API_BASE_URL=self.api_base_path,
+            game_type_id=game_type_id,
+        )

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "draft_kings"
-version = "3.0.0"
+version = "3.1.0"
 description = "A client to access data on draftkings.com"
 authors = ["Jae Bradley <jae.b.bradley@gmail.com>"]
 maintainers = ["Jae Bradley <jae.b.bradley@gmail.com>"]