prosperity3bt 0.1.0__py3-none-any.whl

prosperity3bt/__main__.py

@@ -0,0 +1,302 @@
+import sys
+import webbrowser
+from argparse import ArgumentParser
+from collections import defaultdict
+from datetime import datetime
+from functools import partial, reduce
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from importlib import import_module, metadata, reload
+from pathlib import Path
+from typing import Any, Optional
+
+from prosperity3bt.data import has_day_data
+from prosperity3bt.file_reader import FileReader, FileSystemReader, PackageResourcesReader
+from prosperity3bt.models import BacktestResult
+from prosperity3bt.runner import run_backtest
+
+
+def parse_algorithm(algorithm: str) -> Any:
+    algorithm_path = Path(algorithm).expanduser().resolve()
+    if not algorithm_path.is_file():
+        raise ModuleNotFoundError(f"{algorithm_path} is not a file")
+
+    sys.path.append(str(algorithm_path.parent))
+    return import_module(algorithm_path.stem)
+
+
+def parse_data(data_root: Optional[str]) -> FileReader:
+    if data_root is not None:
+        return FileSystemReader(Path(data_root).expanduser().resolve())
+    else:
+        return PackageResourcesReader()
+
+
+def parse_days(file_reader: FileReader, days: list[str]) -> list[tuple[int, int]]:
+    parsed_days = []
+
+    for arg in days:
+        if "-" in arg:
+            round_num, day_num = map(int, arg.split("-", 1))
+
+            if not has_day_data(file_reader, round_num, day_num):
+                print(f"Warning: no data found for round {round_num} day {day_num}")
+                continue
+
+            parsed_days.append((round_num, day_num))
+        else:
+            round_num = int(arg)
+
+            parsed_days_in_round = []
+            for day_num in range(-5, 6):
+                if has_day_data(file_reader, round_num, day_num):
+                    parsed_days_in_round.append((round_num, day_num))
+
+            if len(parsed_days_in_round) == 0:
+                print(f"Warning: no data found for round {round_num}")
+                continue
+
+            parsed_days.extend(parsed_days_in_round)
+
+    if len(parsed_days) == 0:
+        print("Error: did not find data for any requested round/day")
+        sys.exit(1)
+
+    return parsed_days
+
+
+def parse_out(out: Optional[str], no_out: bool) -> Optional[Path]:
+    if out is not None:
+        return Path(out).expanduser().resolve()
+
+    if no_out:
+        return None
+
+    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    return Path.cwd() / "backtests" / f"{timestamp}.log"
+
+
+def print_day_summary(result: BacktestResult) -> None:
+    last_timestamp = result.activity_logs[-1].timestamp
+
+    product_lines = []
+    total_profit = 0
+
+    for row in reversed(result.activity_logs):
+        if row.timestamp != last_timestamp:
+            break
+
+        product = row.columns[2]
+        profit = row.columns[-1]
+
+        product_lines.append(f"{product}: {profit:,.0f}")
+        total_profit += profit
+
+    print(*reversed(product_lines), sep="\n")
+    print(f"Total profit: {total_profit:,.0f}")
+
+
+def merge_results(
+    a: BacktestResult, b: BacktestResult, merge_profit_loss: bool, merge_timestamps: bool
+) -> BacktestResult:
+    sandbox_logs = a.sandbox_logs[:]
+    activity_logs = a.activity_logs[:]
+    trades = a.trades[:]
+
+    if merge_timestamps:
+        a_last_timestamp = a.activity_logs[-1].timestamp
+        timestamp_offset = a_last_timestamp + 100
+    else:
+        timestamp_offset = 0
+
+    sandbox_logs.extend([row.with_offset(timestamp_offset) for row in b.sandbox_logs])
+    trades.extend([row.with_offset(timestamp_offset) for row in b.trades])
+
+    if merge_profit_loss:
+        profit_loss_offsets = defaultdict(float)
+        for row in reversed(a.activity_logs):
+            if row.timestamp != a_last_timestamp:
+                break
+
+            profit_loss_offsets[row.columns[2]] = row.columns[-1]
+
+        activity_logs.extend(
+            [row.with_offset(timestamp_offset, profit_loss_offsets[row.columns[2]]) for row in b.activity_logs]
+        )
+    else:
+        activity_logs.extend([row.with_offset(timestamp_offset, 0) for row in b.activity_logs])
+
+    return BacktestResult(a.round_num, a.day_num, sandbox_logs, activity_logs, trades)
+
+
+def write_output(output_file: Path, merged_results: BacktestResult) -> None:
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    with output_file.open("w+", encoding="utf-8") as file:
+        file.write("Sandbox logs:\n")
+        for row in merged_results.sandbox_logs:
+            file.write(str(row))
+
+        file.write("\n\n\nActivities log:\n")
+        file.write(
+            "day;timestamp;product;bid_price_1;bid_volume_1;bid_price_2;bid_volume_2;bid_price_3;bid_volume_3;ask_price_1;ask_volume_1;ask_price_2;ask_volume_2;ask_price_3;ask_volume_3;mid_price;profit_and_loss\n"
+        )
+        file.write("\n".join(map(str, merged_results.activity_logs)))
+
+        file.write("\n\n\n\n\nTrade History:\n")
+        file.write("[\n")
+        file.write(",\n".join(map(str, merged_results.trades)))
+        file.write("]")
+
+
+def print_overall_summary(results: list[BacktestResult]) -> None:
+    print("Profit summary:")
+
+    total_profit = 0
+    for result in results:
+        last_timestamp = result.activity_logs[-1].timestamp
+
+        profit = 0
+        for row in reversed(result.activity_logs):
+            if row.timestamp != last_timestamp:
+                break
+
+            profit += row.columns[-1]
+
+        print(f"Round {result.round_num} day {result.day_num}: {profit:,.0f}")
+        total_profit += profit
+
+    print(f"Total profit: {total_profit:,.0f}")
+
+
+class HTTPRequestHandler(SimpleHTTPRequestHandler):
+    def end_headers(self) -> None:
+        self.send_header("Access-Control-Allow-Origin", "*")
+        return super().end_headers()
+
+    def log_message(self, format: str, *args: Any) -> None:
+        return
+
+
+def open_visualizer(output_file: Path, no_requests: int) -> None:
+    http_handler = partial(HTTPRequestHandler, directory=output_file.parent)
+    http_server = HTTPServer(("localhost", 0), http_handler)
+
+    webbrowser.open(
+        f"https://jmerle.github.io/imc-prosperity-3-visualizer/?open=http://localhost:{http_server.server_port}/{output_file.name}"
+    )
+
+    # Chrome makes 2 requests: 1 OPTIONS request to check for CORS headers and 1 GET request to get the data
+    # Some users reported their browser only makes 1 request, which is covered by the --vis-requests option
+    for _ in range(no_requests):
+        http_server.handle_request()
+
+
+def format_path(path: Path) -> str:
+    cwd = Path.cwd()
+    if path.is_relative_to(cwd):
+        return str(path.relative_to(cwd))
+    else:
+        return str(path)
+
+
+def main() -> None:
+    parser = ArgumentParser(prog="prosperity3bt", description="Run a backtest.")
+    parser.add_argument("algorithm", type=str, help="path to the Python file containing the algoritm to backtest")
+    parser.add_argument(
+        "days",
+        type=str,
+        nargs="+",
+        help="the days to backtest on (<round>-<day> for a single day, <round> for all days in a round)",
+    )
+    parser.add_argument("--merge-pnl", action="store_true", help="merge profit and loss across days")
+    parser.add_argument("--vis", action="store_true", help="open backtest result in visualizer when done")
+    parser.add_argument("--out", type=str, help="path to save output log to (defaults to backtests/<timestamp>.log)")
+    parser.add_argument(
+        "--data",
+        type=str,
+        help="path to data directory (must look similar in structure to https://github.com/jmerle/imc-prosperity-3-backtester/tree/master/prosperity3bt/resources)",
+    )
+    parser.add_argument("--print", action="store_true", help="print the trader's output to stdout while it's running")
+    parser.add_argument(
+        "--no-trades-matching", action="store_true", help="disable matching orders against market trades"
+    )
+    parser.add_argument("--no-out", action="store_true", help="skip saving the output log to a file")
+    parser.add_argument("--no-progress", action="store_true", help="don't show progress bars")
+    parser.add_argument(
+        "--vis-requests",
+        type=int,
+        default=2,
+        help="number of requests the visualizer is expected to make to the backtester's HTTP server when using --vis",
+    )
+    parser.add_argument(
+        "--original-timestamps",
+        action="store_true",
+        help="preserve original timestamps in output log rather than making them increase across days",
+    )
+    # parser.add_argument(
+    #     "--no-names", action="store_true", help="don't use de-anonymized trades data, even if it exists"
+    # )
+    parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {metadata.version(__package__)}")
+
+    args = parser.parse_args()
+
+    if args.vis and args.no_out:
+        print("Error: --vis and --no-out are mutually exclusive")
+        sys.exit(1)
+
+    if args.out is not None and args.no_out:
+        print("Error: --out and --no-out are mutually exclusive")
+        sys.exit(1)
+
+    try:
+        trader_module = parse_algorithm(args.algorithm)
+    except ModuleNotFoundError as e:
+        print(f"{args.algorithm} is not a valid algorithm file: {e}")
+        sys.exit(1)
+
+    if not hasattr(trader_module, "Trader"):
+        print(f"{args.algorithm} does not expose a Trader class")
+        sys.exit(1)
+
+    file_reader = parse_data(args.data)
+    days = parse_days(file_reader, args.days)
+    output_file = parse_out(args.out, args.no_out)
+
+    show_progress_bars = not args.no_progress and not args.print
+
+    results = []
+    for round_num, day_num in days:
+        print(f"Backtesting {args.algorithm} on round {round_num} day {day_num}")
+
+        reload(trader_module)
+
+        result = run_backtest(
+            trader_module.Trader(),
+            file_reader,
+            round_num,
+            day_num,
+            args.print,
+            args.no_trades_matching,
+            True,  # args.no_names,
+            show_progress_bars,
+        )
+
+        print_day_summary(result)
+        if len(days) > 1:
+            print()
+
+        results.append(result)
+
+    if len(days) > 1:
+        print_overall_summary(results)
+
+    if output_file is not None:
+        merged_results = reduce(lambda a, b: merge_results(a, b, args.merge_pnl, not args.original_timestamps), results)
+        write_output(output_file, merged_results)
+        print(f"\nSuccessfully saved backtest results to {format_path(output_file)}")
+
+    if args.vis:
+        open_visualizer(output_file, args.vis_requests)
+
+
+if __name__ == "__main__":
+    main()

