pocket-option 0.1.0__tar.gz

pocket_option-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yury "lordralinc" Yushmanov
+
+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.

pocket_option-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: pocket-option
+Version: 0.1.0
+Summary: Async API client for Pocket Option platform
+License-Expression: MIT
+License-File: LICENSE
+Author: Yury "lordralinc" Yushmanov
+Requires-Python: >=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: ujson
+Requires-Dist: aiohttp[speedups] (>=3.13.1,<4.0.0)
+Requires-Dist: pydantic (>=2.12.3,<3.0.0)
+Requires-Dist: python-socketio[asyncio-client] (>=5.14.2,<6.0.0)
+Requires-Dist: pytz (>=2025.2,<2026.0)
+Requires-Dist: ujson (>=5.11.0,<6.0.0) ; extra == "ujson"
+Project-URL: Homepage, https://github.com/lordralinc/pocket_option
+Project-URL: Issues, https://github.com/lordralinc/pocket_option/issues
+Project-URL: Repository, https://github.com/lordralinc/pocket_option
+Description-Content-Type: text/markdown
+
+# ⚡ PocketOption API SDK (Unofficial)
+
+Асинхронный **Python-SDK для взаимодействия с PocketOption API** (неофициальный).
+
+Полностью типизирован, построен на `pydantic`, с поддержкой middleware, событий.
+
+>⚠️ Проект не связан с PocketOption. Предназначен для интеграций, анализа и автоматизации.
+
+> Поддерживает Python 3.13+ и полностью асинхронен (`asyncio` + `aiohttp`).
+
+> ## Предупреждение о рисках:
+> Инвестирование в финансовые продукты сопряжено с рисками. Прошлые результаты не гарантируют будущую доходность, а стоимость активов может изменяться в зависимости от рыночных условий и колебаний базовых инструментов. Любые прогнозы или иллюстрации приведены исключительно для справки и не являются гарантией результата. Этот проект не является приглашением или рекомендацией к инвестированию. Перед инвестированием проконсультируйтесь с финансовыми, юридическими и налоговыми специалистами и решите, подходит ли данный продукт вашим целям, допустимому уровню риска и текущей ситуации.
+
+> P.S. У них демо прикольное, чисто позалипать кайф
+
+## 🚀 Возможности
+
+- 🔌 Подключение к WebSocket-API PocketOption (через `socket io`)
+
+- 🔐 Авторизация по активной сессии
+
+- 💹 Управление ордерами и сделками (демо / реальный счёт)
+
+- 📊 Подписка на рыночные потоки
+
+- 💾 Встроенные in-memory-хранилища (`MemoryCandleStorage`, `MemoryDealsStorage`)
+
+- ⚙️ Middleware-цепочка для перехвата событий и запросов
+
+- 💬 Событийная модель с декораторами (`@client.on.*`)
+
+- ✅ Строгая типизация
+
+
+## ⚙️ Пример использования
+
+```python
+import asyncio
+import os
+from pocket_option import PocketOptionClient
+from pocket_option.models import Asset, OrderAction
+from pocket_option.constants import Regions
+
+
+
+async def on_update_stream(assets: list[UpdateStreamItem]):
+    print("Assets updated: ", assets)
+
+async def main():
+    client = PocketOptionClient()
+    client.on.update_stream(on_update_stream)
+
+    deals = MemoryDealsStorage(client)
+
+    await client.connect(Regions.DEMO)
+    await client.emit.auth(AuthorizationData.model_validate({
+        "session": os.environ["PO_SESSION"],
+        "isDemo": 1,
+        "uid": int(os.environ["PO_UID"]),
+        "platform": 2,
+        "isFastHistory": True,
+        "isOptimized": True,
+    }))
+
+    deal = await deals.open_deal(
+        asset=Asset.AUDCAD_otc,
+        amount=10,
+        action=OrderAction.CALL,
+        is_demo=1,
+        option_type=100,
+        time=60,
+    )
+    print("✅ Opened deal:", deal)
+    result = await deals.check_deal_result(wait_time=60, deal=deal)
+    print("✅ Deal result:", result)
+
+asyncio.run(main())
+
+```
+
+
+## 📜 Лицензия
+
+**MIT License** — делай что хочешь, но на свой страх и риск.

