Draftfast DFS Optimization Tool

To optimize lineups, use the run function from draftfast.optimize. You must provide a rule_set (defining the game constraints) and a player_pool (a list of Player objects or players generated from a CSV).

from draftfast import rules
from draftfast.optimize import run
from draftfast.orm import Player

# Define a player pool
player_pool = [
    Player(name='A1', cost=5500, proj=55, pos='PG'),
    Player(name='A2', cost=5500, proj=55, pos='PG'),
    # ... more players
]

# Run optimization
roster = run(
    rule_set=rules.DK_NBA_RULE_SET,
    player_pool=player_pool,
    verbose=True,
)

Install the draftfast package using pip. Requires Python 3.12 or higher.

pip install draftfast

You can run the Draftfast service using Docker Compose. The service is configured to run on the linux/arm64 platform (optimized for Apple Silicon Macs) using the intel-ben image. The current configuration mounts the local directory to /dk inside the container and uses tail -F anything as the command to keep the container running.

services:
  draftfast:
    platform: linux/arm64
    image: intel-ben
    command: tail -F anything
    volumes:
      - .:/dk

If a game is not pre-defined, you can instantiate a rules.RuleSet object to define custom roster sizes, position limits, and salary caps.

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,
)

To export generated rosters to a file format compatible with DraftKings, use the uploaders module.

from draftfast.csv_parse import uploaders

uploader = uploaders.DraftKingsNBAUploader(
    pid_file='./pid_file.csv',
)
uploader.write_rosters(rosters)

Use OptimizerSettings to pass Stack objects to the run function. Stacks allow you to force the optimizer to pick multiple players from the same team, often with specific position requirements.

from draftfast.optimize import run
from draftfast.settings import OptimizerSettings

# Example: A simple team stack
# Example: A specific QB-WR stack
stack_config = Stack(
    team='NE',
    count=5,
    stack_lock_pos=['QB'],
    stack_eligible_pos=['WR'],
)

roster = run(
    rule_set=rules.DK_NHL_RULE_SET,
    player_pool=player_pool,
    verbose=True,
    optimizer_settings=OptimizerSettings(
        stacks=[stack_config]
    ),
)

Instead of manually creating Player objects, you can use salary_download.generate_players_from_csvs to parse salary files into a player pool.

from draftfast.csv_parse import salary_download
from draftfast import rules

players = salary_download.generate_players_from_csvs(
  salary_file_location='./salaries.csv',
  game=rules.DRAFT_KINGS,
)

Use LineupConstraints to explicitly lock specific players into lineups, ban players from being selected, or enforce constraints on specific groups of players.

from draftfast.optimize import run
from draftfast.settings import LineupConstraints

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=[
            # Group constraint: pick between 2 and 3 players from this list
            [('Todd Gurley', 'Melvin Gordon', 'Christian McCaffrey'), (2, 3)],
            # Group constraint: pick exactly 1 player from this list
            [('Chris Carson', 'Mike Davis'), 1],
        ]
    )
)