outcometick 1.4.0__tar.gz

outcometick-1.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ligengxin
+
+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.

outcometick-1.4.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: outcometick
+Version: 1.4.0
+Summary: Strategy SDK for outcometick prediction-market backtests
+License: MIT
+Project-URL: Documentation, https://outcometick.com/docs/sdk
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<!--
+  GENERATED — do not edit this repository directly.
+
+  Every file here is built from the outcometick monorepo by
+  scripts/publish-sdk-repos.mjs and overwritten wholesale on each publish.
+  An edit made here survives until the next publish and then disappears.
+
+  Generated from monorepo revision 27a03218dafadd78d846fb906e64e2981aa6f51c.
+-->
+
+# outcometick
+
+The Python strategy SDK for [outcometick.com](https://outcometick.com).
+
+```python
+from outcometick import Strategy, Order
+
+
+class MeanReversion(Strategy):
+    def on_market_open(self, ctx, market):
+        self.entered = False
+
+    def on_tick(self, ctx, tick):
+        z = ctx.zscore(tick.value, window=180)
+        if self.entered or abs(z) < ctx.p.entry_z:
+            return None
+        side = "DOWN" if z > 0 else "UP"
+        book = ctx.book()
+        self.entered = True
+        return Order(side=side, size=ctx.p.size, limit=book.best(side))
+```
+
+This package is the SDK surface: the `Strategy` base class and the `Order`
+value object, so your editor and type checker know the API and your own tests
+can import it.
+
+**The `ot` command line is distributed via npm**, not here:
+
+```
+npm i -g outcometick
+```
+
+It runs Python strategies by spawning your local `python3`. Shipping one CLI
+rather than two is deliberate — `ot check` must be the same validator the queue
+runs, and a second implementation in another language would be the first thing
+to drift.
+
+Full reference: https://outcometick.com/docs/sdk

outcometick-1.4.0/README.md

@@ -0,0 +1,48 @@
+<!--
+  GENERATED — do not edit this repository directly.
+
+  Every file here is built from the outcometick monorepo by
+  scripts/publish-sdk-repos.mjs and overwritten wholesale on each publish.
+  An edit made here survives until the next publish and then disappears.
+
+  Generated from monorepo revision 27a03218dafadd78d846fb906e64e2981aa6f51c.
+-->
+
+# outcometick
+
+The Python strategy SDK for [outcometick.com](https://outcometick.com).
+
+```python
+from outcometick import Strategy, Order
+
+
+class MeanReversion(Strategy):
+    def on_market_open(self, ctx, market):
+        self.entered = False
+
+    def on_tick(self, ctx, tick):
+        z = ctx.zscore(tick.value, window=180)
+        if self.entered or abs(z) < ctx.p.entry_z:
+            return None
+        side = "DOWN" if z > 0 else "UP"
+        book = ctx.book()
+        self.entered = True
+        return Order(side=side, size=ctx.p.size, limit=book.best(side))
+```
+
+This package is the SDK surface: the `Strategy` base class and the `Order`
+value object, so your editor and type checker know the API and your own tests
+can import it.
+
+**The `ot` command line is distributed via npm**, not here:
+
+```
+npm i -g outcometick
+```
+
+It runs Python strategies by spawning your local `python3`. Shipping one CLI
+rather than two is deliberate — `ot check` must be the same validator the queue
+runs, and a second implementation in another language would be the first thing
+to drift.
+
+Full reference: https://outcometick.com/docs/sdk

outcometick-1.4.0/outcometick/__init__.py

@@ -0,0 +1,67 @@
+"""The SDK surface a submitted Python strategy imports.
+
+Deliberately tiny. `Strategy` is a base class that exists so `entry` can be
+checked against something, and `Order` is a value object. Everything a strategy
+can actually DO arrives through `ctx`, which the runner constructs — there is no
+way to reach the outside from here, because there is nothing here to reach it
+with.
+"""
+
+from __future__ import annotations
+
+# Named explicitly so `from __future__ import annotations` does not leak
+# `annotations` into the package's public surface — this module is also
+# published to PyPI, where dir(outcometick) is what a user reads as the API.
+__all__ = ("Strategy", "Order", "SIDES")
+
+SIDES = ("UP", "DOWN")
+
+
+class Strategy:
+    """Base class for a submitted strategy.
+
+    The hooks are not defined here on purpose. A default no-op `on_tick` would
+    turn "you declared a hook you did not implement" — a rejection the submitter
+    can fix in seconds — into a run that quietly never trades and bills for an
+    empty equity curve.
+    """
+
+    #: Params from the manifest, injected by the runner before the first hook.
+    p: dict = {}
+
+
+class Order:
+    """An order a hook returns. Never sent — returned, and matched by the runner
+    against the depth that was actually resting at that millisecond.
+
+    `limit` is a bound in whichever direction protects you: a ceiling when
+    opening, a floor when reducing.
+    """
+
+    __slots__ = ("side", "size", "limit", "hold_s", "reduce_only", "tif", "tag")
+
+    def __init__(self, side, size, limit=None, hold_s=None, reduce_only=False,
+                 tif="ioc", tag=None):
+        if side not in SIDES:
+            raise ValueError(f'side must be "UP" or "DOWN", got {side!r}')
+        if not (isinstance(size, (int, float)) and size > 0):
+            raise ValueError(f"size must be a positive number, got {size!r}")
+        if limit is not None and not (0 <= float(limit) <= 1):
+            # A binary outcome token trades between 0 and 1. A limit outside
+            # that is not a price, and silently clamping it would fill an order
+            # the strategy never asked for.
+            raise ValueError(f"limit must be between 0 and 1, got {limit!r}")
+        if tif != "ioc":
+            # Not modelled, so not accepted. See "Not supported yet" in the docs.
+            raise ValueError(f'tif must be "ioc"; {tif!r} is not supported yet')
+        self.side = side
+        self.size = float(size)
+        self.limit = None if limit is None else float(limit)
+        self.hold_s = None if hold_s is None else int(hold_s)
+        self.reduce_only = bool(reduce_only)
+        self.tif = tif
+        self.tag = tag
+
+    def __repr__(self) -> str:
+        return (f"Order(side={self.side!r}, size={self.size}, limit={self.limit}, "
+                f"reduce_only={self.reduce_only})")

outcometick-1.4.0/outcometick.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: outcometick
+Version: 1.4.0
+Summary: Strategy SDK for outcometick prediction-market backtests
+License: MIT
+Project-URL: Documentation, https://outcometick.com/docs/sdk
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<!--
+  GENERATED — do not edit this repository directly.
+
+  Every file here is built from the outcometick monorepo by
+  scripts/publish-sdk-repos.mjs and overwritten wholesale on each publish.
+  An edit made here survives until the next publish and then disappears.
+
+  Generated from monorepo revision 27a03218dafadd78d846fb906e64e2981aa6f51c.
+-->
+
+# outcometick
+
+The Python strategy SDK for [outcometick.com](https://outcometick.com).
+
+```python
+from outcometick import Strategy, Order
+
+
+class MeanReversion(Strategy):
+    def on_market_open(self, ctx, market):
+        self.entered = False
+
+    def on_tick(self, ctx, tick):
+        z = ctx.zscore(tick.value, window=180)
+        if self.entered or abs(z) < ctx.p.entry_z:
+            return None
+        side = "DOWN" if z > 0 else "UP"
+        book = ctx.book()
+        self.entered = True
+        return Order(side=side, size=ctx.p.size, limit=book.best(side))
+```
+
+This package is the SDK surface: the `Strategy` base class and the `Order`
+value object, so your editor and type checker know the API and your own tests
+can import it.
+
+**The `ot` command line is distributed via npm**, not here:
+
+```
+npm i -g outcometick
+```
+
+It runs Python strategies by spawning your local `python3`. Shipping one CLI
+rather than two is deliberate — `ot check` must be the same validator the queue
+runs, and a second implementation in another language would be the first thing
+to drift.
+
+Full reference: https://outcometick.com/docs/sdk

outcometick-1.4.0/outcometick.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+outcometick/__init__.py
+outcometick/py.typed
+outcometick.egg-info/PKG-INFO
+outcometick.egg-info/SOURCES.txt
+outcometick.egg-info/dependency_links.txt
+outcometick.egg-info/top_level.txt
+tests/test_sdk.py

outcometick-1.4.0/outcometick.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

outcometick-1.4.0/outcometick.egg-info/top_level.txt

@@ -0,0 +1 @@
+outcometick

outcometick-1.4.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "outcometick"
+version = "1.4.0"
+description = "Strategy SDK for outcometick prediction-market backtests"
+readme = "README.md"
+requires-python = ">=3.14"
+license = { text = "MIT" }
+
+[project.urls]
+Documentation = "https://outcometick.com/docs/sdk"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["outcometick"]
+
+[tool.setuptools.package-data]
+outcometick = ["py.typed"]

outcometick-1.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

outcometick-1.4.0/tests/test_sdk.py

@@ -0,0 +1,71 @@
+"""Tests for the public Python SDK surface.
+
+Small on purpose: this package is the SDK surface and nothing else, so these
+assert the contract a strategy author actually depends on — the names that
+exist, and the argument validation that rejects a bad order at construction
+rather than silently at fill time.
+
+They ship with the published package so the mirror is a repository someone can
+clone and verify rather than take on faith.
+"""
+
+import unittest
+
+from outcometick import Order, Strategy, SIDES
+
+
+class TestSurface(unittest.TestCase):
+    def test_exports_are_exactly_what_is_documented(self):
+        import outcometick
+
+        self.assertEqual(sorted(outcometick.__all__), ["Order", "SIDES", "Strategy"])
+        # __all__ also keeps `annotations` from `from __future__ import` out of
+        # the public namespace, which is what a reader sees in dir().
+        self.assertNotIn("annotations", outcometick.__all__)
+
+    def test_sides_are_the_two_outcome_tokens(self):
+        self.assertEqual(tuple(SIDES), ("UP", "DOWN"))
+
+
+class TestOrder(unittest.TestCase):
+    def test_accepts_a_well_formed_order(self):
+        o = Order(side="UP", size=100, limit=0.55)
+        self.assertEqual(o.side, "UP")
+        self.assertEqual(o.size, 100.0)
+        self.assertEqual(o.limit, 0.55)
+        self.assertFalse(o.reduce_only)
+
+    def test_limit_is_optional(self):
+        self.assertIsNone(Order(side="DOWN", size=1).limit)
+
+    def test_rejects_a_side_that_is_not_an_outcome_token(self):
+        with self.assertRaises(ValueError):
+            Order(side="SIDEWAYS", size=100)
+
+    def test_rejects_a_non_positive_size(self):
+        for bad in (0, -1):
+            with self.assertRaises(ValueError):
+                Order(side="UP", size=bad)
+
+    def test_rejects_a_limit_outside_zero_to_one(self):
+        # A binary outcome token trades between 0 and 1. Anything else is not a
+        # price, and clamping it would fill an order nobody asked for.
+        for bad in (-0.01, 1.5, 100):
+            with self.assertRaises(ValueError):
+                Order(side="UP", size=1, limit=bad)
+
+
+class TestStrategy(unittest.TestCase):
+    def test_params_default_to_empty_so_a_hook_can_read_them(self):
+        self.assertEqual(Strategy().p, {})
+
+    def test_hooks_are_not_defined_by_the_base_class(self):
+        # Deliberate: a default no-op on_tick would turn "you declared a hook you
+        # did not implement" — fixable in seconds — into a run that quietly never
+        # trades and bills for an empty equity curve.
+        for hook in ("on_tick", "on_market_open", "on_book", "on_trade", "on_settle"):
+            self.assertFalse(hasattr(Strategy, hook), hook)
+
+
+if __name__ == "__main__":
+    unittest.main()