prosperity3bt/data.py

@@ -0,0 +1,125 @@
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Optional
+
+from prosperity3bt.datamodel import Symbol, Trade
+from prosperity3bt.file_reader import FileReader
+
+LIMITS = {
+    "RAINFOREST_RESIN": 50,
+    "KELP": 50,
+}
+
+
+@dataclass
+class PriceRow:
+    day: int
+    timestamp: int
+    product: Symbol
+    bid_prices: list[int]
+    bid_volumes: list[int]
+    ask_prices: list[int]
+    ask_volumes: list[int]
+    mid_price: float
+    profit_loss: float
+
+
+def get_column_values(columns: list[str], indices: list[int]) -> list[int]:
+    values = []
+
+    for index in indices:
+        value = columns[index]
+        if value == "":
+            break
+
+        values.append(int(value))
+
+    return values
+
+
+@dataclass
+class BacktestData:
+    round_num: int
+    day_num: int
+
+    prices: dict[int, dict[Symbol, PriceRow]]
+    trades: dict[int, dict[Symbol, list[Trade]]]
+    products: list[Symbol]
+    profit_loss: dict[Symbol, int]
+
+
+def create_backtest_data(round_num: int, day_num: int, prices: list[PriceRow], trades: list[Trade]) -> BacktestData:
+    prices_by_timestamp: dict[int, dict[Symbol, PriceRow]] = defaultdict(dict)
+    for row in prices:
+        prices_by_timestamp[row.timestamp][row.product] = row
+
+    trades_by_timestamp: dict[int, dict[Symbol, list[Trade]]] = defaultdict(lambda: defaultdict(list))
+    for trade in trades:
+        trades_by_timestamp[trade.timestamp][trade.symbol].append(trade)
+
+    products = sorted(set(row.product for row in prices))
+    profit_loss = {product: 0 for product in products}
+
+    return BacktestData(
+        round_num=round_num,
+        day_num=day_num,
+        prices=prices_by_timestamp,
+        trades=trades_by_timestamp,
+        products=products,
+        profit_loss=profit_loss,
+    )
+
+
+def has_day_data(file_reader: FileReader, round_num: int, day_num: int) -> bool:
+    with file_reader.file([f"round{round_num}", f"prices_round_{round_num}_day_{day_num}.csv"]) as file:
+        return file is not None
+
+
+def read_day_data(file_reader: FileReader, round_num: int, day_num: int, no_names: bool) -> Optional[BacktestData]:
+    prices = []
+    with file_reader.file([f"round{round_num}", f"prices_round_{round_num}_day_{day_num}.csv"]) as file:
+        if file is None:
+            return None
+
+        for line in file.read_text(encoding="utf-8").splitlines()[1:]:
+            columns = line.split(";")
+
+            prices.append(
+                PriceRow(
+                    day=int(columns[0]),
+                    timestamp=int(columns[1]),
+                    product=columns[2],
+                    bid_prices=get_column_values(columns, [3, 5, 7]),
+                    bid_volumes=get_column_values(columns, [4, 6, 8]),
+                    ask_prices=get_column_values(columns, [9, 11, 13]),
+                    ask_volumes=get_column_values(columns, [10, 12, 14]),
+                    mid_price=float(columns[15]),
+                    profit_loss=float(columns[16]),
+                )
+            )
+
+    trades = []
+    trades_suffixes = ["nn"] if no_names else ["wn", "nn"]
+
+    for suffix in trades_suffixes:
+        with file_reader.file([f"round{round_num}", f"trades_round_{round_num}_day_{day_num}_{suffix}.csv"]) as file:
+            if file is None:
+                continue
+
+            for line in file.read_text(encoding="utf-8").splitlines()[1:]:
+                columns = line.split(";")
+
+                trades.append(
+                    Trade(
+                        symbol=columns[3],
+                        price=int(float(columns[5])),
+                        quantity=int(columns[6]),
+                        buyer=columns[1],
+                        seller=columns[2],
+                        timestamp=int(columns[0]),
+                    )
+                )
+
+            break
+
+    return create_backtest_data(round_num, day_num, prices, trades)

