diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-draftfast.spec | 1104 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 1106 insertions, 0 deletions
@@ -0,0 +1 @@ +/draftfast-3.8.0.tar.gz diff --git a/python-draftfast.spec b/python-draftfast.spec new file mode 100644 index 0000000..66f27b0 --- /dev/null +++ b/python-draftfast.spec @@ -0,0 +1,1104 @@ +%global _empty_manifest_terminate_build 0 +Name: python-draftfast +Version: 3.8.0 +Release: 1 +Summary: A tool to automate and optimize DraftKings and FanDuel lineup construction. +License: MIT License +URL: https://github.com/BenBrostoff/draftfast +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/83/e1/e9e2f428effb2199ab98b45d68598600e37abb0ff8ed0d0d1c4723133e01/draftfast-3.8.0.tar.gz +BuildArch: noarch + + +%description +## Introduction · [](https://travis-ci.org/BenBrostoff/draftfast) · [](https://draftfast.herokuapp.com/) + + + +An incredibly powerful tool that automates and optimizes lineup building, allowing you to enter thousands of lineups in any DraftKings or FanDuel contest in the time it takes you to grab a coffee. + +## Installation + +Requires Python 3.9+. + +```bash +pip install draftfast +``` + +## Usage + +Example usage ([you can experiment with these examples in repl.it](https://repl.it/@BenBrostoff/AllWarlikeDemoware)): + +```python +from draftfast import rules +from draftfast.optimize import run +from draftfast.orm import Player +from draftfast.csv_parse import salary_download + +# Create players for a classic DraftKings game +player_pool = [ + Player(name='A1', cost=5500, proj=55, pos='PG'), + Player(name='A2', cost=5500, proj=55, pos='PG'), + Player(name='A3', cost=5500, proj=55, pos='SG'), + Player(name='A4', cost=5500, proj=55, pos='SG'), + Player(name='A5', cost=5500, proj=55, pos='SF'), + Player(name='A6', cost=5500, proj=55, pos='SF'), + Player(name='A7', cost=5500, proj=55, pos='PF'), + Player(name='A8', cost=5500, proj=55, pos='PF'), + Player(name='A9', cost=5500, proj=55, pos='C'), + Player(name='A10', cost=5500, proj=55, pos='C'), +] + +roster = run( + rule_set=rules.DK_NBA_RULE_SET, + player_pool=player_pool, + verbose=True, +) + +# Or, alternatively, generate players from a CSV +players = salary_download.generate_players_from_csvs( + salary_file_location='./salaries.csv', + game=rules.DRAFT_KINGS, +) + +roster = run( + rule_set=rules.DK_NBA_RULE_SET, + player_pool=players, + verbose=True, +) +``` + +You can see more examples in the [`examples` directory](https://github.com/BenBrostoff/draftfast/tree/master/examples). + +## Game Rules + +Optimizing for a particular game is as easy as setting the `RuleSet` (see the example above). Game rules in the library are in the table below: + +| League | Site | Reference | +| ------------- |:-------------:| :-----:| +| NFL | DraftKings | `DK_NFL_RULE_SET` | +| NFL | FanDuel | `FD_NFL_RULE_SET` | +| NBA | DraftKings | `DK_NBA_RULE_SET` | +| NBA | FanDuel | `FD_NBA_RULE_SET` | +| MLB | DraftKings | `DK_MLB_RULE_SET` | +| MLB | FanDuel | `FD_MLB_RULE_SET` | +| WNBA | DraftKings | `DK_WNBA_RULE_SET` | +| WNBA | FanDuel | `FD_WNBA_RULE_SET` | +| PGA | FanDuel | `FD_PGA_RULE_SET` | +| PGA | DraftKings | `DK_PGA_RULE_SET` | +| PGA_CAPTAIN | DraftKings | `DK_PGA_CAPTAIN_RULE_SET` | +| NASCAR | FanDuel | `FD_NASCAR_RULE_SET` | +| NASCAR | DraftKings | `DK_NASCAR_RULE_SET` | +| SOCCER | DraftKings | `DK_SOCCER_RULE_SET` | +| EuroLeague | DraftKings | `DK_EURO_LEAGUE_RULE_SET` | +| NHL | DraftKings | `DK_NHL_RULE_SET` | +| NBA Pickem | DraftKings | `DK_NBA_PICKEM_RULE_SET` | +| NFL Showdown | DraftKings | `DK_NFL_SHOWDOWN_RULE_SET` | +| NBA Showdown | DraftKings | `DK_NBA_SHOWDOWN_RULE_SET` | +| MLB Showdown | DraftKings | `DK_MLB_SHOWDOWN_RULE_SET` | +| XFL | DraftKings | `DK_XFL_CLASSIC_RULE_SET` | +| Tennis | DraftKings | `DK_TEN_CLASSIC_RULE_SET` | +| CS:GO | DraftKings | `DK_CSGO_SHOWDOWN` | +| F1 | DraftKings | `DK_F1_SHOWDOWN` | +| NFL MVP | FanDuel | `FD_NFL_MVP_RULE_SET` | +| MLB MVP | FanDuel | `FD_MLB_MVP_RULE_SET` | +| NBA MVP | FanDuel | `FD_NBA_MVP_RULE_SET` | + +Note that you can also tune `draftfast` for any game of your choice even if it's not implemented in the library (PRs welcome!). Using the `RuleSet` class, you can generate your own game rules that specific number of players, salary, etc. Example: + +```python +from draftfast import rules + +golf_rules = rules.RuleSet( + site=rules.DRAFT_KINGS, + league='PGA', + roster_size='6', + position_limits=[['G', 6, 6]], + salary_max=50_000, +) +``` + +## Settings + +Usage example: + +```python +class Showdown(Roster): + POSITION_ORDER = { + 'M': 0, + 'F': 1, + 'D': 2, + 'GK': 3, + } + + +showdown_limits = [ + ['M', 0, 6], + ['F', 0, 6], + ['D', 0, 6], + ['GK', 0, 6], +] + +soccer_rules = rules.RuleSet( + site=rules.DRAFT_KINGS, + league='SOCCER_SHOWDOWN', + roster_size=6, + position_limits=showdown_limits, + salary_max=50_000, + general_position_limits=[], +) +player_pool = salary_download.generate_players_from_csvs( + salary_file_location=salary_file, + game=rules.DRAFT_KINGS, +) +roster = run( + rule_set=soccer_rules, + player_pool=player_pool, + verbose=True, + roster_gen=Showdown, +) +``` + +`PlayerPoolSettings` + +- `min_proj` +- `max_proj` +- `min_salary` +- `max_salary` +- `min_avg` +- `max_avg` + +`OptimizerSettings` + +- `stacks` - A list of `Stack` objects. Example: + +```python +roster = run( + rule_set=rules.DK_NHL_RULE_SET, + player_pool=player_pool, + verbose=True, + optimizer_settings=OptimizerSettings( + stacks=[ + Stack(team='PHI', count=3), + Stack(team='FLA', count=3), + Stack(team='NSH', count=2), + ] + ), +) +``` + +`Stack` can also be tuned to support different combinations of positions. For NFL, +to only specify a QB-WRs based stack of five: + +```python +Stack( + team='NE', + count=5, + stack_lock_pos=['QB'], + stack_eligible_pos=['WR'], +) +``` + +- `custom_rules` - Define rules that set if / then conditions for lineups. + + +For example, if two WRs from the same team are in a naturally optimized lineup, then the QB must also be in the lineup. You can find some good examples of rules in `draftfast/test/test_custom_rules.py`. + +```python +from draftfast.optimize import run +from draftfast.settings import OptimizerSettings, CustomRule + +# If two WRs on one team, play the QB from same team +settings = OptimizerSettings( + custom_rules=[ + CustomRule( + group_a=lambda p: p.pos == 'WR' and p.team == 'Patriots', + group_b=lambda p: p.pos == 'QB' and p.team == 'Patriots', + comparison=lambda sum, a, b: sum(a) + 1 <= sum(b) + ) + ] +) +roster = run( + rule_set=rules.DK_NFL_RULE_SET, + player_pool=nfl_pool, + verbose=True, + optimizer_settings=settings, +) +``` + +Another common use case is given one player is in a lineup, always play another player: + +```python +from draftfast.optimize import run +from draftfast.settings import OptimizerSettings, CustomRule + +# If Player A, always play Player B and vice versa +settings = OptimizerSettings( + custom_rules=[ + CustomRule( + group_a=lambda p: p.name == 'Tom Brady', + group_b=lambda p: p.name == 'Rob Gronkowski', + comparison=lambda sum, a, b: sum(a) == sum(b) + ) + ] +) +roster = run( + rule_set=rules.DK_NFL_RULE_SET, + player_pool=nfl_pool, + verbose=True, + optimizer_settings=settings, +) +``` + +Custom rules also don't have to make a comparison between two groups. You can say "never play these two players in the same lineup" by using the `CustomRule#comparison` property. + +```python +# Never play these two players together +settings = OptimizerSettings( + custom_rules=[ + CustomRule( + group_a=lambda p: p, + group_b=lambda p: p.name == 'Devon Booker' or p.name == 'Chris Paul', + comparison=lambda sum, a, b: sum(b) <= 1 + ) + ] +) +roster = run( + rule_set=rules.DK_NBA_RULE_SET, + player_pool=nba_pool, + verbose=True, + optimizer_settings=settings, +) +``` + +Importantly, as of this writing, passing closures into `CustomRule`s does not work (ex. `lambda p: p.team == team`), +so dynamically generating rules is not possible. PRs welcome for a fix here, I believe this is a limitation of `ortools`. + +`LineupConstraints` + +- `locked` - list of players to lock +- `banned` - list of players to ban +- `groups` - list of player groups constraints. See below + +```python +roster = run( + rule_set=rules.DK_NFL_RULE_SET, + player_pool=player_pool, + verbose=True, + constraints=LineupConstraints( + locked=['Rob Gronkowski'], + banned=['Mark Ingram', 'Doug Martin'], + groups=[ + [('Todd Gurley', 'Melvin Gordon', 'Christian McCaffrey'), (2, 3)], + [('Chris Carson', 'Mike Davis'), 1], + ] + ) +) +``` + +- `no_offense_against_defense` - Do not allow offensive players to be matched up against defensive players in the optimized lineup. Currently only implemented for soccer, NHL, and NFL -- PRs welcome! + +## CSV Upload + +```python +from draftfast.csv_parse import uploaders + +uploader = uploaders.DraftKingsNBAUploader( + pid_file='./pid_file.csv', +) +uploader.write_rosters(rosters) + +``` + +## Support and Consulting + +DFS optimization is only one part of a sustainable strategy. Long-term DFS winners have the best: + +- Player projections +- Bankroll management +- Diversification in contests played +- Diversification across lineups (see `draftfast.exposure`) +- Research process +- 1 hour before gametime lineup changes +- ...and so much more + +DraftFast provides support and consulting services that can help with all of these. [Let's get in touch today](mailto:ben.brostoff@gmail.com). + +# Contributing + +Run tests or set of tests: + +```sh +# All tests +nosetests + +# Single file +nosetests draftfast/test/test_soccer.py + +# Single test +nosetests draftfast/test/test_soccer.py:test_soccer_dk_no_opp_d +``` + +Run linting + +``` +flake8 draftfast +``` + +# Credits + +Special thanks to [swanson](https://github.com/swanson/), who authored [this repo](https://github.com/swanson/degenerate), which was the inspiration for this one. + +Current project maintainers: + +- [BenBrostoff](https://github.com/BenBrostoff) +- [sharkiteuthis](https://github.com/sharkiteuthis) + + + + +%package -n python3-draftfast +Summary: A tool to automate and optimize DraftKings and FanDuel lineup construction. +Provides: python-draftfast +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-draftfast +## Introduction · [](https://travis-ci.org/BenBrostoff/draftfast) · [](https://draftfast.herokuapp.com/) + + + +An incredibly powerful tool that automates and optimizes lineup building, allowing you to enter thousands of lineups in any DraftKings or FanDuel contest in the time it takes you to grab a coffee. + +## Installation + +Requires Python 3.9+. + +```bash +pip install draftfast +``` + +## Usage + +Example usage ([you can experiment with these examples in repl.it](https://repl.it/@BenBrostoff/AllWarlikeDemoware)): + +```python +from draftfast import rules +from draftfast.optimize import run +from draftfast.orm import Player +from draftfast.csv_parse import salary_download + +# Create players for a classic DraftKings game +player_pool = [ + Player(name='A1', cost=5500, proj=55, pos='PG'), + Player(name='A2', cost=5500, proj=55, pos='PG'), + Player(name='A3', cost=5500, proj=55, pos='SG'), + Player(name='A4', cost=5500, proj=55, pos='SG'), + Player(name='A5', cost=5500, proj=55, pos='SF'), + Player(name='A6', cost=5500, proj=55, pos='SF'), + Player(name='A7', cost=5500, proj=55, pos='PF'), + Player(name='A8', cost=5500, proj=55, pos='PF'), + Player(name='A9', cost=5500, proj=55, pos='C'), + Player(name='A10', cost=5500, proj=55, pos='C'), +] + +roster = run( + rule_set=rules.DK_NBA_RULE_SET, + player_pool=player_pool, + verbose=True, +) + +# Or, alternatively, generate players from a CSV +players = salary_download.generate_players_from_csvs( + salary_file_location='./salaries.csv', + game=rules.DRAFT_KINGS, +) + +roster = run( + rule_set=rules.DK_NBA_RULE_SET, + player_pool=players, + verbose=True, +) +``` + +You can see more examples in the [`examples` directory](https://github.com/BenBrostoff/draftfast/tree/master/examples). + +## Game Rules + +Optimizing for a particular game is as easy as setting the `RuleSet` (see the example above). Game rules in the library are in the table below: + +| League | Site | Reference | +| ------------- |:-------------:| :-----:| +| NFL | DraftKings | `DK_NFL_RULE_SET` | +| NFL | FanDuel | `FD_NFL_RULE_SET` | +| NBA | DraftKings | `DK_NBA_RULE_SET` | +| NBA | FanDuel | `FD_NBA_RULE_SET` | +| MLB | DraftKings | `DK_MLB_RULE_SET` | +| MLB | FanDuel | `FD_MLB_RULE_SET` | +| WNBA | DraftKings | `DK_WNBA_RULE_SET` | +| WNBA | FanDuel | `FD_WNBA_RULE_SET` | +| PGA | FanDuel | `FD_PGA_RULE_SET` | +| PGA | DraftKings | `DK_PGA_RULE_SET` | +| PGA_CAPTAIN | DraftKings | `DK_PGA_CAPTAIN_RULE_SET` | +| NASCAR | FanDuel | `FD_NASCAR_RULE_SET` | +| NASCAR | DraftKings | `DK_NASCAR_RULE_SET` | +| SOCCER | DraftKings | `DK_SOCCER_RULE_SET` | +| EuroLeague | DraftKings | `DK_EURO_LEAGUE_RULE_SET` | +| NHL | DraftKings | `DK_NHL_RULE_SET` | +| NBA Pickem | DraftKings | `DK_NBA_PICKEM_RULE_SET` | +| NFL Showdown | DraftKings | `DK_NFL_SHOWDOWN_RULE_SET` | +| NBA Showdown | DraftKings | `DK_NBA_SHOWDOWN_RULE_SET` | +| MLB Showdown | DraftKings | `DK_MLB_SHOWDOWN_RULE_SET` | +| XFL | DraftKings | `DK_XFL_CLASSIC_RULE_SET` | +| Tennis | DraftKings | `DK_TEN_CLASSIC_RULE_SET` | +| CS:GO | DraftKings | `DK_CSGO_SHOWDOWN` | +| F1 | DraftKings | `DK_F1_SHOWDOWN` | +| NFL MVP | FanDuel | `FD_NFL_MVP_RULE_SET` | +| MLB MVP | FanDuel | `FD_MLB_MVP_RULE_SET` | +| NBA MVP | FanDuel | `FD_NBA_MVP_RULE_SET` | + +Note that you can also tune `draftfast` for any game of your choice even if it's not implemented in the library (PRs welcome!). Using the `RuleSet` class, you can generate your own game rules that specific number of players, salary, etc. Example: + +```python +from draftfast import rules + +golf_rules = rules.RuleSet( + site=rules.DRAFT_KINGS, + league='PGA', + roster_size='6', + position_limits=[['G', 6, 6]], + salary_max=50_000, +) +``` + +## Settings + +Usage example: + +```python +class Showdown(Roster): + POSITION_ORDER = { + 'M': 0, + 'F': 1, + 'D': 2, + 'GK': 3, + } + + +showdown_limits = [ + ['M', 0, 6], + ['F', 0, 6], + ['D', 0, 6], + ['GK', 0, 6], +] + +soccer_rules = rules.RuleSet( + site=rules.DRAFT_KINGS, + league='SOCCER_SHOWDOWN', + roster_size=6, + position_limits=showdown_limits, + salary_max=50_000, + general_position_limits=[], +) +player_pool = salary_download.generate_players_from_csvs( + salary_file_location=salary_file, + game=rules.DRAFT_KINGS, +) +roster = run( + rule_set=soccer_rules, + player_pool=player_pool, + verbose=True, + roster_gen=Showdown, +) +``` + +`PlayerPoolSettings` + +- `min_proj` +- `max_proj` +- `min_salary` +- `max_salary` +- `min_avg` +- `max_avg` + +`OptimizerSettings` + +- `stacks` - A list of `Stack` objects. Example: + +```python +roster = run( + rule_set=rules.DK_NHL_RULE_SET, + player_pool=player_pool, + verbose=True, + optimizer_settings=OptimizerSettings( + stacks=[ + Stack(team='PHI', count=3), + Stack(team='FLA', count=3), + Stack(team='NSH', count=2), + ] + ), +) +``` + +`Stack` can also be tuned to support different combinations of positions. For NFL, +to only specify a QB-WRs based stack of five: + +```python +Stack( + team='NE', + count=5, + stack_lock_pos=['QB'], + stack_eligible_pos=['WR'], +) +``` + +- `custom_rules` - Define rules that set if / then conditions for lineups. + + +For example, if two WRs from the same team are in a naturally optimized lineup, then the QB must also be in the lineup. You can find some good examples of rules in `draftfast/test/test_custom_rules.py`. + +```python +from draftfast.optimize import run +from draftfast.settings import OptimizerSettings, CustomRule + +# If two WRs on one team, play the QB from same team +settings = OptimizerSettings( + custom_rules=[ + CustomRule( + group_a=lambda p: p.pos == 'WR' and p.team == 'Patriots', + group_b=lambda p: p.pos == 'QB' and p.team == 'Patriots', + comparison=lambda sum, a, b: sum(a) + 1 <= sum(b) + ) + ] +) +roster = run( + rule_set=rules.DK_NFL_RULE_SET, + player_pool=nfl_pool, + verbose=True, + optimizer_settings=settings, +) +``` + +Another common use case is given one player is in a lineup, always play another player: + +```python +from draftfast.optimize import run +from draftfast.settings import OptimizerSettings, CustomRule + +# If Player A, always play Player B and vice versa +settings = OptimizerSettings( + custom_rules=[ + CustomRule( + group_a=lambda p: p.name == 'Tom Brady', + group_b=lambda p: p.name == 'Rob Gronkowski', + comparison=lambda sum, a, b: sum(a) == sum(b) + ) + ] +) +roster = run( + rule_set=rules.DK_NFL_RULE_SET, + player_pool=nfl_pool, + verbose=True, + optimizer_settings=settings, +) +``` + +Custom rules also don't have to make a comparison between two groups. You can say "never play these two players in the same lineup" by using the `CustomRule#comparison` property. + +```python +# Never play these two players together +settings = OptimizerSettings( + custom_rules=[ + CustomRule( + group_a=lambda p: p, + group_b=lambda p: p.name == 'Devon Booker' or p.name == 'Chris Paul', + comparison=lambda sum, a, b: sum(b) <= 1 + ) + ] +) +roster = run( + rule_set=rules.DK_NBA_RULE_SET, + player_pool=nba_pool, + verbose=True, + optimizer_settings=settings, +) +``` + +Importantly, as of this writing, passing closures into `CustomRule`s does not work (ex. `lambda p: p.team == team`), +so dynamically generating rules is not possible. PRs welcome for a fix here, I believe this is a limitation of `ortools`. + +`LineupConstraints` + +- `locked` - list of players to lock +- `banned` - list of players to ban +- `groups` - list of player groups constraints. See below + +```python +roster = run( + rule_set=rules.DK_NFL_RULE_SET, + player_pool=player_pool, + verbose=True, + constraints=LineupConstraints( + locked=['Rob Gronkowski'], + banned=['Mark Ingram', 'Doug Martin'], + groups=[ + [('Todd Gurley', 'Melvin Gordon', 'Christian McCaffrey'), (2, 3)], + [('Chris Carson', 'Mike Davis'), 1], + ] + ) +) +``` + +- `no_offense_against_defense` - Do not allow offensive players to be matched up against defensive players in the optimized lineup. Currently only implemented for soccer, NHL, and NFL -- PRs welcome! + +## CSV Upload + +```python +from draftfast.csv_parse import uploaders + +uploader = uploaders.DraftKingsNBAUploader( + pid_file='./pid_file.csv', +) +uploader.write_rosters(rosters) + +``` + +## Support and Consulting + +DFS optimization is only one part of a sustainable strategy. Long-term DFS winners have the best: + +- Player projections +- Bankroll management +- Diversification in contests played +- Diversification across lineups (see `draftfast.exposure`) +- Research process +- 1 hour before gametime lineup changes +- ...and so much more + +DraftFast provides support and consulting services that can help with all of these. [Let's get in touch today](mailto:ben.brostoff@gmail.com). + +# Contributing + +Run tests or set of tests: + +```sh +# All tests +nosetests + +# Single file +nosetests draftfast/test/test_soccer.py + +# Single test +nosetests draftfast/test/test_soccer.py:test_soccer_dk_no_opp_d +``` + +Run linting + +``` +flake8 draftfast +``` + +# Credits + +Special thanks to [swanson](https://github.com/swanson/), who authored [this repo](https://github.com/swanson/degenerate), which was the inspiration for this one. + +Current project maintainers: + +- [BenBrostoff](https://github.com/BenBrostoff) +- [sharkiteuthis](https://github.com/sharkiteuthis) + + + + +%package help +Summary: Development documents and examples for draftfast +Provides: python3-draftfast-doc +%description help +## Introduction · [](https://travis-ci.org/BenBrostoff/draftfast) · [](https://draftfast.herokuapp.com/) + + + +An incredibly powerful tool that automates and optimizes lineup building, allowing you to enter thousands of lineups in any DraftKings or FanDuel contest in the time it takes you to grab a coffee. + +## Installation + +Requires Python 3.9+. + +```bash +pip install draftfast +``` + +## Usage + +Example usage ([you can experiment with these examples in repl.it](https://repl.it/@BenBrostoff/AllWarlikeDemoware)): + +```python +from draftfast import rules +from draftfast.optimize import run +from draftfast.orm import Player +from draftfast.csv_parse import salary_download + +# Create players for a classic DraftKings game +player_pool = [ + Player(name='A1', cost=5500, proj=55, pos='PG'), + Player(name='A2', cost=5500, proj=55, pos='PG'), + Player(name='A3', cost=5500, proj=55, pos='SG'), + Player(name='A4', cost=5500, proj=55, pos='SG'), + Player(name='A5', cost=5500, proj=55, pos='SF'), + Player(name='A6', cost=5500, proj=55, pos='SF'), + Player(name='A7', cost=5500, proj=55, pos='PF'), + Player(name='A8', cost=5500, proj=55, pos='PF'), + Player(name='A9', cost=5500, proj=55, pos='C'), + Player(name='A10', cost=5500, proj=55, pos='C'), +] + +roster = run( + rule_set=rules.DK_NBA_RULE_SET, + player_pool=player_pool, + verbose=True, +) + +# Or, alternatively, generate players from a CSV +players = salary_download.generate_players_from_csvs( + salary_file_location='./salaries.csv', + game=rules.DRAFT_KINGS, +) + +roster = run( + rule_set=rules.DK_NBA_RULE_SET, + player_pool=players, + verbose=True, +) +``` + +You can see more examples in the [`examples` directory](https://github.com/BenBrostoff/draftfast/tree/master/examples). + +## Game Rules + +Optimizing for a particular game is as easy as setting the `RuleSet` (see the example above). Game rules in the library are in the table below: + +| League | Site | Reference | +| ------------- |:-------------:| :-----:| +| NFL | DraftKings | `DK_NFL_RULE_SET` | +| NFL | FanDuel | `FD_NFL_RULE_SET` | +| NBA | DraftKings | `DK_NBA_RULE_SET` | +| NBA | FanDuel | `FD_NBA_RULE_SET` | +| MLB | DraftKings | `DK_MLB_RULE_SET` | +| MLB | FanDuel | `FD_MLB_RULE_SET` | +| WNBA | DraftKings | `DK_WNBA_RULE_SET` | +| WNBA | FanDuel | `FD_WNBA_RULE_SET` | +| PGA | FanDuel | `FD_PGA_RULE_SET` | +| PGA | DraftKings | `DK_PGA_RULE_SET` | +| PGA_CAPTAIN | DraftKings | `DK_PGA_CAPTAIN_RULE_SET` | +| NASCAR | FanDuel | `FD_NASCAR_RULE_SET` | +| NASCAR | DraftKings | `DK_NASCAR_RULE_SET` | +| SOCCER | DraftKings | `DK_SOCCER_RULE_SET` | +| EuroLeague | DraftKings | `DK_EURO_LEAGUE_RULE_SET` | +| NHL | DraftKings | `DK_NHL_RULE_SET` | +| NBA Pickem | DraftKings | `DK_NBA_PICKEM_RULE_SET` | +| NFL Showdown | DraftKings | `DK_NFL_SHOWDOWN_RULE_SET` | +| NBA Showdown | DraftKings | `DK_NBA_SHOWDOWN_RULE_SET` | +| MLB Showdown | DraftKings | `DK_MLB_SHOWDOWN_RULE_SET` | +| XFL | DraftKings | `DK_XFL_CLASSIC_RULE_SET` | +| Tennis | DraftKings | `DK_TEN_CLASSIC_RULE_SET` | +| CS:GO | DraftKings | `DK_CSGO_SHOWDOWN` | +| F1 | DraftKings | `DK_F1_SHOWDOWN` | +| NFL MVP | FanDuel | `FD_NFL_MVP_RULE_SET` | +| MLB MVP | FanDuel | `FD_MLB_MVP_RULE_SET` | +| NBA MVP | FanDuel | `FD_NBA_MVP_RULE_SET` | + +Note that you can also tune `draftfast` for any game of your choice even if it's not implemented in the library (PRs welcome!). Using the `RuleSet` class, you can generate your own game rules that specific number of players, salary, etc. Example: + +```python +from draftfast import rules + +golf_rules = rules.RuleSet( + site=rules.DRAFT_KINGS, + league='PGA', + roster_size='6', + position_limits=[['G', 6, 6]], + salary_max=50_000, +) +``` + +## Settings + +Usage example: + +```python +class Showdown(Roster): + POSITION_ORDER = { + 'M': 0, + 'F': 1, + 'D': 2, + 'GK': 3, + } + + +showdown_limits = [ + ['M', 0, 6], + ['F', 0, 6], + ['D', 0, 6], + ['GK', 0, 6], +] + +soccer_rules = rules.RuleSet( + site=rules.DRAFT_KINGS, + league='SOCCER_SHOWDOWN', + roster_size=6, + position_limits=showdown_limits, + salary_max=50_000, + general_position_limits=[], +) +player_pool = salary_download.generate_players_from_csvs( + salary_file_location=salary_file, + game=rules.DRAFT_KINGS, +) +roster = run( + rule_set=soccer_rules, + player_pool=player_pool, + verbose=True, + roster_gen=Showdown, +) +``` + +`PlayerPoolSettings` + +- `min_proj` +- `max_proj` +- `min_salary` +- `max_salary` +- `min_avg` +- `max_avg` + +`OptimizerSettings` + +- `stacks` - A list of `Stack` objects. Example: + +```python +roster = run( + rule_set=rules.DK_NHL_RULE_SET, + player_pool=player_pool, + verbose=True, + optimizer_settings=OptimizerSettings( + stacks=[ + Stack(team='PHI', count=3), + Stack(team='FLA', count=3), + Stack(team='NSH', count=2), + ] + ), +) +``` + +`Stack` can also be tuned to support different combinations of positions. For NFL, +to only specify a QB-WRs based stack of five: + +```python +Stack( + team='NE', + count=5, + stack_lock_pos=['QB'], + stack_eligible_pos=['WR'], +) +``` + +- `custom_rules` - Define rules that set if / then conditions for lineups. + + +For example, if two WRs from the same team are in a naturally optimized lineup, then the QB must also be in the lineup. You can find some good examples of rules in `draftfast/test/test_custom_rules.py`. + +```python +from draftfast.optimize import run +from draftfast.settings import OptimizerSettings, CustomRule + +# If two WRs on one team, play the QB from same team +settings = OptimizerSettings( + custom_rules=[ + CustomRule( + group_a=lambda p: p.pos == 'WR' and p.team == 'Patriots', + group_b=lambda p: p.pos == 'QB' and p.team == 'Patriots', + comparison=lambda sum, a, b: sum(a) + 1 <= sum(b) + ) + ] +) +roster = run( + rule_set=rules.DK_NFL_RULE_SET, + player_pool=nfl_pool, + verbose=True, + optimizer_settings=settings, +) +``` + +Another common use case is given one player is in a lineup, always play another player: + +```python +from draftfast.optimize import run +from draftfast.settings import OptimizerSettings, CustomRule + +# If Player A, always play Player B and vice versa +settings = OptimizerSettings( + custom_rules=[ + CustomRule( + group_a=lambda p: p.name == 'Tom Brady', + group_b=lambda p: p.name == 'Rob Gronkowski', + comparison=lambda sum, a, b: sum(a) == sum(b) + ) + ] +) +roster = run( + rule_set=rules.DK_NFL_RULE_SET, + player_pool=nfl_pool, + verbose=True, + optimizer_settings=settings, +) +``` + +Custom rules also don't have to make a comparison between two groups. You can say "never play these two players in the same lineup" by using the `CustomRule#comparison` property. + +```python +# Never play these two players together +settings = OptimizerSettings( + custom_rules=[ + CustomRule( + group_a=lambda p: p, + group_b=lambda p: p.name == 'Devon Booker' or p.name == 'Chris Paul', + comparison=lambda sum, a, b: sum(b) <= 1 + ) + ] +) +roster = run( + rule_set=rules.DK_NBA_RULE_SET, + player_pool=nba_pool, + verbose=True, + optimizer_settings=settings, +) +``` + +Importantly, as of this writing, passing closures into `CustomRule`s does not work (ex. `lambda p: p.team == team`), +so dynamically generating rules is not possible. PRs welcome for a fix here, I believe this is a limitation of `ortools`. + +`LineupConstraints` + +- `locked` - list of players to lock +- `banned` - list of players to ban +- `groups` - list of player groups constraints. See below + +```python +roster = run( + rule_set=rules.DK_NFL_RULE_SET, + player_pool=player_pool, + verbose=True, + constraints=LineupConstraints( + locked=['Rob Gronkowski'], + banned=['Mark Ingram', 'Doug Martin'], + groups=[ + [('Todd Gurley', 'Melvin Gordon', 'Christian McCaffrey'), (2, 3)], + [('Chris Carson', 'Mike Davis'), 1], + ] + ) +) +``` + +- `no_offense_against_defense` - Do not allow offensive players to be matched up against defensive players in the optimized lineup. Currently only implemented for soccer, NHL, and NFL -- PRs welcome! + +## CSV Upload + +```python +from draftfast.csv_parse import uploaders + +uploader = uploaders.DraftKingsNBAUploader( + pid_file='./pid_file.csv', +) +uploader.write_rosters(rosters) + +``` + +## Support and Consulting + +DFS optimization is only one part of a sustainable strategy. Long-term DFS winners have the best: + +- Player projections +- Bankroll management +- Diversification in contests played +- Diversification across lineups (see `draftfast.exposure`) +- Research process +- 1 hour before gametime lineup changes +- ...and so much more + +DraftFast provides support and consulting services that can help with all of these. [Let's get in touch today](mailto:ben.brostoff@gmail.com). + +# Contributing + +Run tests or set of tests: + +```sh +# All tests +nosetests + +# Single file +nosetests draftfast/test/test_soccer.py + +# Single test +nosetests draftfast/test/test_soccer.py:test_soccer_dk_no_opp_d +``` + +Run linting + +``` +flake8 draftfast +``` + +# Credits + +Special thanks to [swanson](https://github.com/swanson/), who authored [this repo](https://github.com/swanson/degenerate), which was the inspiration for this one. + +Current project maintainers: + +- [BenBrostoff](https://github.com/BenBrostoff) +- [sharkiteuthis](https://github.com/sharkiteuthis) + + + + +%prep +%autosetup -n draftfast-3.8.0 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-draftfast -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Thu May 18 2023 Python_Bot <Python_Bot@openeuler.org> - 3.8.0-1 +- Package Spec generated @@ -0,0 +1 @@ +762ab139a1ae0ac88d24c2420efef71a draftfast-3.8.0.tar.gz |