uselayer 0.1.0__tar.gz

uselayer-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+uv.lock.bak

uselayer-0.1.0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## 0.1.0 (unreleased)
+
+- `Client` in paper mode (the default): orders fill against Polymarket US's live public order books
+  through Layer's fill model; nothing is sent to the venue.
+- Live mode for Polymarket US with your own API key (`PolymarketUS`): signed orders, cancel and
+  cancel-all, open orders, fills, positions and balance; fresh books from the venue's WebSocket; an
+  unknown order outcome is looked up and never resent; a new store starts killed when the account
+  already has open orders or positions.
+- Backtest mode: replay books you saved with `uselayer.backtest.record_books`.
+- Pairs: `quote()` prices YES on one market plus NO on its twin after both fees; `trade()` places both
+  legs with the leg-risk guard (thinner leg first, second leg up to break-even, chase, then unwind or
+  report the exposure); `run(strategy, pairs)` runs the same strategy in backtest, paper or live.
+- One order shape for every venue and mode, published as `schema/order.json`.
+- `preview()`: the fill, fees and every rule's decision, without sending anything.
+- Guardrails: max position, budget, max daily loss, allowed venues/markets/actions, expiry,
+  approval above a size, stop-loss and take-profit; an always-on price collar, order throttle and
+  kill switch (`python -m uselayer kill | resume | status`).
+- Dated venue rules: fee schedules looked up by the time of the trade.
+- Fee math, `profit()` and `size()` that match Layer's API to the millionth of a dollar.
+- One error type, `VenueError`, with `code`, `hint`, `next` and `retryable`; retries and pacing per
+  venue host.
+- Local SQLite store per mode; no telemetry.