pocket_option-0.1.0/README.md

@@ -0,0 +1,84 @@
+# ⚡ PocketOption API SDK (Unofficial)
+
+Асинхронный **Python-SDK для взаимодействия с PocketOption API** (неофициальный).
+
+Полностью типизирован, построен на `pydantic`, с поддержкой middleware, событий.
+
+>⚠️ Проект не связан с PocketOption. Предназначен для интеграций, анализа и автоматизации.
+
+> Поддерживает Python 3.13+ и полностью асинхронен (`asyncio` + `aiohttp`).
+
+> ## Предупреждение о рисках:
+> Инвестирование в финансовые продукты сопряжено с рисками. Прошлые результаты не гарантируют будущую доходность, а стоимость активов может изменяться в зависимости от рыночных условий и колебаний базовых инструментов. Любые прогнозы или иллюстрации приведены исключительно для справки и не являются гарантией результата. Этот проект не является приглашением или рекомендацией к инвестированию. Перед инвестированием проконсультируйтесь с финансовыми, юридическими и налоговыми специалистами и решите, подходит ли данный продукт вашим целям, допустимому уровню риска и текущей ситуации.
+
+> P.S. У них демо прикольное, чисто позалипать кайф
+
+## 🚀 Возможности
+
+- 🔌 Подключение к WebSocket-API PocketOption (через `socket io`)
+
+- 🔐 Авторизация по активной сессии
+
+- 💹 Управление ордерами и сделками (демо / реальный счёт)
+
+- 📊 Подписка на рыночные потоки
+
+- 💾 Встроенные in-memory-хранилища (`MemoryCandleStorage`, `MemoryDealsStorage`)
+
+- ⚙️ Middleware-цепочка для перехвата событий и запросов
+
+- 💬 Событийная модель с декораторами (`@client.on.*`)
+
+- ✅ Строгая типизация
+
+
+## ⚙️ Пример использования
+
+```python
+import asyncio
+import os
+from pocket_option import PocketOptionClient
+from pocket_option.models import Asset, OrderAction
+from pocket_option.constants import Regions
+
+
+
+async def on_update_stream(assets: list[UpdateStreamItem]):
+    print("Assets updated: ", assets)
+
+async def main():
+    client = PocketOptionClient()
+    client.on.update_stream(on_update_stream)
+
+    deals = MemoryDealsStorage(client)
+
+    await client.connect(Regions.DEMO)
+    await client.emit.auth(AuthorizationData.model_validate({
+        "session": os.environ["PO_SESSION"],
+        "isDemo": 1,
+        "uid": int(os.environ["PO_UID"]),
+        "platform": 2,
+        "isFastHistory": True,
+        "isOptimized": True,
+    }))
+
+    deal = await deals.open_deal(
+        asset=Asset.AUDCAD_otc,
+        amount=10,
+        action=OrderAction.CALL,
+        is_demo=1,
+        option_type=100,
+        time=60,
+    )
+    print("✅ Opened deal:", deal)
+    result = await deals.check_deal_result(wait_time=60, deal=deal)
+    print("✅ Deal result:", result)
+
+asyncio.run(main())
+
+```
+
+
+## 📜 Лицензия
+
+**MIT License** — делай что хочешь, но на свой страх и риск.

pocket_option-0.1.0/pocket_option/__init__.py

@@ -0,0 +1,3 @@
+from .generated_client import PocketOptionClient
+
+__all__ = ("PocketOptionClient",)

pocket_option-0.1.0/pocket_option/client.py

