DimaKudosh#53 Added constraint for restricting players from opposite teams

Author: DimaKudosh

docs/constraints.rst

@@ -12,6 +12,8 @@ Constraints
 - Minimum salary cap.
 - Maximum repeating players.
 - Ownership projection constraint.
+- Team stacking
+- Restricting players from opposing teams
 
 Number of players from same team
 --------------------------------
@@ -88,3 +90,20 @@ It accepts list with integers, each integer represents minimum number of players
 .. code-block:: python
 
     optimizer.set_team_stacking([3, 3])
+
+Restrict players from opposing team
+-----------------------------------
+In some cases you would want to restrict creating of lineup with players from opposing teams,
+for example prevent of pitchers and hitters from same game. For this you can use `restrict_positions_for_opposing_team`
+method of optimizer, it accepts 2 arguments with list of positions for one team and list of positions for another.
+
+.. code-block:: python
+
+    optimizer.restrict_positions_for_opposing_team(['P'], ['1B', '2B', '3B'])
+
+.. note::
+
+    This constraint works only when players has information about upcoming game and their opponents,
+    in other case `LineupOptimizerException` will be raised. So it will not work in FantasyDraft
+    (because they doesn't provide information about opponents) and if you write your custom players importer and
+    don't pass `game_info` parameter in players constructors.

pydfs_lineup_optimizer/lineup_optimizer.py

@@ -8,7 +8,7 @@
 from pydfs_lineup_optimizer.sites import SitesRegistry
 from pydfs_lineup_optimizer.lineup_importer import CSVImporter
 from pydfs_lineup_optimizer.settings import BaseSettings, LineupPosition
-from pydfs_lineup_optimizer.player import LineupPlayer
+from pydfs_lineup_optimizer.player import LineupPlayer, GameInfo
 from pydfs_lineup_optimizer.utils import ratio, link_players_with_positions, get_remaining_positions
 from pydfs_lineup_optimizer.rules import *
 
@@ -41,6 +41,7 @@ def __init__(self, settings, solver=PuLPSolver):
         self._max_projected_ownership = None  # type: Optional[float]
         self._min_projected_ownership = None  # type: Optional[float]
         self._team_stacks = None  # type: Optional[List[int]]
+        self._opposing_teams_position_restriction = None  # type: Optional[Tuple[List[str], List[str]]]
 
     @property
     def budget(self):
@@ -137,6 +138,16 @@ def team_stacks(self):
         # type: () -> Optional[List[int]]
         return self._team_stacks
 
+    @property
+    def opposing_teams_position_restriction(self):
+        # type: () -> Optional[Tuple[List[str], List[str]]]
+        return self._opposing_teams_position_restriction
+
+    @property
+    def games(self):
+        # type: () -> FrozenSet[GameInfo]
+        return frozenset(player.game_info for player in self.players if player.game_info)
+
     def reset_lineup(self):
         self._lineup = []
         self._players_with_same_position = {}
@@ -377,6 +388,13 @@ def set_team_stacking(self, stacks):
             self.remove_rule(TeamStacksRule)
         self._team_stacks = stacks
 
+    def restrict_positions_for_opposing_team(self, first_team_positions, second_team_positions):
+        # type: (List[str], List[str]) -> None
+        if not self.games:
+            raise LineupOptimizerException('Game Info isn\'t specified for players')
+        self._opposing_teams_position_restriction = (first_team_positions, second_team_positions)
+        self.add_new_rule(RestrictPositionsForOpposingTeams)
+
     def optimize(self, n, max_exposure=None, randomness=False, with_injured=False):
         # type: (int, Optional[float], bool, bool) -> Generator[Lineup, None, None]
         params = locals()

pydfs_lineup_optimizer/lineup_printer.py

@@ -12,14 +12,24 @@ def print_lineup(self, lineup):
 
 
 class LineupPrinter(BaseLineupPrinter):
+    OUTPUT_FORMAT = '{0:>2}. {1:<5} {2:<30}{3:<6}{4:<15}{5:<9}{6:<8}{7:<10}\n'
+
+    def _print_game_info(self, player):
+        # type: ('LineupPlayer') -> str
+        game_info = player.game_info
+        if game_info:
+            return '%s@%s' % (game_info.away_team, game_info.home_team)
+        return ''
+
     def _print_player(self, index, player):
         # type: (int, 'LineupPlayer') -> str
-        return '{0:>2}. {1:<5} {2:<30}{3:<6}{4:<15}{5:<8}{6:<10}\n'.format(
+        return self.OUTPUT_FORMAT.format(
             index,
             player.lineup_position,
             player.full_name,
             '/'.join(player.positions),
             player.team,
+            self._print_game_info(player),
             round(player.fppg, 3),
             str(player.salary) + '$',
         )
@@ -33,20 +43,24 @@ def print_lineup(self, lineup):
         return res
 
 
-class DropLowestLineupPrinter(BaseLineupPrinter):
+class DropLowestLineupPrinter(LineupPrinter):
+    def _print_player(self, index, player, is_dropped=False):
+        return self.OUTPUT_FORMAT.format(
+            index,
+            player.lineup_position,
+            '%s%s' % (player.full_name, '(DROPPED)' if is_dropped else ''),
+            '/'.join(player.positions),
+            player.team,
+            self._print_game_info(player),
+            round(player.fppg, 3),
+            str(player.salary) + '$',
+        )
+
     def print_lineup(self, lineup):
         res = ''
-        lowest_fppg_player = sorted(lineup, key=lambda player: player.fppg)[0]
+        lowest_fppg_player = sorted(lineup, key=lambda p: p.fppg)[0]
         for index, player in enumerate(lineup.players, start=1):
-            res += '{0:>2}. {1:<5} {2:<30}{3:<6}{4:<15}{5:<8}{6:<10}\n'.format(
-                index,
-                player.lineup_position,
-                '%s%s' % (player.full_name, '(DROPPED)' if player == lowest_fppg_player else ''),
-                '/'.join(player.positions),
-                player.team,
-                round(player.fppg, 3),
-                str(player.salary) + '$',
-            )
+            res += self._print_player(index, player, is_dropped=lowest_fppg_player)
         res += 'Fantasy Points %.2f' % lineup.fantasy_points_projection
         res += '\nFantasy Points Without Dropped Player %.2f' % \
                (lineup.fantasy_points_projection - lowest_fppg_player.fppg)

pydfs_lineup_optimizer/rules.py

@@ -1,6 +1,6 @@
 from __future__ import division
 from collections import defaultdict
-from itertools import product, combinations, groupby
+from itertools import product, combinations, groupby, permutations
 from math import ceil
 from random import getrandbits, uniform
 from typing import List, Dict, Any, Optional, TYPE_CHECKING
@@ -291,3 +291,22 @@ def apply(self, solver, players_dict):
                 solver.add_constraint(variables, coefficients, SolverSign.GTE,
                                       stack * solver_variable)
             solver.add_constraint(combinations_variables, [1] * len(combinations_variables), SolverSign.GTE, total)
+
+
+class RestrictPositionsForOpposingTeams(OptimizerRule):
+    def apply(self, solver, players_dict):
+        if not self.optimizer.opposing_teams_position_restriction:
+            return
+        for game in self.optimizer.games:
+            first_team_players = {player: variable for player, variable in players_dict.items()
+                                  if player.team == game.home_team}
+            second_team_players = {player: variable for player, variable in players_dict.items()
+                                   if player.team == game.away_team}
+            for first_team_positions, second_team_positions in \
+                    permutations(self.optimizer.opposing_teams_position_restriction, 2):
+                first_team_variables = [variable for player, variable in first_team_players.items()
+                                        if list_intersection(player.positions, first_team_positions)]
+                second_team_variables = [variable for player, variable in second_team_players.items()
+                                         if list_intersection(player.positions, second_team_positions)]
+                for variables in product(first_team_variables, second_team_variables):
+                    solver.add_constraint(variables, [1, 1], SolverSign.LTE, 1)

pydfs_lineup_optimizer/sites/draftkings/classic/importer.py

@@ -71,7 +71,7 @@ def import_players(self):  # pragma: no cover
                 else:
                     start_line += 1
 
-    def import_lineups(self, players):
+    def import_lineups(self, players):  # pragma: no cover
         with open(self.filename, 'r') as csv_file:
             lines = csv.reader(csv_file)
             try:

pydfs_lineup_optimizer/sites/fanduel/importer.py

@@ -1,7 +1,7 @@
 import csv
 from pydfs_lineup_optimizer.exceptions import LineupOptimizerIncorrectCSV
 from pydfs_lineup_optimizer.lineup_importer import CSVImporter
-from pydfs_lineup_optimizer.player import Player
+from pydfs_lineup_optimizer.player import Player, GameInfo
 from pydfs_lineup_optimizer.sites.sites_registry import SitesRegistry
 from pydfs_lineup_optimizer.constants import Site
 
@@ -15,6 +15,11 @@ def import_players(self):  # pragma: no cover
         with open(self.filename, 'r') as csvfile:
             csv_data = csv.DictReader(csvfile, skipinitialspace=True)
             for row in csv_data:
+                try:
+                    away_team, home_team = row.get('Game').split('@')
+                    game_info = GameInfo(home_team, away_team, None, False)
+                except ValueError:
+                    game_info = None
                 try:
                     max_exposure = row.get('Max Exposure')
                     player = Player(
@@ -26,7 +31,8 @@ def import_players(self):  # pragma: no cover
                         float(row['Salary']),
                         float(row['FPPG']),
                         True if row['Injury Indicator'].strip() else False,
-                        max_exposure=float(max_exposure.replace('%', '')) if max_exposure else None
+                        max_exposure=float(max_exposure.replace('%', '')) if max_exposure else None,
+                        game_info=game_info,
                     )
                 except KeyError:
                     raise LineupOptimizerIncorrectCSV

pydfs_lineup_optimizer/sites/yahoo/importer.py

@@ -1,7 +1,7 @@
 import csv
 from pydfs_lineup_optimizer.exceptions import LineupOptimizerIncorrectCSV
 from pydfs_lineup_optimizer.lineup_importer import CSVImporter
-from pydfs_lineup_optimizer.player import Player
+from pydfs_lineup_optimizer.player import Player, GameInfo
 from pydfs_lineup_optimizer.sites.sites_registry import SitesRegistry
 from pydfs_lineup_optimizer.constants import Site
 
@@ -15,6 +15,11 @@ def import_players(self):  # pragma: no cover
         with open(self.filename, 'r') as csvfile:
             csv_data = csv.DictReader(csvfile, skipinitialspace=True)
             for row in csv_data:
+                try:
+                    away_team, home_team = row.get('Game', '').split('@')
+                    game_info = GameInfo(home_team, away_team, None, False)
+                except ValueError:
+                    game_info = None
                 try:
                     max_exposure = row.get('Max Exposure')
                     player = Player(
@@ -26,7 +31,8 @@ def import_players(self):  # pragma: no cover
                         float(row['Salary']),
                         float(row['FPPG']),
                         True if row['Injury Status'].strip() else False,
-                        max_exposure=float(max_exposure.replace('%', '')) if max_exposure else None
+                        max_exposure=float(max_exposure.replace('%', '')) if max_exposure else None,
+                        game_info=game_info,
                     )
                 except KeyError:
                     raise LineupOptimizerIncorrectCSV

tests/test_rules.py

@@ -3,11 +3,13 @@
 import mock
 from copy import deepcopy
 from collections import Counter
+from datetime import datetime
 from pydfs_lineup_optimizer import get_optimizer
 from pydfs_lineup_optimizer.constants import Site, Sport
-from pydfs_lineup_optimizer.player import Player
+from pydfs_lineup_optimizer.player import Player, GameInfo
 from pydfs_lineup_optimizer.exceptions import LineupOptimizerException
 from pydfs_lineup_optimizer.rules import ProjectedOwnershipRule
+from pydfs_lineup_optimizer.utils import list_intersection
 from .utils import create_players, load_players
 
 
@@ -303,3 +305,42 @@ def test_stack_greater_than_max_from_one_team(self):
         stacks = [5]
         with self.assertRaises(LineupOptimizerException):
             self.optimizer.set_team_stacking(stacks)
+
+
+class PositionsForOpposingTeamTestCase(unittest.TestCase):
+    def setUp(self):
+        first_game_info = GameInfo('HOU', 'BOS', datetime.now(), False)
+        second_game_info = GameInfo('CHI', 'NY', datetime.now(), False)
+        self.players = [
+            Player(1, '1', '1', ['SP', 'RP'], 'HOU', 3000, 15, game_info=first_game_info),
+            Player(2, '2', '2', ['SP', 'RP'], 'BOS', 3000, 15, game_info=first_game_info),
+            Player(3, '3', '3', ['C'], 'HOU', 3000, 15, game_info=first_game_info),
+            Player(4, '4', '4', ['1B'], 'BOS', 3000, 15, game_info=first_game_info),
+            Player(5, '5', '5', ['2B'], 'HOU', 3000, 15, game_info=first_game_info),
+            Player(6, '6', '6', ['3B'], 'BOS', 3000, 15, game_info=first_game_info),
+            Player(7, '7', '7', ['SS'], 'HOU', 3000, 15, game_info=first_game_info),
+            Player(8, '8', '8', ['OF'], 'BOS', 3000, 15, game_info=first_game_info),
+            Player(9, '9', '9', ['OF'], 'HOU', 3000, 15, game_info=first_game_info),
+            Player(10, '10', '10', ['OF'], 'BOS', 3000, 15, game_info=first_game_info),
+            Player(11, '11', '11', ['SP', 'RP'], 'CHI', 3000, 5, game_info=second_game_info),
+            Player(12, '12', '12', ['SP', 'RP'], 'NY', 3000, 5, game_info=second_game_info),
+        ]
+        self.optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASEBALL)
+        self.optimizer.load_players(self.players)
+
+    def test_restrict_positions_for_opposing_team_correctness(self):
+        first_team_positions = ['SP', 'RP']
+        second_team_positions = ['1B', '2B', '3B']
+        self.optimizer.restrict_positions_for_opposing_team(first_team_positions, second_team_positions)
+        lineup = next(self.optimizer.optimize(1))
+        pitcher_games = {player.game_info for player in lineup
+                         if list_intersection(player.positions, first_team_positions)}
+        hitters_games = {player.game_info for player in lineup
+                         if list_intersection(player.positions, second_team_positions)}
+        self.assertFalse(pitcher_games.intersection(hitters_games))
+
+    def test_restrict_positions_if_game_not_specified(self):
+        for player in self.players:
+            player.game_info = None
+        with self.assertRaises(LineupOptimizerException):
+            self.optimizer.restrict_positions_for_opposing_team(['SP', 'RP'], ['1B'])