uselayer-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Precious Emakenemi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uselayer-0.1.0/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.5
+Name: uselayer
+Version: 0.1.0
+Summary: Trade prediction markets with your own venue keys: one order shape, paper mode by default, guardrails, and fee math that matches Layer's API.
+Project-URL: Homepage, https://uselayer.sh
+Project-URL: Source, https://github.com/Dave-56/uselayer-sdk
+Author: Layer
+License-Expression: MIT
+License-File: LICENSE
+Keywords: polymarket,prediction markets,sdk,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: cryptography>=42
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.7
+Requires-Dist: websockets>=13
+Provides-Extra: yaml
+Requires-Dist: pyyaml>=6; extra == 'yaml'
+Description-Content-Type: text/markdown
+
+# uselayer
+
+A Python SDK for trading prediction markets with your own venue keys.
+
+This release (0.1) trades **Polymarket US**. **Paper mode** (the default) fills orders against the
+venue's real order books with simulated money and sends nothing to the venue. **Live mode** sends
+orders with your own Polymarket US API key. **Backtest mode** replays books you saved.
+
+- One order shape for every venue and mode, published as a JSON Schema (`schema/order.json`).
+- Paper mode is the default. `preview()` shows what an order would do and sends nothing.
+- Guardrails check every order before it's sent: position size, budget, daily loss, allowed markets,
+  approvals, stop-loss and take-profit. A price collar, an order throttle and a kill switch are
+  always on.
+- Fees come from each venue's published schedule in force at the time of the trade. They match
+  Layer's API (`POST /v0/profit`, `POST /v0/size`) to the millionth of a dollar.
+- Everything stays on your machine: a local SQLite file per mode, no telemetry.
+
+## Install
+
+```bash
+pip install uselayer
+```
+
+Python 3.11 or newer.
+
+## Paper trade in five lines
+
+```python
+from uselayer import Client
+
+client = Client()  # paper mode: real books, simulated fills
+m = client.markets(limit=20)[0]  # open Polymarket US markets, no key needed
+book = client.book(m.slug)
+order = client.order(
+    venue="polymarket_us", market=m.slug, side="yes", price=book.outcome("yes").best_ask.price, size=5
+)
+print(client.preview(order))  # fill, fees, every rule's decision
+print(client.send(order))  # the order, filled against the book
+```
+
+`client.positions()`, `client.fills()` and `client.orders()` read the local store. Every fill in paper
+mode is a `SimulatedFill` with `simulated=True`.
+
+## Live mode
+
+```python
+from uselayer import Client, PolymarketUS
+
+client = Client(mode="live", polymarket_us=PolymarketUS(key_id="...", secret_key_path="~/.pmus/secret"))
+client.balances()["polymarket_us"].cash
+order = client.buy(venue="polymarket_us", market="<slug>", side="yes", price=0.42, size=5)
+client.positions()                                     # from the venue
+```
+
+Create the key at polymarket.us/developer. It stays on your machine: requests are signed with it
+locally and only the signature is sent. Books in live mode come from the venue's WebSocket, so they
+aren't cached. An order whose answer never arrives raises `outcome_unknown` and is never sent again
+on its own: call `client.sync()` and check `client.orders()`.
+
+If the local store is new but your account already has open orders or positions, live mode starts
+with the kill switch on, until you run `python -m uselayer resume --mode live`.
+
+## Guardrails
+
+```python
+client = Client(
+    rules={
+        "max_position": {"per_market": 200},  # $ at risk in one market
+        "budget": 1000,  # $ at risk in total
+        "max_daily_loss": {"amount": 150},  # stop opening positions after this loss today
+        "approve_above": 100,  # ask before orders above $100
+        "stop_loss": {"pct": 25},  # exits sent by client.monitor()
+    }
+)
+```
+
+Rules can also come from a YAML or JSON file: `Client(rules="guardrails.yaml")` (YAML needs
+`pip install "uselayer[yaml]"`). They're fixed when the client is created.
+
+**Kill switch.** `client.kill()` cancels resting orders and blocks new ones. From another terminal:
+`python -m uselayer kill`. It stays on, even after a restart, until a person runs
+`python -m uselayer resume`. The client a strategy or agent holds can't resume.
+
+## Pairs: both sides, with the leg-risk guard
+
+When two markets are the same bet, buying YES on one and NO on the other pays $1 per contract
+either way. `quote()` prices that after both fees; `trade()` places both legs:
+
+```python
+q = client.quote(pair)                        # pair: a Match from client.matches(), or two (venue, market)
+t = client.trade(pair, size=100, min_edge=0.01)
+t.status                                      # "hedged" | "missed" | "unwound" | "exposed"
+```
+
+The thinner leg goes first, immediate-or-cancel. The other leg goes for what filled, up to its
+break-even price. If it can't be completed within `chase_s`, the first leg is sold back, never below
+its entry price minus `max_unwind_loss` (`on_miss="unwind"`, the default), or the open contracts are
+reported (`on_miss="hold"`). Both legs pass the guardrails together before either is sent.
+
+In this release `trade()` runs in paper and backtest mode.
+
+## One strategy, every mode
+
+```python
+def strategy(client, pair, quote):
+    if quote.net_profit_per_contract >= 0.02:
+        client.trade(pair, size=100)
+
+Client(mode="backtest", books=saved_books).run(strategy, [pair])   # the past
+Client().run(strategy, [pair], iterations=60)                      # now, paper
+```
+
+## Backtest on books you saved
+
+```python
+from uselayer import Client
+from uselayer.backtest import load_books, record_books
+
+record_books(Client(), ["<slug>"], "books.jsonl")  # run on a schedule to build a history
+
+bt = Client(mode="backtest", books=load_books("books.jsonl"))
+bt.replay(lambda client, book: ...)  # place orders as each book arrives
+```
+
+The replay uses the same fill model, fees and rules as paper mode, on the replayed clock.
+
+## Fees by date
+
+```python
+from datetime import UTC, datetime
+from uselayer import FeeSettings, calculate_fee, rules_at
+
+rules_at("polymarket_us", datetime.now(UTC)).source  # the schedule's page
+calculate_fee(
+    FeeSettings(venue="polymarket_us"), contracts=100, price=0.5, role="taker", at=datetime.now(UTC)
+)
+```
+
+Before the earliest schedule the SDK knows, it raises `no_venue_rules` instead of guessing.
+
+## What paper mode can't tell you
+
+- **Queue position.** A paper order that rests fills as soon as a later book reaches its price. A real
+  one waits in line, so paper fills look at least as good as live ones.
+- **Freshness without a key.** In paper mode, Polymarket US's public book is cached for up to 30
+  seconds. The SDK stamps each book with the venue's time and, when a copy is older than
+  `max_quote_age_s` (10 s by default), waits for a fresh one before using it.
+
+## For AI agents
+
+`AGENTS.md` and `llms.txt` ship inside the package. Every public method has a docstring with an
+example, every object has `.to_dict()`, and every error is a `VenueError` with `code`, `hint` and
+`next`. The `examples/` folder runs in CI.
+
+## Layer
+
+Layer (uselayer.sh) finds markets that are the same bet on different venues. With a Layer API key,
+`client.matches(q="...")` returns them. The SDK sends Layer your key, the market ids Layer gave you
+and your filters, and nothing else: no prices, orders, positions or venue keys.
+
+## License
+
+MIT