@@ -0,0 +1,271 @@
+import asyncio
+import collections.abc
+import logging
+import typing
+from inspect import isclass
+
+import aiohttp
+import pydantic
+import socketio
+
+from pocket_option.constants import DEFAULT_ORIGIN, DEFAULT_USER_AGENT
+from pocket_option.middleware import Middleware
+from pocket_option.middlewares import FixTypesOnMiddleware, MakeJsonOnMiddleware
+from pocket_option.utils import get_json_function
+
+if typing.TYPE_CHECKING:
+    from pocket_option import models
+    from pocket_option.types import EmitCallback, JsonFunction, JsonValue, SIOEventListener
+
+__all__ = ("BasePocketOptionClient",)
+
+logger = logging.getLogger()
+
+
+class BasePocketOptionClient:
+    def __init__(
+        self,
+        on_middlewares: "list[Middleware] | None" = None,
+        *,
+        reconnection: bool = True,
+        reconnection_attempts: int = 0,
+        reconnection_delay: float = 1.0,
+        reconnection_delay_max: float = 5.0,
+        randomization_factor: float = 0.5,
+        logger: bool = False,
+        engineio_logger: bool = False,
+        json: "JsonFunction | None" = None,
+        handle_sigint: bool = True,
+        request_timeout: float = 5,
+        http_session: aiohttp.ClientSession | None = None,
+        ssl_verify: bool = True,
+        websocket_extra_options: dict | None = None,
+        timestamp_requests: bool = False,
+    ) -> None:
+        """Initializes the Socket.IO client wrapper with middleware and connection options.
+
+        :param on_middlewares:
+            A list of middlewares executed on incoming Socket.IO events.
+            Each middleware can modify or intercept event data before the callback is called.
+            By default, the following middlewares are applied:
+            - `MakeJsonOnMiddleware()` — parses JSON data into Python objects.
+            - `FixTypesOnMiddleware()` — normalizes data types for consistency.
+
+        :param emit_middlewares:
+            A list of middlewares executed before emitting events to the server.
+            Each middleware can modify the outgoing payload.
+            Defaults to an empty list.
+
+        :param reconnection:
+            Enables or disables automatic reconnection when the connection is lost.
+            Defaults to `True`.
+
+        :param reconnection_attempts:
+            The maximum number of reconnection attempts.
+            A value of `0` means unlimited retries.
+
+        :param reconnection_delay:
+            Initial delay (in seconds) before attempting to reconnect.
+            Defaults to `1.0`.
+
+        :param reconnection_delay_max:
+            Maximum delay (in seconds) between reconnection attempts.
+            Defaults to `5.0`.
+
+        :param randomization_factor:
+            A factor between 0 and 1 used to randomize the reconnection delay to prevent
+            simultaneous reconnects.
+            Defaults to `0.5`.
+
+        :param logger:
+            Enables logging for the Socket.IO client.
+            Defaults to `False`.
+
+        :param engineio_logger:
+            Enables logging for the underlying Engine.IO layer.
+            Defaults to `False`.
+
+        :param json:
+            Custom JSON serialization/deserialization functions.
+            If not provided, a default implementation will be used.
+
+        :param handle_sigint:
+            If `True`, the client will handle SIGINT (Ctrl+C) for clean shutdown.
+            Defaults to `True`.
+
+        :param request_timeout:
+            The timeout (in seconds) for HTTP requests during the Socket.IO handshake.
+            Defaults to `5`.
+
+        :param http_session:
+            Optional existing `aiohttp.ClientSession` instance to reuse for HTTP requests.
+            If `None`, a new session is created internally.
+
+        :param ssl_verify:
+            Whether to verify SSL certificates for secure connections.
+            Defaults to `True`.
+
+        :param websocket_extra_options:
+            Optional dictionary of additional parameters for the WebSocket connection.
+            Useful for setting headers or specific connection parameters.
+
+        :param timestamp_requests:
+            Whether to append a timestamp to each request for caching avoidance.
+            Defaults to `False`.
+        """
+        self.middlewares = on_middlewares or [MakeJsonOnMiddleware(), FixTypesOnMiddleware()]
+        self.json = json or get_json_function()
+        self.sio = socketio.AsyncClient(
+            reconnection=reconnection,
+            reconnection_attempts=reconnection_attempts,
+            reconnection_delay=reconnection_delay,  # pyright: ignore[reportArgumentType]
+            reconnection_delay_max=reconnection_delay_max,  # pyright: ignore[reportArgumentType]
+            randomization_factor=randomization_factor,
+            logger=logger,
+            serializer="default",
+            json=self.json,
+            handle_sigint=handle_sigint,
+            request_timeout=request_timeout,
+            http_session=http_session,
+            ssl_verify=ssl_verify,
+            websocket_extra_options=websocket_extra_options,
+            timestamp_requests=timestamp_requests,
+            engineio_logger=engineio_logger,
+        )
+
+    def get_auth_from_packet(self, packet: str) -> "models.AuthorizationData":
+        packet = packet.removeprefix("42")
+        json_packet = self.json.loads(packet)
+        return typing.cast("models.AuthorizationData", json_packet)
+
+    def add_middleware(self, middleware: Middleware) -> None:
+        self.middlewares.append(middleware)
+
+    async def _get_real_value[T](
+        self,
+        value: T
+        | None
+        | collections.abc.Callable[[], T]
+        | collections.abc.Callable[[], collections.abc.Coroutine[None, None, T]],
+    ) -> T | None:
+        if callable(value):
+            result = value()
+            if asyncio.iscoroutine(result):
+                return await result
+            return result  # type: ignore
+        return value
+
+    async def wait(self):
+        return await self.sio.wait()
+
+    async def disconnect(self) -> None:
+        return await self.sio.disconnect()
+
+    async def shutdown(self) -> None:
+        return await self.sio.shutdown()
+
+    async def sleep(self, seconds: float = 0) -> None:
+        return await self.sio.sleep(seconds=seconds)  # type: ignore
+
+    async def connect(
+        self,
+        url: str,
+        headers: dict[str, str] | collections.abc.Callable[[], dict[str, str]] | None = None,
+        auth: "models.AuthorizationData | None" = None,
+        wait: bool = True,
+        wait_timeout: float = 1,
+        retry: bool = False,
+    ):
+        headers = await self._get_real_value(headers) or {}
+        headers.setdefault("Origin", DEFAULT_ORIGIN)
+        headers.setdefault("User-Agent", DEFAULT_USER_AGENT)
+        return await self.sio.connect(
+            url,
+            headers=headers,
+            auth=auth,
+            transports=["websocket"],
+            namespaces=["/"],
+            socketio_path="socket.io",
+            wait=wait,
+            wait_timeout=wait_timeout,  # type: ignore
+            retry=retry,
+        )
+
+    @typing.overload
+    def add_on(
+        self,
+        event: str,
+        handler: None = ...,
+        *,
+        model: type[pydantic.BaseModel] | pydantic.TypeAdapter | None = ...,
+    ) -> "typing.Callable[[SIOEventListener], None]": ...
+    @typing.overload
+    def add_on(
+        self,
+        event: str,
+        handler: "SIOEventListener",
+        *,
+        model: type[pydantic.BaseModel] | pydantic.TypeAdapter | None = ...,
+    ) -> None: ...
+
+    def add_on(
+        self,
+        event: str,
+        handler: "SIOEventListener | None" = None,
+        *,
+        model: type[pydantic.BaseModel] | pydantic.TypeAdapter | None = None,
+    ) -> "None | typing.Callable[[SIOEventListener], None]":
+        def _get_data(d: "JsonValue | None"):
+            if d and isinstance(d, dict) and model and isclass(model) and issubclass(model, pydantic.BaseModel):
+                return model.model_validate(d)
+            if d and isinstance(model, pydantic.TypeAdapter):
+                return model.validate_python(d)
+            return d
+
+        if handler is None:
+
+            def set_handler(_handler: "SIOEventListener"):
+                async def wrapper(data: "JsonValue | None"):
+                    for middleware in self.middlewares:
+                        data = await middleware.on(event, data)
+                    new_data = _get_data(data)
+                    logger.debug("New event '%s' with data %r", event, new_data)
+                    result = _handler(new_data)
+                    if asyncio.iscoroutine(result):
+                        await result
+
+                self.sio.on(event, handler=wrapper)
+
+            return set_handler
+
+        async def _handler(data: "JsonValue | None"):
+            for middleware in self.middlewares:
+                data = await middleware.on(event, data)
+            new_data = _get_data(data)
+            logger.debug("New event '%s' with data %r", event, new_data)
+            result = handler(new_data)
+            if asyncio.iscoroutine(result):
+                await result
+
+        return self.sio.on(event, handler=_handler)
+
+    async def send(
+        self,
+        event: str,
+        data: "JsonValue | pydantic.BaseModel | None" = None,
+        callback: "EmitCallback[JsonValue] | None" = None,
+    ) -> None:
+        if isinstance(data, pydantic.BaseModel):
+            data = data.model_dump(mode="json", by_alias=True)
+        if isinstance(data, list):
+            data = [
+                it.model_dump(mode="json", by_alias=True) if isinstance(it, pydantic.BaseModel) else it for it in data
+            ]
+        for middleware in self.middlewares:
+            event, data, callback = await middleware.emit(event, data=data, callback=callback)
+        logger.debug(
+            "Emitting event '%s' with data %r",
+            event,
+            data if event != "auth" else {**typing.cast("dict[str, JsonValue]", data), "session": "***"},
+        )
+        return await self.sio.emit(event=event, data=data, callback=callback)