prosperity3bt/datamodel.py

@@ -0,0 +1,153 @@
+import json
+from json import JSONEncoder
+from typing import Dict, List
+
+import jsonpickle
+
+Time = int
+Symbol = str
+Product = str
+Position = int
+UserId = str
+ObservationValue = int
+
+
+class Listing:
+    def __init__(self, symbol: Symbol, product: Product, denomination: Product):
+        self.symbol = symbol
+        self.product = product
+        self.denomination = denomination
+
+
+class ConversionObservation:
+    def __init__(
+        self,
+        bidPrice: float,
+        askPrice: float,
+        transportFees: float,
+        exportTariff: float,
+        importTariff: float,
+        sugarPrice: float,
+        sunlightIndex: float,
+    ):
+        self.bidPrice = bidPrice
+        self.askPrice = askPrice
+        self.transportFees = transportFees
+        self.exportTariff = exportTariff
+        self.importTariff = importTariff
+        self.sugarPrice = sugarPrice
+        self.sunlightIndex = sunlightIndex
+
+
+class Observation:
+    def __init__(
+        self,
+        plainValueObservations: Dict[Product, ObservationValue],
+        conversionObservations: Dict[Product, ConversionObservation],
+    ) -> None:
+        self.plainValueObservations = plainValueObservations
+        self.conversionObservations = conversionObservations
+
+    def __str__(self) -> str:
+        return (
+            "(plainValueObservations: "
+            + jsonpickle.encode(self.plainValueObservations)
+            + ", conversionObservations: "
+            + jsonpickle.encode(self.conversionObservations)
+            + ")"
+        )
+
+
+class Order:
+    def __init__(self, symbol: Symbol, price: int, quantity: int) -> None:
+        self.symbol = symbol
+        self.price = price
+        self.quantity = quantity
+
+    def __str__(self) -> str:
+        return "(" + self.symbol + ", " + str(self.price) + ", " + str(self.quantity) + ")"
+
+    def __repr__(self) -> str:
+        return "(" + self.symbol + ", " + str(self.price) + ", " + str(self.quantity) + ")"
+
+
+class OrderDepth:
+    def __init__(self):
+        self.buy_orders: Dict[int, int] = {}
+        self.sell_orders: Dict[int, int] = {}
+
+
+class Trade:
+    def __init__(
+        self, symbol: Symbol, price: int, quantity: int, buyer: UserId = None, seller: UserId = None, timestamp: int = 0
+    ) -> None:
+        self.symbol = symbol
+        self.price: int = price
+        self.quantity: int = quantity
+        self.buyer = buyer
+        self.seller = seller
+        self.timestamp = timestamp
+
+    def __str__(self) -> str:
+        return (
+            "("
+            + self.symbol
+            + ", "
+            + self.buyer
+            + " << "
+            + self.seller
+            + ", "
+            + str(self.price)
+            + ", "
+            + str(self.quantity)
+            + ", "
+            + str(self.timestamp)
+            + ")"
+        )
+
+    def __repr__(self) -> str:
+        return (
+            "("
+            + self.symbol
+            + ", "
+            + self.buyer
+            + " << "
+            + self.seller
+            + ", "
+            + str(self.price)
+            + ", "
+            + str(self.quantity)
+            + ", "
+            + str(self.timestamp)
+            + ")"
+        )
+
+
+class TradingState(object):
+    def __init__(
+        self,
+        traderData: str,
+        timestamp: Time,
+        listings: Dict[Symbol, Listing],
+        order_depths: Dict[Symbol, OrderDepth],
+        own_trades: Dict[Symbol, List[Trade]],
+        market_trades: Dict[Symbol, List[Trade]],
+        position: Dict[Product, Position],
+        observations: Observation,
+    ):
+        self.traderData = traderData
+        self.timestamp = timestamp
+        self.listings = listings
+        self.order_depths = order_depths
+        self.own_trades = own_trades
+        self.market_trades = market_trades
+        self.position = position
+        self.observations = observations
+
+    def toJSON(self):
+        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True)
+
+
+class ProsperityEncoder(JSONEncoder):
+    def default(self, o):
+        return o.__dict__