uselayer-0.1.0/README.md

@@ -0,0 +1,163 @@
+# uselayer
+
+A Python SDK for trading prediction markets with your own venue keys.
+
+This release (0.1) trades **Polymarket US**. **Paper mode** (the default) fills orders against the
+venue's real order books with simulated money and sends nothing to the venue. **Live mode** sends
+orders with your own Polymarket US API key. **Backtest mode** replays books you saved.
+
+- One order shape for every venue and mode, published as a JSON Schema (`schema/order.json`).
+- Paper mode is the default. `preview()` shows what an order would do and sends nothing.
+- Guardrails check every order before it's sent: position size, budget, daily loss, allowed markets,
+  approvals, stop-loss and take-profit. A price collar, an order throttle and a kill switch are
+  always on.
+- Fees come from each venue's published schedule in force at the time of the trade. They match
+  Layer's API (`POST /v0/profit`, `POST /v0/size`) to the millionth of a dollar.
+- Everything stays on your machine: a local SQLite file per mode, no telemetry.
+
+## Install
+
+```bash
+pip install uselayer
+```
+
+Python 3.11 or newer.
+
+## Paper trade in five lines
+
+```python
+from uselayer import Client
+
+client = Client()  # paper mode: real books, simulated fills
+m = client.markets(limit=20)[0]  # open Polymarket US markets, no key needed
+book = client.book(m.slug)
+order = client.order(
+    venue="polymarket_us", market=m.slug, side="yes", price=book.outcome("yes").best_ask.price, size=5
+)
+print(client.preview(order))  # fill, fees, every rule's decision
+print(client.send(order))  # the order, filled against the book
+```
+
+`client.positions()`, `client.fills()` and `client.orders()` read the local store. Every fill in paper
+mode is a `SimulatedFill` with `simulated=True`.
+
+## Live mode
+
+```python
+from uselayer import Client, PolymarketUS
+
+client = Client(mode="live", polymarket_us=PolymarketUS(key_id="...", secret_key_path="~/.pmus/secret"))
+client.balances()["polymarket_us"].cash
+order = client.buy(venue="polymarket_us", market="<slug>", side="yes", price=0.42, size=5)
+client.positions()                                     # from the venue
+```
+
+Create the key at polymarket.us/developer. It stays on your machine: requests are signed with it
+locally and only the signature is sent. Books in live mode come from the venue's WebSocket, so they
+aren't cached. An order whose answer never arrives raises `outcome_unknown` and is never sent again
+on its own: call `client.sync()` and check `client.orders()`.
+
+If the local store is new but your account already has open orders or positions, live mode starts
+with the kill switch on, until you run `python -m uselayer resume --mode live`.
+
+## Guardrails
+
+```python
+client = Client(
+    rules={
+        "max_position": {"per_market": 200},  # $ at risk in one market
+        "budget": 1000,  # $ at risk in total
+        "max_daily_loss": {"amount": 150},  # stop opening positions after this loss today
+        "approve_above": 100,  # ask before orders above $100
+        "stop_loss": {"pct": 25},  # exits sent by client.monitor()
+    }
+)
+```
+
+Rules can also come from a YAML or JSON file: `Client(rules="guardrails.yaml")` (YAML needs
+`pip install "uselayer[yaml]"`). They're fixed when the client is created.
+
+**Kill switch.** `client.kill()` cancels resting orders and blocks new ones. From another terminal:
+`python -m uselayer kill`. It stays on, even after a restart, until a person runs
+`python -m uselayer resume`. The client a strategy or agent holds can't resume.
+
+## Pairs: both sides, with the leg-risk guard
+
+When two markets are the same bet, buying YES on one and NO on the other pays $1 per contract
+either way. `quote()` prices that after both fees; `trade()` places both legs:
+
+```python
+q = client.quote(pair)                        # pair: a Match from client.matches(), or two (venue, market)
+t = client.trade(pair, size=100, min_edge=0.01)
+t.status                                      # "hedged" | "missed" | "unwound" | "exposed"
+```
+
+The thinner leg goes first, immediate-or-cancel. The other leg goes for what filled, up to its
+break-even price. If it can't be completed within `chase_s`, the first leg is sold back, never below
+its entry price minus `max_unwind_loss` (`on_miss="unwind"`, the default), or the open contracts are
+reported (`on_miss="hold"`). Both legs pass the guardrails together before either is sent.
+
+In this release `trade()` runs in paper and backtest mode.
+
+## One strategy, every mode
+
+```python
+def strategy(client, pair, quote):
+    if quote.net_profit_per_contract >= 0.02:
+        client.trade(pair, size=100)
+
+Client(mode="backtest", books=saved_books).run(strategy, [pair])   # the past
+Client().run(strategy, [pair], iterations=60)                      # now, paper
+```
+
+## Backtest on books you saved
+
+```python
+from uselayer import Client
+from uselayer.backtest import load_books, record_books
+
+record_books(Client(), ["<slug>"], "books.jsonl")  # run on a schedule to build a history
+
+bt = Client(mode="backtest", books=load_books("books.jsonl"))
+bt.replay(lambda client, book: ...)  # place orders as each book arrives
+```
+
+The replay uses the same fill model, fees and rules as paper mode, on the replayed clock.
+
+## Fees by date
+
+```python
+from datetime import UTC, datetime
+from uselayer import FeeSettings, calculate_fee, rules_at
+
+rules_at("polymarket_us", datetime.now(UTC)).source  # the schedule's page
+calculate_fee(
+    FeeSettings(venue="polymarket_us"), contracts=100, price=0.5, role="taker", at=datetime.now(UTC)
+)
+```
+
+Before the earliest schedule the SDK knows, it raises `no_venue_rules` instead of guessing.
+
+## What paper mode can't tell you
+
+- **Queue position.** A paper order that rests fills as soon as a later book reaches its price. A real
+  one waits in line, so paper fills look at least as good as live ones.
+- **Freshness without a key.** In paper mode, Polymarket US's public book is cached for up to 30
+  seconds. The SDK stamps each book with the venue's time and, when a copy is older than
+  `max_quote_age_s` (10 s by default), waits for a fresh one before using it.
+
+## For AI agents
+
+`AGENTS.md` and `llms.txt` ship inside the package. Every public method has a docstring with an
+example, every object has `.to_dict()`, and every error is a `VenueError` with `code`, `hint` and
+`next`. The `examples/` folder runs in CI.
+
+## Layer
+
+Layer (uselayer.sh) finds markets that are the same bet on different venues. With a Layer API key,
+`client.matches(q="...")` returns them. The SDK sends Layer your key, the market ids Layer gave you
+and your filters, and nothing else: no prices, orders, positions or venue keys.
+
+## License
+
+MIT