pocket_option-0.1.0/pocket_option/constants.py

@@ -0,0 +1,52 @@
+__all__ = (
+    "API_LIMITS_MAX_CONCURRENT_ORDERS",
+    "API_LIMITS_MAX_DURATION",
+    "API_LIMITS_MAX_ORDER_AMOUNT",
+    "API_LIMITS_MIN_DURATION",
+    "API_LIMITS_MIN_ORDER_AMOUNT",
+    "API_LIMITS_RATE_LIMIT",
+    "DEFAULT_ORIGIN",
+    "DEFAULT_USER_AGENT",
+    "MAX_INT_32",
+    "TIMESTAMP_OFFSET",
+    "Regions",
+)
+
+
+API_LIMITS_MIN_ORDER_AMOUNT = 1
+API_LIMITS_MAX_ORDER_AMOUNT = 50_000
+API_LIMITS_MIN_DURATION = 5
+API_LIMITS_MAX_DURATION = 43_200
+API_LIMITS_MAX_CONCURRENT_ORDERS = 10
+API_LIMITS_RATE_LIMIT = 100
+MAX_INT_32 = 2_147_483_647
+TIMESTAMP_OFFSET = -7200
+DEFAULT_ORIGIN = "https://m.pocketoption.com"
+DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:143.0) Gecko/20100101 Firefox/143.0"
+
+
+class Regions:
+    UNITED_STATES_NORTH = "wss://api-us-north.po.market"
+    UNITED_STATES_SOUTH = "wss://api-us-south.po.market"
+    EUROPA = "wss://api-eu.po.market"
+    ASIA = "wss://api-asia.po.market"
+
+    UNITED_STATES_2 = "wss://api-us2.po.market"
+    UNITED_STATES_3 = "wss://api-us3.po.market"
+    UNITED_STATES_4 = "wss://api-us4.po.market"
+
+    FRANCE_1 = "wss://api-fr.po.market"
+    FRANCE_2 = "wss://api-fr2.po.market"
+    RUSSIA = "wss://api-msk.po.market"
+    INDIA = "wss://api-in.po.market"
+    FINLAND = "wss://api-fin.po.market"
+
+    SEYCHELLES = "wss://api-sc.po.market"
+    HONGKONG = "wss://api-hk.po.market"
+
+    SERVER_1 = "wss://api-spb.po.market"
+    SERVER_2 = "wss://api-l.po.market"
+    SERVER_3 = "wss://api-c.po.market"
+
+    DEMO = "wss://demo-api-eu.po.market"
+    DEMO_2 = "wss://try-demo-eu.po.market"