prosperity3bt/file_reader.py

@@ -0,0 +1,44 @@
+from abc import abstractmethod
+from contextlib import contextmanager
+from importlib import resources
+from pathlib import Path
+from typing import ContextManager, Optional
+
+
+@contextmanager
+def wrap_in_context_manager(value):
+    yield value
+
+
+class FileReader:
+    @abstractmethod
+    def file(self, path_parts: list[str]) -> ContextManager[Optional[Path]]:
+        """Given a path to a file, yields a single Path object to the file or None if the file does not exist."""
+        raise NotImplementedError()
+
+
+class FileSystemReader(FileReader):
+    def __init__(self, root: Path) -> None:
+        self._root = root
+
+    def file(self, path_parts: list[str]) -> ContextManager[Optional[Path]]:
+        file = self._root
+        for part in path_parts:
+            file = file / part
+
+        if not file.is_file():
+            return wrap_in_context_manager(None)
+
+        return wrap_in_context_manager(file)
+
+
+class PackageResourcesReader(FileReader):
+    def file(self, path_parts: list[str]) -> ContextManager[Optional[Path]]:
+        try:
+            container = resources.files(f"prosperity3bt.resources.{'.'.join(path_parts[:-1])}")
+            if not (container / path_parts[-1]).is_file():
+                return wrap_in_context_manager(None)
+
+            return resources.as_file(container / path_parts[-1])
+        except Exception:
+            return wrap_in_context_manager(None)