uselayer-0.1.0/examples/01_book_and_preview.py

@@ -0,0 +1,22 @@
+"""Read a market's book and preview an order. Nothing is sent.
+
+python examples/01_book_and_preview.py
+"""
+
+from _pick import pick_market
+
+from uselayer import Client
+
+client = Client(store=":memory:")  # paper mode (the default); this store lives in memory only
+slug, book = pick_market(client)
+yes = book.outcome("yes")
+print(f"market {slug}: best bid {yes.best_bid.price}, best ask {yes.best_ask.price}, as of {book.as_of}")
+
+order = client.order(venue="polymarket_us", market=slug, side="yes", price=yes.best_ask.price, size=5)
+preview = client.preview(order)
+print(
+    f"allowed: {preview.allowed}, would fill {preview.est_fill.filled} @ {preview.est_fill.avg_price}, fees ${preview.fees}"
+)
+for d in preview.verdict.decisions:
+    if d.result != "allow":
+        print(f"  {d.rule}: {d.result} — {d.reason}")

uselayer-0.1.0/examples/02_paper_trade.py

@@ -0,0 +1,26 @@
+"""Buy in paper mode against the live book, then check the fee by hand.
+
+python examples/02_paper_trade.py
+"""
+
+from _pick import pick_market
+
+from uselayer import Client
+
+client = Client(store=":memory:")
+slug, book = pick_market(client)
+ask = book.outcome("yes").best_ask
+
+order = client.buy(venue="polymarket_us", market=slug, side="yes", price=ask.price, size=5)
+print(f"{order.status}: {order.filled} @ {order.avg_price}, fees ${order.fees}")
+
+coefficient = client.market(slug).fee_coefficient or 0.0695
+for fill in client.fills():
+    by_hand = coefficient * fill.contracts * fill.price * (1 - fill.price)
+    print(
+        f"  fill {fill.contracts} @ {fill.price}: fee ${fill.fee} (by hand ${by_hand:.4f}, billed to the cent)"
+    )
+    assert abs(fill.fee - by_hand) <= 0.005 + 1e-9
+
+for p in client.positions():
+    print(f"position: {p.contracts} {p.side} of {p.market} at {p.avg_price} (simulated: {p.simulated})")