pocket_option-0.1.0/pocket_option/contrib/candles.py

@@ -0,0 +1,133 @@
+import abc
+import collections.abc
+import datetime
+import math
+import typing
+from collections import defaultdict, deque
+
+import pydantic
+import pytz
+
+from pocket_option.generated_client import PocketOptionClient
+from pocket_option.models import Asset, UpdateStreamItem
+from pocket_option.utils import append_or_replace
+
+if typing.TYPE_CHECKING:
+    from pocket_option.generated_client import PocketOptionClient
+
+
+class Candle(pydantic.BaseModel):
+    asset: Asset
+    timestamp: datetime.datetime
+    timeframe: int
+    open: float
+    low: float
+    high: float
+    close: float
+
+
+class CandleStorage(abc.ABC):
+    def __init__(self, client: "PocketOptionClient") -> None:
+        self.client = client
+
+        self.client.on.update_stream(self._on_update_stream)
+
+    async def _on_update_stream(self, items: list[UpdateStreamItem]) -> None:
+        await self.add_item_bulk(items)
+
+    async def add_candle(self, candle: Candle) -> None:
+        await self.add_item_bulk(
+            [
+                UpdateStreamItem(asset=candle.asset, timestamp=candle.timestamp.timestamp(), value=candle.open),
+                UpdateStreamItem(asset=candle.asset, timestamp=candle.timestamp.timestamp() + 0.01, value=candle.low),
+                UpdateStreamItem(asset=candle.asset, timestamp=candle.timestamp.timestamp() + 0.02, value=candle.high),
+                UpdateStreamItem(
+                    asset=candle.asset,
+                    timestamp=candle.timestamp.timestamp() + (candle.timeframe - 0.01),
+                    value=candle.close,
+                ),
+            ],
+        )
+
+    @abc.abstractmethod
+    async def add_item(self, item: UpdateStreamItem): ...
+    @abc.abstractmethod
+    async def add_item_bulk(self, items: list[UpdateStreamItem]): ...
+    @abc.abstractmethod
+    async def get_items(
+        self,
+        asset: Asset,
+        *,
+        start: datetime.datetime | None = None,
+        end: datetime.datetime | None = None,
+        count: int | None = None,
+    ) -> collections.abc.Iterable[UpdateStreamItem]: ...
+
+    async def get_candles(
+        self,
+        asset: Asset,
+        timeframe: int = 5,
+        *,
+        start: datetime.datetime | None = None,
+        end: datetime.datetime | None = None,
+        count: int | None = None,
+    ) -> collections.abc.Iterable[Candle]:
+        items = await self.get_items(asset, start=start, end=end, count=count)
+
+        buckets: dict[int, list[UpdateStreamItem]] = defaultdict(list)
+        for item in items:
+            ts_bucket = math.floor(item.timestamp / timeframe) * timeframe
+            buckets[ts_bucket].append(item)
+        candles = []
+
+        for ts_bucket in sorted(buckets):
+            group = buckets[ts_bucket]
+            values = [i.value for i in group]
+            candle = Candle(
+                asset=asset,
+                timestamp=datetime.datetime.fromtimestamp(ts_bucket, tz=pytz.UTC),
+                timeframe=timeframe,
+                open=values[0],
+                close=values[-1],
+                high=max(values),
+                low=min(values),
+            )
+            candles.append(candle)
+
+        return candles
+
+
+class MemoryCandleStorage(CandleStorage):
+    def __init__(self, client: "PocketOptionClient") -> None:
+        super().__init__(client)
+        self._max_len = 10_000
+        self._storage: dict[Asset, deque[UpdateStreamItem]] = defaultdict(lambda: deque([], 10_000))
+
+    def set_max_len(self, _max_len: int):
+        self._storage = defaultdict(lambda: deque([], _max_len))
+
+    async def add_item(self, item: UpdateStreamItem):
+        self._storage[item.asset] = append_or_replace(self._storage[item.asset], item, ["asset", "timestamp"])
+
+    async def add_item_bulk(self, items: list[UpdateStreamItem]):
+        for it in items:
+            await self.add_item(it)
+
+    async def get_items(
+        self,
+        asset: Asset,
+        *,
+        start: datetime.datetime | None = None,
+        end: datetime.datetime | None = None,
+        count: int | None = None,
+    ) -> collections.abc.Iterable[UpdateStreamItem]:
+        items = self._storage.get(asset, [])
+        if start:
+            items = [i for i in items if i.timestamp >= start.timestamp()]
+        if end:
+            items = [i for i in items if i.timestamp <= end.timestamp()]
+        items = list(items)
+        items.sort(key=lambda i: i.timestamp)
+        if count is not None:
+            items = items[-count:]
+        return items