uselayer-0.1.0/examples/03_rules_and_kill.py

@@ -0,0 +1,24 @@
+"""Set guardrails, see one block an order, then press the kill switch.
+
+python examples/03_rules_and_kill.py
+"""
+
+from _pick import pick_market
+
+from uselayer import Client, VenueError
+
+client = Client(store=":memory:", rules={"max_position": {"per_market": 3}, "budget": 10})
+slug, book = pick_market(client)
+ask = book.outcome("yes").best_ask
+
+big = client.order(venue="polymarket_us", market=slug, side="yes", price=ask.price, size=50)
+print("preview of a big order:", client.preview(big).blocked_by)  # max_position
+
+small = client.buy(venue="polymarket_us", market=slug, side="yes", price=ask.price, size=1)
+print("small order:", small.status)
+
+client.kill()  # cancels resting orders and blocks new ones (python -m uselayer kill does the same from a terminal)
+try:
+    client.buy(venue="polymarket_us", market=slug, side="yes", price=ask.price, size=1)
+except VenueError as e:
+    print(f"after kill: {e.code} by {e.rule}. {e.next}")

uselayer-0.1.0/examples/04_backtest_saved_books.py

@@ -0,0 +1,31 @@
+"""Save a few books, then replay them in backtest mode through the same fill model and rules.
+
+python examples/04_backtest_saved_books.py
+"""
+
+import tempfile
+from pathlib import Path
+
+from _pick import pick_market
+
+from uselayer import Book, Client
+from uselayer.backtest import load_books, record_books
+
+live = Client(store=":memory:")
+slug, _ = pick_market(live)
+path = Path(tempfile.mkdtemp()) / "books.jsonl"
+for _ in range(3):
+    record_books(live, [slug], path)  # in real use, call this on a schedule to build a history
+
+
+def strategy(client: Client, book: Book) -> None:
+    ask = book.outcome("yes").best_ask
+    if ask and not client.positions():
+        client.buy(venue=book.venue, market=book.market, side="yes", price=ask.price, size=2)
+
+
+bt = Client(mode="backtest", books=load_books(path))
+result = bt.replay(strategy)
+print(f"replayed {result['books']} books, {result['fills']} simulated fills")
+for p in bt.positions():
+    print(f"position: {p.contracts} @ {p.avg_price}, fees ${p.fees}")

uselayer-0.1.0/examples/05_fees_by_date.py

@@ -0,0 +1,21 @@
+"""Fees come from the schedule in force at the time of the trade.
+
+python examples/05_fees_by_date.py
+"""
+
+from datetime import UTC, datetime
+
+from uselayer import FeeSettings, calculate_fee, rules_at
+from uselayer.fees import dollars
+
+now = datetime.now(UTC)
+r = rules_at("polymarket_us", now)
+print(f"Polymarket US schedule from {r.effective_from.date()} ({r.source})")
+fee = calculate_fee(FeeSettings(venue="polymarket_us"), contracts=100, price=0.5, role="taker", at=now)
+print(f"100 contracts at $0.50, taker: ${dollars(fee)}")
+
+for when in (datetime(2026, 7, 9, tzinfo=UTC), datetime(2026, 7, 11, tzinfo=UTC)):
+    s = FeeSettings(venue="polymarket", category="sports")
+    print(
+        f"Polymarket sports, {when.date()}: ${dollars(calculate_fee(s, contracts=100, price=0.5, role='taker', at=when))}"
+    )

uselayer-0.1.0/examples/06_pair_trade_backtest.py

@@ -0,0 +1,47 @@
+"""Trade both sides of a pair with the leg-risk guard, in backtest mode.
+
+The books below are made up for the example; they aren't real prices. Two markets that are the same
+bet: buying YES on one and NO on the other pays $1 per contract either way.
+
+    python examples/06_pair_trade_backtest.py
+"""
+
+from datetime import UTC, datetime, timedelta
+
+from uselayer import Book, Client, Level
+
+t0 = datetime(2026, 10, 1, 12, 0, tzinfo=UTC)
+
+
+def book(market: str, seconds: int, bid: float, ask: float, size: float = 50) -> Book:
+    return Book(
+        venue="polymarket_us",
+        market=market,
+        bids=(Level(price=bid, size=size),),
+        asks=(Level(price=ask, size=size),),
+        as_of=t0 + timedelta(seconds=seconds),
+    )
+
+
+pair = [("polymarket_us", "example-a"), ("polymarket_us", "example-b")]
+books = [
+    book("example-a", 0, 0.40, 0.42),  # YES on A costs 0.42
+    book("example-b", 1, 0.60, 0.62),  # NO on B costs 1 − 0.60 = 0.40
+    book("example-a", 60, 0.47, 0.49),
+    book("example-b", 61, 0.52, 0.54),
+]
+
+
+def strategy(client: Client, pair: list[tuple[str, str]], quote) -> None:  # type: ignore[no-untyped-def]
+    print(
+        f"quote: {quote.contracts} contracts clear the edge, {quote.net_profit_per_contract} a contract after fees"
+    )
+    if quote.net_profit_per_contract >= 0.02 and not client.positions():
+        t = client.trade(pair, size=20, min_edge=0.01)
+        print(f"trade: {t.status}, {t.hedged} hedged, ${t.locked_in} locked in after fees")
+
+
+bt = Client(mode="backtest", books=books, rules={"max_position": {"per_market": 50}})
+bt.run(strategy, [pair])
+for p in bt.positions():
+    print(f"position: {p.contracts} {p.side} of {p.market} at {p.avg_price}")

uselayer-0.1.0/examples/_pick.py

@@ -0,0 +1,14 @@
+"""Shared by the examples: pick an open Polymarket US market with prices on both sides."""
+
+from __future__ import annotations
+
+from uselayer import Book, Client
+
+
+def pick_market(client: Client) -> tuple[str, Book]:
+    for m in client.markets(limit=50):
+        book = client.book(m.slug)
+        yes = book.outcome("yes")
+        if yes.best_bid and yes.best_ask and 0.1 < yes.best_ask.price < 0.9 and yes.best_ask.size >= 5:
+            return m.slug, book
+    raise SystemExit("No open market with prices on both sides right now; try again later.")