bn-quik 0.1.0__tar.gz → 0.2.1__tar.gz

{bn_quik-0.1.0 → bn_quik-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bn_quik
-Version: 0.1.0
+Version: 0.2.1
 Summary: Backtrader-next connector for QUIK terminal
 Project-URL: Homepage, https://github.com/Alex-Shur/bn_quik
 Project-URL: Source, https://github.com/Alex-Shur/bn_quik
@@ -12,9 +12,18 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 or later (G
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
-Requires-Dist: backtrader-next>=2.1.0
+Requires-Dist: backtrader-next>=2.3.2
 Requires-Dist: quik-python>=1.2.0
 Description-Content-Type: text/markdown
 
-# bn_quik
+<div align="center">
+
+# bn_quik  
+
+[![PyPi Release](https://img.shields.io/pypi/v/bn_quik?color=32a852&label=PyPi)](https://pypi.org/project/bn_quik/)
+[![Total downloads](https://img.shields.io/pepy/dt/bn_quik?label=%E2%88%91&color=skyblue)](https://pypistats.org/packages/bn_quik)
+[![Made with Python](https://img.shields.io/badge/Python-3.11+-c7a002?logo=python&logoColor=white)](https://python.org "Go to Python homepage")
+[![License](https://img.shields.io/github/license/Alex-Shur/bn_quik?color=9c2400)](https://github.com/Alex-Shur/bn_quik/blob/master/LICENSE)
+</div>
+
 Live trading intergartion of backtrader-next with QUIK trade terminal

bn_quik-0.2.1/README.md

@@ -0,0 +1,11 @@
+<div align="center">
+
+# bn_quik  
+
+[![PyPi Release](https://img.shields.io/pypi/v/bn_quik?color=32a852&label=PyPi)](https://pypi.org/project/bn_quik/)
+[![Total downloads](https://img.shields.io/pepy/dt/bn_quik?label=%E2%88%91&color=skyblue)](https://pypistats.org/packages/bn_quik)
+[![Made with Python](https://img.shields.io/badge/Python-3.11+-c7a002?logo=python&logoColor=white)](https://python.org "Go to Python homepage")
+[![License](https://img.shields.io/github/license/Alex-Shur/bn_quik?color=9c2400)](https://github.com/Alex-Shur/bn_quik/blob/master/LICENSE)
+</div>
+
+Live trading intergartion of backtrader-next with QUIK trade terminal

{bn_quik-0.1.0 → bn_quik-0.2.1}/bn_quik/QuikBroker.py

@@ -16,7 +16,8 @@ from quik_python.data_structures import Transaction, Trade, TransactionReply
 from quik_python.data_structures.money_limit_ex import MoneyLimitEx
 from quik_python.data_structures.order import OrderTradeFlags, State
 from quik_python.data_structures.portfolio_info_ex import PortfolioInfoEx
-from quik_python.data_structures.stop_order import StopOrder
+from quik_python.data_structures.stop_order import StopOrder as QuikStopOrder
+from quik_python.data_structures.order import Order as QuikOrder
 from quik_python.data_structures.transaction_types import TransactionAction, TransactionOperation, TransactionType
 
 from .QuikStore import QuikStore, Account
@@ -32,11 +33,6 @@ class MetaQuikBroker(BrokerBase.__class__):
 # noinspection PyProtectedMember,PyArgumentList
 class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
 
-    params = (
-        ('client_code_for_orders', None),  # Номер торгового терминала. У брокера Финам требуется для совершения торговых операций
-        ('trade_account_id', None),
-    )
-
     account:Account = None
 
     def __init__(self, **kwargs):
@@ -68,12 +64,12 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
     async def __get_account(self):
         if not self.account:
             acc_list = await self.store.get_accounts()
-            self.account = next((a for a in acc_list if a.trade_account_id == self.p.trade_account_id), None)
+            self.account = next((a for a in acc_list if a.trade_account_id == self.store.p.trade_account_id), None)
             # Если для заявок брокер устанавливает отдельный код клиента, то задаем его в параметре client_code_for_orders
             # В остальных случаях получаем код клиента из заявки (счета). Для фьючерсов кода клиента нет
             if self.account:
-                self.account.order_client_code = self.p.client_code_for_orders if self.p.client_code_for_orders else self.account.client_code
-                self.account.is_ucp = await self.store._is_ucp_client(self.account.firm_id, self.account.client_code)
+                self.account.order_client_code = self.store.p.client_code_for_orders if self.store.p.client_code_for_orders else self.account.client_code
+                self.account.is_ucp = await self._is_ucp_client(self.account.firm_id, self.account.client_code)
                 self.logger.info(f"Account {self.account.trade_account_id} is UCP: {self.account.is_ucp}")
         return self.account
 
@@ -85,7 +81,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         self.store.broker = self
         self.account = await self.__get_account()
         if not self.account:
-            raise ValueError(f'QuikBroker: Не найден счет с trade_account_id={self.p.trade_account_id}')
+            raise ValueError(f'QuikBroker: Не найден счет с trade_account_id={self.store.p.trade_account_id}')
         await self._get_all_active_positions()
         self.cash = await self._getcash()
         self.value = await self._getvalue(None)
@@ -93,7 +89,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
 
     def start(self):
         super(QuikBroker, self).start()
-        self.store.__class__.run_sync(self.__start_async())
+        QuikStore.run_sync(self.__start_async())
 
     def stop(self):
         super(QuikBroker, self).stop()
@@ -118,7 +114,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
             with self._lock_cash:
                 return self.value + self.cash
         else:
-            return self.store.__class__.run_sync(self._getvalue(datas))
+            return QuikStore.run_sync(self._getvalue(datas))
 
     def getposition(self, data):
         """Позиция по тикеру
@@ -129,19 +125,19 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
 
     def buy(self, owner, data, size, price=None, plimit=None, exectype=None, valid=None, tradeid=0, oco=None, trailamount=None, trailpercent=None, parent=None, transmit=True, **kwargs):
         """Заявка на покупку"""
-        order = self.store.__class__.run_sync(self.create_order(owner, data, size, price, plimit, exectype, valid, oco, parent, transmit, True, **kwargs))
+        order = QuikStore.run_sync(self.create_order(owner, data, size, price, plimit, exectype, valid, oco, parent, transmit, True, **kwargs))
         self.notifs.append(order.clone())  # Уведомляем брокера об отправке новой заявки на покупку на биржу
         return order
 
     def sell(self, owner, data, size, price=None, plimit=None, exectype=None, valid=None, tradeid=0, oco=None, trailamount=None, trailpercent=None, parent=None, transmit=True, **kwargs):
         """Заявка на продажу"""
-        order = self.store.__class__.run_sync(self.create_order(owner, data, size, price, plimit, exectype, valid, oco, parent, transmit, False, **kwargs))
+        order = QuikStore.run_sync(self.create_order(owner, data, size, price, plimit, exectype, valid, oco, parent, transmit, False, **kwargs))
         self.notifs.append(order.clone())  # Уведомляем брокера об отправке новой заявки на продажу на биржу
         return order
 
     def cancel(self, order):
         """Отмена заявки"""
-        return self.store.__class__.run_sync(self.cancel_order(order))
+        return QuikStore.run_sync(self.cancel_order(order))
 
     def get_notification(self):
         with self._lock_notifs:
@@ -174,7 +170,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
             return order
 
         order.addinfo(account=self.account)  # Передаем в заявку счет
-        si = await self.store._get_ticker_info(class_code, sec_code)
+        si = await self.store.get_ticker_info(class_code, sec_code)
         if not si:
             self.logger.error('create_order: Постановка заявки %s по тикеру %s.%s отменена. Тикер не найден', order.ref, class_code, sec_code)
             order.reject(self)
@@ -211,12 +207,12 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         sec_code = order.data.sec_code
         quantity = abs(order.size)
         if self.store.p.lots:
-            quantity = await self.store._size_to_lots(class_code, sec_code, quantity)
-            order.size = math.copysign(await self.store._lots_to_size(class_code, sec_code, quantity), order.size)
+            quantity = await self._size_to_lots(class_code, sec_code, quantity)
+            order.size = math.copysign(await self._lots_to_size(class_code, sec_code, quantity), order.size)
 
         trans_id = int(time.time() * 1000) % 100000000  # time in milliseconds
-        order.info["trans_id"] = trans_id
-        order.info["data_id"] = order.data.data_id
+        order.addinfo(trans_id = trans_id)
+        order.addinfo(data_id = order.data.data_id)
 
         transaction = Transaction()
         transaction.TRANS_ID = trans_id
@@ -236,10 +232,10 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         if order.exectype == Order.Market:
             transaction.TYPE = TransactionType.M
             if order.data.derivative:  # Для деривативов
-                last_price = float(await self.store._get_last_price(class_code, sec_code))
+                last_price = float(await self.store.get_last_price(class_code, sec_code))
                 # Из документации QUIK: При покупке/продаже фьючерсов по рынку нужно ставить цену хуже последней сделки
                 last_price = last_price + slippage if order.isbuy() else last_price - slippage
-                market_price = await self.store._price_to_valid_price(class_code, sec_code, last_price)
+                market_price = await self.store.price_to_valid_price(class_code, sec_code, last_price)
             else:
                 market_price = Decimal(0)  # Цена рыночной заявки должна быть нулевой
             transaction.PRICE = market_price  # Рыночную цену QUIK ставим в заявку
@@ -247,25 +243,25 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         # Лимитная заявка
         elif order.exectype == Order.Limit:
             transaction.TYPE = TransactionType.L  # Лимитная заявка
-            limit_price = await self.store._price_to_valid_price(class_code, sec_code, order.price)
+            limit_price = await self.store.price_to_valid_price(class_code, sec_code, order.price)
             transaction.PRICE = limit_price  # Лимитную цену QUIK Ставим в заявку
 
         # Стоп заявка
         elif order.exectype == Order.Stop:
-            stop_price = await self.store._price_to_valid_price(class_code, sec_code, order.price)
+            stop_price = await self.store.price_to_valid_price(class_code, sec_code, order.price)
             transaction.STOPPRICE = stop_price  # Стоп цену QUIK ставим в заявкуСтавим в заявку
             if order.data.derivative:  # Для деривативов
                 market_price = stop_price + slippage if order.isbuy() else stop_price - slippage
-                market_price = await self.store._price_to_valid_price(class_code, sec_code, market_price)  # Из документации QUIK: При покупке/продаже фьючерсов по рынку нужно ставить цену хуже последней сделки
+                market_price = await self.store.price_to_valid_price(class_code, sec_code, market_price)  # Из документации QUIK: При покупке/продаже фьючерсов по рынку нужно ставить цену хуже последней сделки
             else:  # Для остальных рынков
                 market_price = Decimal(0)  # Цена рыночной заявки должна быть нулевой
             transaction.PRICE = market_price  # Рыночную цену QUIK ставим в заявку
 
         # Стоп-лимитная заявка
         elif order.exectype == Order.StopLimit:
-            stop_price = await self.store._price_to_valid_price(class_code, sec_code, order.price)
+            stop_price = await self.store.price_to_valid_price(class_code, sec_code, order.price)
             transaction.STOPPRICE = stop_price  # Стоп цену QUIK ставим в заявку
-            limit_price = await self.store._price_to_valid_price(class_code, sec_code, order.pricelimit)
+            limit_price = await self.store.price_to_valid_price(class_code, sec_code, order.pricelimit)
             transaction.PRICE = limit_price  # Лимитную цену QUIK Ставим в заявку
 
         # Для стоп заявок
@@ -281,7 +277,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         with self._lock_orders:
             self.orders[trans_id] = order  # Сохраняем заявку в списке заявок, отправленных на биржу
         self._save_broker_state()
-        trans_id = await self.store._send_transaction(transaction)
+        trans_id = await self.store.send_transaction(transaction)
         order.submit(self)  # Отправляем заявку на биржу (Order.Submitted)
         self._save_broker_state()
         if trans_id < 0:  # Если возникла ошибка при постановке заявки на уровне QUIK
@@ -303,8 +299,9 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
                 return None
 
         order_num = order.info['order_num']
+        linked_order = order.info.get('linked_order', 0)
         is_stop = order.exectype in [Order.Stop, Order.StopLimit]
-        is_stop_order = is_stop and await self.store._get_order_by_number(order_num) is None
+        is_stop_order = is_stop and await self.store.get_order_by_number(order_num) is None
 
         transaction = Transaction()
         transaction.TRANS_ID = trans_id
@@ -312,14 +309,18 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         transaction.SECCODE = order.data.sec_code
 
         if is_stop_order:  # Для стоп заявки
-            transaction.ACTION = TransactionAction.KILL_STOP_ORDER
-            transaction.STOP_ORDER_KEY = str(order_num)
+            if linked_order== 0: # Если нет связанной лимитной заявки, то отменяем стоп-заявку
+                transaction.ACTION = TransactionAction.KILL_STOP_ORDER
+                transaction.STOP_ORDER_KEY = str(order_num)
+            else:  # Если есть связанная лимитная заявка, то отменяем лимитную заявку
+                transaction.ACTION = TransactionAction.KILL_ORDER
+                transaction.ORDER_KEY = str(linked_order)
         else:  # Для лимитной заявки
             transaction.ACTION = TransactionAction.KILL_ORDER
             transaction.ORDER_KEY = str(order_num)
         order.addinfo(op='cancel')
         self._save_broker_state()
-        await self.store._send_transaction(transaction)
+        await self.store.send_transaction(transaction)
         return order
 
     async def oco_pc_check(self, order):
@@ -346,7 +347,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
                     await self.cancel_order(child)  # Отменяем дочернюю заявку
 
 
-    async def _on_trans_reply(self, data: TransactionReply):
+    async def on_trans_reply(self, data: TransactionReply):
         """Обработчик события ответа на транзакцию пользователя"""
         self.logger.debug('on_trans_reply: data=%s', str(data))
         qk_trans_reply = data
@@ -366,11 +367,12 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
             order_op = order.info["op"]
             if order_op == 'new':
                 self.logger.debug('on_trans_reply: Заявка %s переведена в статус принята на бирже (Order.Accepted)', order.ref)
-                order.accept(self)  # Заявка принята на бирже (Order.Accepted)
+                with self.store.lock_store_data:
+                    order.accept(self)  # Заявка принята на бирже (Order.Accepted)
                 order.addinfo(op='done')
             elif order_op == 'cancel':
                 self.logger.debug('on_trans_reply: Заявка %s переведена в статус отменена (Order.Canceled)', order.ref)
-                with self.store._lock_store_data:
+                with self.store.lock_store_data:
                     order.cancel()  # Отменяем существующую заявку (Order.Canceled)
                 order.addinfo(op='done')
         elif status in (2, 4, 5, 10, 11, 12, 13, 14, 16):  # Транзакция не выполнена (ошибка заявки):
@@ -384,7 +386,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
                 return  # то заявку не отменяем, выходим, дальше не продолжаем
             try:
                 self.logger.debug('on_trans_reply: Заявка %s переведена в статус отклонена (Order.Rejected)', order.ref)
-                with self.store._lock_store_data:
+                with self.store.lock_store_data:
                     order.reject(self)  # Отклоняем заявку (Order.Rejected)
             except (KeyError, IndexError) as e:
                 self.logger.error('on_trans_reply: Exception for change order.status: %s', e)
@@ -393,7 +395,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         elif status == 6:  # Транзакция не прошла проверку лимитов сервера QUIK
             try:
                 self.logger.debug('on_trans_reply: Заявка %s переведена в статус не прошла проверку лимитов (Order.Margin)', order.ref)
-                with self.store._lock_store_data:
+                with self.store.lock_store_data:
                     order.margin()  # Для заявки не хватает средств (Order.Margin)
             except (KeyError, IndexError) as e:
                 self.logger.error('on_trans_reply: Exception for change order.status: %s', e)
@@ -408,7 +410,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         self.logger.debug('on_trans_reply: Заявка %s. Выход', order.ref)
 
 
-    async def _on_trade(self, data: Trade):
+    async def on_trade(self, data: Trade):
         """Обработчик события получения новой / изменения существующей сделки.
         Выполняется до события изменения существующей заявки. Нужен для определения цены исполнения заявок.
         """
@@ -427,7 +429,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         self.logger.debug('on_trade: Заявка %s с номером %s. Номер транзакции %s. Номер сделки %s order=%s', order.ref, order_num, trans_id, trade_num, order)
         class_code = qk_trade.class_code  # Код режима торгов
         sec_code = qk_trade.sec_code  # Код тикера
-        dataname = self.store._get_ticker_name(class_code, sec_code)
+        dataname = self.store.get_ticker_name(class_code, sec_code)
         # Защита от дублей сделок (критичная секция - check-then-act)
         # Используем asyncio.Lock для оптимальной работы в async контексте
         async with self._lock_trades:
@@ -439,7 +441,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
 
         size = qk_trade.qty  # Абсолютное кол-во
         if self.store.p.lots:  # Если входящий остаток в лотах
-            size = await self.store._lots_to_size(class_code, sec_code, size)  # то переводим кол-во из лотов в штуки
+            size = await self._lots_to_size(class_code, sec_code, size)  # то переводим кол-во из лотов в штуки
         if qk_trade.flags & OrderTradeFlags.IS_SELL.value:
             size *= -1  # Продажа - кол-во ставим отрицательным
         price = float(qk_trade.price) # Цена сделки
@@ -474,16 +476,52 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
             self.value = await self._getvalue(None)
 
 
-    async def _on_order(self, order : Order):
+    async def on_order(self, order : QuikOrder):
         self.logger.debug('on_order trans_id=%s order_num=%s  ext_status=%s  flags=%s  state=%s', order.trans_id, order.order_num, order.ext_order_status, order.flags, order.state)
+        trans_id = order.trans_id
+        with self._lock_orders:
+            if trans_id not in self.orders:
+                self.logger.debug('on_order: Заявка с номером %s. Номер транзакции %s. Заявка была выставлена не из торговой системы. Выход', order.order_num, trans_id)
+                return
+            order: Order = self.orders[trans_id]
+        if order.exectype in (Order.Stop, Order.StopLimit):
+            linked_order = order.info.get('linked_order', 0)
+            if linked_order != 0 and order.order_num == linked_order:
+                self.logger.debug('on_order: Заявка %s является стоп-заявкой', order.ref)
+                notifs = False
+                if order.state == State.CANCELED:
+                    self.logger.debug('on_order: Linked Заявка %s переведена в статус отклонена (Order.Rejected)', order.ref)
+                    with self.store.lock_store_data:
+                        order.reject(self)  # Отклоняем заявку (Order.Rejected)
+                    notifs = True
+                elif order.state == State.COMPLETED:
+                    self.logger.debug('on_order: Linked Заявка %s исполнена (Order.Сompleted)', order.ref)
+                    with self.store.lock_store_data:
+                        order.completed(self)  # Переводим заявку в статус Order.Completed
+                    notifs = True
+                self._save_broker_state()
+                if notifs:
+                    with self._lock_notifs:
+                        self.notifs.append(order.clone())  # Уведомляем брокера о заявке
 
-    async def _on_stop_order(self, stop_order:StopOrder):
+    async def on_stop_order(self, stop_order:QuikStopOrder):
         self.logger.debug('on_stop_order trans_id=%s order_num=%s  linked_order=%s  flags=%s  state=%s', stop_order.trans_id, stop_order.order_num, stop_order.linked_order, stop_order.flags, stop_order.state)
-
+        trans_id = stop_order.trans_id
+        with self._lock_orders:
+            if trans_id not in self.orders:
+                self.logger.debug('on_stop_order: Заявка с номером %s. Номер транзакции %s. Заявка была выставлена не из торговой системы. Выход', stop_order.order_num, trans_id)
+                return
+            order: Order = self.orders[trans_id]
+        state = stop_order.state
+        if state == State.COMPLETED:
+            order.addinfo(linked_order=stop_order.linked_order)
+            self._save_broker_state()
+        with self._lock_notifs:
+            self.notifs.append(order.clone())  # Уведомляем брокера о заявке
 
     def submit(self, order):
         """Отправка заявки на биржу (требуется BrokerBase)"""
-        return self.store.__class__.run_sync(self.place_order(order))
+        return QuikStore.run_sync(self.place_order(order))
 
 
     def add_order_history(self, orders, notify=True):
@@ -510,10 +548,10 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
             for ticker_name, position in self._positions.items():
                 if datas and not any(data.p.dataname == ticker_name for data in datas):
                     continue
-                class_code, sec_code = await self.store._parse_ticker_name(ticker_name)
-                last_price =  await self.store._get_last_price(class_code, sec_code)
+                class_code, sec_code = await self.store.parse_ticker_name(ticker_name)
+                last_price =  await self.store.get_last_price(class_code, sec_code)
                 if last_price:
-                    last_price = await self.store._quik_price_to_SUR(class_code, sec_code, last_price)
+                    last_price = await self.store.quik_price_to_SUR(class_code, sec_code, last_price)
                     value += position.size * last_price
         return value
 
@@ -522,13 +560,14 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         orders = self._load_broker_state()
         if orders is None:
             return
-        ord_list = await self.store._get_orders()
-        stop_ord_list = await self.store._get_stop_orders()
+        ord_list = await self.store.get_orders()
+        stop_ord_list = await self.store.get_stop_orders()
         founded = set()
         for o in ord_list:
             self.logger.debug('Active Order: %s', str(o))
-            if o.trans_id in orders:
-                order: Order = orders[o.trans_id]
+            str_trans_id = str(o.trans_id)
+            if str_trans_id in orders:
+                order: Order = orders[str_trans_id]
                 order.addinfo(order_num=o.order_num)
                 match o.state:
                     case State.ACTIVE:
@@ -543,12 +582,13 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
                     case _:
                         pass
                 order.price = float(o.price)
-                founded.add(o.trans_id)
+                founded.add(str_trans_id)
 
         for o in stop_ord_list:
             self.logger.debug('Active Stop Order: %s', str(o))
-            if o.trans_id in orders:
-                order: Order = orders[o.trans_id]
+            str_trans_id = str(o.trans_id)
+            if str_trans_id in orders:
+                order: Order = orders[str_trans_id]
                 order.addinfo(order_num=o.order_num)
                 match o.state:
                     case State.ACTIVE:
@@ -561,20 +601,28 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
                     case _:
                         pass
                 order.price = float(o.price)
-                founded.add(o.trans_id)
+                founded.add(str_trans_id)
         orders_to_remove = set(orders.keys()) - founded
         for trans_id in orders_to_remove:
             del orders[trans_id]
         with self._lock_orders:
             self.orders = orders
-        self._save_broker_state()
-
 
     def _save_broker_state(self):
         """Сохранение состояния брокера"""
+        def _info2dict(vals:dict):
+            info = {}
+            for k, v in vals.items():
+                if k == 'account':
+                    info['account'] = v.to_dict()
+                else:
+                    info[k] = v
+            return info
+
         with self._lock_orders:
             state = {}
             state['version'] = 1
+            state['broker_info'] = self.info
             state['orders'] = {}
             state['last_order_ref'] = Order.last_ref()
             state['ocos'] = self.ocos
@@ -585,9 +633,10 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
             ord = {}
             for k, v in self.orders.items():
                 ord[k] = v.to_dict()
+                ord[k]['info'] = _info2dict(v.info)
             state['orders'] = ord
             with open(self._state_file, 'w') as f:
-                json.dump(state, f)
+                json.dump(state, f, indent=2)
 
     def _load_broker_state(self) -> None|dict:
         """Загрузка состояния брокера"""
@@ -603,17 +652,39 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         if version != 1:
             self.logger.error('load_broker_state: Неподдерживаемая версия состояния брокера: %s', version)
             return None
-        orders_dict = state.get('orders', {})
+        orders_state = state.get('orders', {})
         orders = {}
-        for k, v in orders_dict.items():
-            order = Order.from_dict(v)
+        for k, v in orders_state.items():
+            params = v.get('params', {})
+            info = v.get('info', {})
+            data_id = info.get('data_id', None)
+            if data_id is None:
+                self.logger.error('load_broker_state: Ошибка загрузки заявки %s: нет data_id', k)
+                continue
+            data = None
+            for d in self.cerebro.datas:
+                if d.data_id == data_id:
+                    data = d
+                    break
+            if data is None:
+                self.logger.error('load_broker_state: Ошибка загрузки заявки %s: не найден тикер с data_id=%s', k, data_id)
+                continue
+            params['data'] = data
+            order = Order.from_dict(params, v)
             order.broker = self
-            data_id = order.info["data_id"]
-            order.data = self.store._get_data_by_id(data_id)
+            order.addinfo(account=self.account)
+            order.addcomminfo(self.getcommissioninfo(data))
             orders[k] = order
         last_order_ref = state.get('last_order_ref', 0)
+        for v in orders.values():
+            if v.parent_ref is not None:
+                for o in orders.values():
+                    if o.ref == v.parent_ref:
+                        v.parent = o
+                        break
         Order.reset_ref(last_order_ref)
         self.ocos = state.get('ocos', {})
+        self.info = state.get('broker_info', {})
         trade_nums_serializable = state.get('trade_nums', defaultdict(set))
         for k, v in trade_nums_serializable.items():
             self.trade_nums[k] = set(v)
@@ -626,7 +697,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
         if not acc:
             raise ValueError('QuikBroker: Не задан account для получения позиций')
         if acc.futures:
-            futures_holdings = await self.store._get_futures_client_holdings()
+            futures_holdings = await self.store.get_futures_client_holdings()
             for fut in futures_holdings:
                 if fut.total_net != 0:
                     self.logger.debug("Futures Position: %s TotalNet: %s AvrPosnPrice: %s", fut.sec_code, fut.total_net, fut.avr_pos_nprice)
@@ -634,25 +705,25 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
                     sec_code = fut.sec_code
                     size = int(fut.total_net)
                     if self.store.p.lots:
-                        size = await self.store._lots_to_size(class_code, sec_code, size)
-                    dataname = self.store._get_ticker_name(class_code, sec_code)
-                    price = await self.store._quik_price_to_SUR(class_code, sec_code, fut.avr_pos_nprice)
+                        size = await self._lots_to_size(class_code, sec_code, size)
+                    dataname = self.store.get_ticker_name(class_code, sec_code)
+                    price = await self.store.quik_price_to_SUR(class_code, sec_code, fut.avr_pos_nprice)
                     positions[dataname] = Position(size, price)
         else:
-            depo_limits = await self.store._get_all_depo_limits()
+            depo_limits = await self.store.get_all_depo_limits()
             account_depo_limits = [limit for limit in depo_limits
                                     if limit.client_code == acc.client_code and
                                     limit.firm_id == acc.firm_id and
                                     limit.limit_kind.value == self.store.p.limit_kind and
                                     limit.current_bal != 0]
             for limit in account_depo_limits:
-                class_code, sec_code = await self.store._parse_ticker_name(limit.sec_code)
+                class_code, sec_code = await self.store.parse_ticker_name(limit.sec_code)
                 size = int(limit.current_bal)
                 if self.store.p.lots:  # Если входящий остаток в лотах
-                    size = await self.store._lots_to_size(class_code, sec_code, size)
+                    size = await self._lots_to_size(class_code, sec_code, size)
                 # Переводим средневзвешенную цену приобретения позиции (входа) в цену в рублях за штуку
-                price = await self.store._quik_price_to_SUR(class_code, sec_code, float(limit.wa_position_price))
-                dataname = self.store._get_ticker_name(class_code, sec_code)
+                price = await self.store.quik_price_to_SUR(class_code, sec_code, float(limit.wa_position_price))
+                dataname = self.store.get_ticker_name(class_code, sec_code)
                 positions[dataname] = Position(size, price)
         with self._lock_positions:
             self._positions = positions
@@ -660,7 +731,7 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
     async def _getcash(self):
         """Получение текущего баланса по всем счетам"""
         self.logger.debug('call _getcash()')
-        money_limits:MoneyLimitEx = await self.store._get_money_limits()
+        money_limits:MoneyLimitEx = await self.store.get_money_limits()
         if len(money_limits) == 0:
             self.logger.error("_getcash: Ошибка получения баланса - нет лимитов по деньгам")
             return 0.0
@@ -670,14 +741,14 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
             raise ValueError('QuikBroker: Не задан account для получения позиций')
         if acc.futures:
             if self.store.p.edp:
-                portf:PortfolioInfoEx = await self.store._get_portfolio_info_ex(acc.firm_id, acc.client_code)
+                portf:PortfolioInfoEx = await self.store.get_portfolio_info_ex(acc.firm_id, acc.client_code)
                 if portf:
                     cash += portf.all_assets
                 else:
                     self.logger.error('_getcash: QUIK не вернул информацию по счету с firm_id=%s, client_code=%s. Проверьте правильность значений', acc.firm_id, acc.client_code)
             else:
                 # Баланс = Лимит откр.поз. + Вариац.маржа + Накоплен.доход
-                fut_limits = await self.store._get_futures_limit(acc.firm_id, acc.trade_account_id, self.store.p.currency)
+                fut_limits = await self.store.get_futures_limit(acc.firm_id, acc.trade_account_id, self.store.p.currency)
                 if fut_limits:
                     cash += fut_limits.cbp_limit + fut_limits.var_margin + fut_limits.accruedint
                 else:
@@ -698,3 +769,24 @@ class QuikBroker(with_metaclass(MetaQuikBroker, BrokerBase)):
                 cash += balance
         return cash
 
+    async def _is_ucp_client(self, firm_id: str, client_code: str) -> bool:
+        """Проверка, является ли клиент участником единой денежной позиции (УДП)"""
+        self.logger.debug("Checking if client %s.%s is UCP", firm_id, client_code)
+        try:
+            return await self.store.quik_api.trading.is_ucp_client(firm_id, client_code)
+        except Exception as e:
+            self.logger.error("Error checking UCP client: %s", e)
+            return False
+
+    async def _size_to_lots(self, class_code:str, sec_code:str, size) -> int:
+        info = await self.store.get_ticker_info(class_code, sec_code)
+        if info and info.lot_size and info.lot_size > 0:
+            return int(size // info.lot_size)
+        return size
+
+    async def _lots_to_size(self, class_code: str, sec_code: str, lots) -> int:
+        info = await self.store.get_ticker_info(class_code, sec_code)
+        if info and info.lot_size and info.lot_size > 0:
+            return int(lots * info.lot_size)
+        return lots
+

{bn_quik-0.1.0 → bn_quik-0.2.1}/bn_quik/QuikData.py

@@ -42,7 +42,7 @@ class QuikData(with_metaclass(MetaQuikData, AbstractDataBase)):
 
     def __init__(self, **kwargs):
         self.store = QuikStore(**kwargs)  # Хранилище QUIK
-        self.class_code, self.sec_code = self.store.__class__.run_sync(self.store._parse_ticker_name(self.p.dataname))
+        self.class_code, self.sec_code = QuikStore.run_sync(self.store.parse_ticker_name(self.p.dataname))
         # tf = self.store._bt_timeframe_to_str(self.p.timeframe, self.p.compression)
         self.candle_interval = self.store._bt_timeframe_2_quik(self.p.timeframe, self.p.compression)
         self._data_id = self.store._get_data_id(self.class_code, self.sec_code, self.candle_interval)
@@ -73,7 +73,7 @@ class QuikData(with_metaclass(MetaQuikData, AbstractDataBase)):
         if self.p.live_bars:  # Если получаем историю и новые бары
             if not self.store._is_subscribed_to_candles(self.class_code, self.sec_code, self.candle_interval):
                 self.store._subscribe_to_candles(self.class_code, self.sec_code, self.candle_interval)  # Подписываемся на новые бары
-        self.info = self.store._get_ticker_info_sync(self.class_code, self.sec_code)
+        self.info = self.store.get_ticker_info_sync(self.class_code, self.sec_code)
 
         cur_datetime = self.store._get_quik_datetime_now()
         self.put_notification(self.DELAYED)  # Отправляем уведомление об отправке исторических (не новых) баров

{bn_quik-0.1.0 → bn_quik-0.2.1}/bn_quik/QuikStore.py

@@ -1,5 +1,6 @@
 import logging
 import collections
+import os
 import threading
 import asyncio
 import atexit
@@ -100,20 +101,38 @@ class MetaSingleton(MetaParams):
 
 
 class Account:
-    client_code: str = None
-    order_client_code: str = None
-    firm_id: str = None
-    class_codes: List[str]
-    trade_account_id: str
-    futures: bool = False
-    is_ucp: bool = False
-
+    '''Account class to hold trade account information'''
     def __init__(self, trade_account_id: str, client_code: str, firm_id: str, class_codes: List[str]):
-        self.trade_account_id = trade_account_id
-        self.client_code = client_code
-        self.firm_id = firm_id
-        self.class_codes = class_codes
+        self.client_code: str = client_code
+        self.order_client_code: str = client_code
+        self.firm_id: str = firm_id
+        self.class_codes: List[str] = class_codes
+        self.trade_account_id: str = trade_account_id
+        self.futures: bool = False
+        self.is_ucp: bool = False
+
+    def to_dict(self):
+        return {
+            'trade_account_id': self.trade_account_id,
+            'client_code': self.client_code,
+            'firm_id': self.firm_id,
+            'class_codes': self.class_codes,
+            'futures': self.futures,
+            'is_ucp': self.is_ucp,
+        }
 
+    @classmethod
+    def from_dict(cls, odict):
+        acc = cls(
+            trade_account_id=odict.get('trade_account_id'),
+            client_code=odict.get('client_code'),
+            firm_id=odict.get('firm_id'),
+            class_codes=odict.get('class_codes', []),
+        )
+        acc.futures = odict.get('futures', False)
+        acc.is_ucp = odict.get('is_ucp', False)
+        return acc
+        
 
 class QuikStore(with_metaclass(MetaSingleton, object)):
     '''
@@ -138,10 +157,9 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
         ('edp', False),  # Единая денежная позиция
         ('slippage_steps', 10),  # Кол-во шагов цены для проскальзывания
         ('data_dir', 'DataQuik'),  # Каталог для хранения данных
-        #('notifyall', False),
-        #('_debug', False),
-        # ('reconnect', 3),  # -1 forever, 0 No, > 0 number of retries
-        # ('timeout', 3.0),  # timeout between reconnections
+
+        ('client_code_for_orders', None),  # Номер торгового терминала. У брокера Финам требуется для совершения торговых операций
+        ('trade_account_id', None),
     )
 
     @classmethod
@@ -190,7 +208,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
         self._lock_qdata = threading.RLock()        # Гибридный: Async(_on_new_candle/_register_data/_unregister_data) + может быть sync доступ
         self._lock_notifs = threading.Lock()        # Гибридный: Sync(get_notifications/put_notification) + может быть async
         self._lock_accounts = threading.Lock()      # Только Async: get_accounts (но может расшириться)
-        self._lock_store_data = threading.RLock()   # Гибридный: Используется в QuikBroker для критических операций с данными
+        self.lock_store_data = threading.RLock()   # Гибридный: Используется в QuikBroker для критических операций с данными
         
         # Примечание: threading.Lock безопасен в данной архитектуре благодаря отдельному потоку для event loop.
 
@@ -261,8 +279,8 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
         self.quik_api.events.remove_on_disconnected(self._on_disconnected)
         self.quik_api.events.remove_on_trans_reply(self._on_transaction_reply)
         self.quik_api.events.remove_on_trans_reply(self._on_trade)
-        # self.quik_api.events.remove_on_order(self._on_order)
-        # self.quik_api.events.remove_on_stop_order(self._on_stop_order)
+        self.quik_api.events.remove_on_order(self._on_order)
+        self.quik_api.events.remove_on_stop_order(self._on_stop_order)
 
         self.logger.info("Stopping QUIK async loop...")
         self._stop_event.set()  # Устанавливаем флаг остановки
@@ -305,8 +323,8 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             self.quik_api.events.add_on_disconnected(self._on_disconnected)
             self.quik_api.events.add_on_trans_reply(self._on_transaction_reply)
             self.quik_api.events.add_on_trade(self._on_trade)
-            # self.quik_api.events.add_on_order(self._on_order)
-            # self.quik_api.events.add_on_stop_order(self._on_stop_order)
+            self.quik_api.events.add_on_order(self._on_order)
+            self.quik_api.events.add_on_stop_order(self._on_stop_order)
 
         except Exception as e:
             self.logger.error("Ошибка подключения: %s", e)
@@ -332,23 +350,23 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
     async def _on_transaction_reply(self, reply: TransactionReply):
         # self.logger.debug(reply)
         if self.broker:
-            await self.broker._on_trans_reply(reply)
+            await self.broker.on_trans_reply(reply)
 
     async def _on_order(self, order : Order):
         # self.logger.info(order)
         if self.broker:
-            await self.broker._on_order(order)
+            await self.broker.on_order(order)
 
     async def _on_stop_order(self, stop_order:StopOrder):
         # self.logger.info(stop_order)
         if self.broker:
-            await self.broker._on_stop_order(stop_order)
+            await self.broker.on_stop_order(stop_order)
             pass
 
     async def _on_trade(self, trade: Trade):
         # self.logger.debug(trade)
         if self.broker:
-            await self.broker._on_trade(trade)
+            await self.broker.on_trade(trade)
 
     def _get_data_by_id(self, data_id: str):
         """Получение данных по тикеру и временному интервалу"""
@@ -433,7 +451,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             self.logger.error("Error getting trade accounts: %s", e)
             return []
 
-    async def _get_ticker_info(self, class_code: str, sec_code: str) -> SecurityInfo | None:
+    async def get_ticker_info(self, class_code: str, sec_code: str) -> SecurityInfo | None:
         """Получение информации о тикере из QUIK"""
         key = (class_code, sec_code)
         self.logger.debug("Getting ticker info for %s.%s", class_code, sec_code)
@@ -453,19 +471,10 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
 
     def _get_ticker_info_sync(self, class_code: str, sec_code: str) -> dict:
         """Синхронное получение информации о тикере из QUIK"""
-        info = self.__class__.run_sync(self._get_ticker_info(class_code, sec_code))
+        info = QuikStore.run_sync(self.get_ticker_info(class_code, sec_code))
         return info.to_dict() if info else {}
     
-    async def _is_ucp_client(self, firm_id: str, client_code: str) -> bool:
-        """Проверка, является ли клиент участником единой денежной позиции (УДП)"""
-        self.logger.debug("Checking if client %s.%s is UCP", firm_id, client_code)
-        try:
-            return await self.quik_api.trading.is_ucp_client(firm_id, client_code)
-        except Exception as e:
-            self.logger.error("Error checking UCP client: %s", e)
-            return False
-
-    async def _get_portfolio_info_ex(self, firm_id: str, client_code: str) -> PortfolioInfoEx | None:
+    async def get_portfolio_info_ex(self, firm_id: str, client_code: str) -> PortfolioInfoEx | None:
         self.logger.debug("Getting extended portfolio info for %s.%s", firm_id, client_code)
         try:
             return await self.quik_api.trading.get_portfolio_info_ex(firm_id, client_code)
@@ -482,7 +491,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             self.logger.error("Error getting extended ticker info: %s", e)
             return None
 
-    async def _get_all_depo_limits(self) -> List[DepoLimitEx]:
+    async def get_all_depo_limits(self) -> List[DepoLimitEx]:
         """Получение всех лимитов по бумагам из QUIK"""
         try:
             return await self.quik_api.trading.get_depo_limits()
@@ -490,7 +499,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             self.logger.error("Error getting all depo limits: %s", e)
             return []
 
-    async def _get_money_limits(self) -> List[MoneyLimitEx]:
+    async def get_money_limits(self) -> List[MoneyLimitEx]:
         """Получение всех лимитов по деньгам из QUIK"""
         try:
             return await self.quik_api.trading.get_money_limits()
@@ -498,7 +507,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             self.logger.error("Error getting all money limits: %s", e)
             return []
 
-    async def _get_futures_limit(self, firm_id: str, acc_id: str, curr_code: str = "") -> FuturesLimits | None:
+    async def get_futures_limit(self, firm_id: str, acc_id: str, curr_code: str = "") -> FuturesLimits | None:
         """Получение всех лимитов по фьючерсам из QUIK"""
         try:
             return await self.quik_api.trading.get_futures_limit(firm_id, acc_id, FuturesLimitType.MONEY, curr_code)
@@ -506,7 +515,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             self.logger.error("Error getting futures limits: %s", e)
             return None
 
-    async def _get_orders(self) -> list[Order]:
+    async def get_orders(self) -> list[Order]:
         """Получение всех заявок из QUIK"""
         try:
             return await self.quik_api.orders.get_orders()
@@ -514,7 +523,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             self.logger.error("Error getting orders: %s", e)
             return []
 
-    async def _get_stop_orders(self) -> list[StopOrder]:
+    async def get_stop_orders(self) -> list[StopOrder]:
         """Получение всех стоп-заявок из QUIK"""
         try:
             return await self.quik_api.stop_orders.get_stop_orders()
@@ -522,7 +531,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             self.logger.error("Error getting stop orders: %s", e)
             return []
 
-    async def _get_order_by_number(self, order_num:int) -> Order | None:
+    async def get_order_by_number(self, order_num:int) -> Order | None:
         """Получение информации о заявке по её номеру"""
         try:
             return await self.quik_api.orders.get_order_by_number(order_num)
@@ -530,7 +539,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             self.logger.error("Error getting order by number: %s", e)
             return None
 
-    async def _get_futures_client_holdings(self) -> list[FuturesClientHolding]:
+    async def get_futures_client_holdings(self) -> list[FuturesClientHolding]:
         """Получение всех позиций по фьючерсам из QUIK"""
         try:
             return await self.quik_api.trading.get_futures_client_holdings()
@@ -560,7 +569,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
             return datetime.now(self.tz_msk).replace(tzinfo=None)  # То время МСК получаем из локального времени
 
 
-    async def _parse_ticker_name(self, name:str) -> tuple[str, str] | None:
+    async def parse_ticker_name(self, name:str) -> tuple[str, str] | None:
         parts = name.split('.')
         if len(parts) >= 2:
             return (parts[0], '.'.join(parts[1:]))
@@ -576,7 +585,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
                     self._sec_code2name[sec_code] = (class_code, sec_code)
                 return class_code, sec_code
 
-    def _get_ticker_name(self, class_code: str, sec_code: str) -> str:
+    def get_ticker_name(self, class_code: str, sec_code: str) -> str:
         return f'{class_code}.{sec_code}'
 
 
@@ -656,9 +665,9 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
         """
         Получение уникального идентификатора данных по тикеру и временному интервалу
         """
-        return f'{class_code}.{sec_code}_{interval.name}'
+        return f'{class_code}.{sec_code}.{interval.name}'
 
-    async def _send_transaction(self, transaction) -> int:
+    async def send_transaction(self, transaction) -> int:
         """Отправка транзакции в QUIK"""
         try:
             trans_id = await self.quik_api.trading.send_transaction(transaction)
@@ -690,19 +699,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
                     self.logger.error('get_accounts: Ошибка получения списка счетов: %s', e)
             return self._accounts
 
-    async def _lots_to_size(self, class_code: str, sec_code: str, lots) -> int:
-        info = await self._get_ticker_info(class_code, sec_code)
-        if info and info.lot_size and info.lot_size > 0:
-            return int(lots * info.lot_size)
-        return lots
-
-    async def _size_to_lots(self, class_code:str, sec_code:str, size) -> int:
-        info = await self._get_ticker_info(class_code, sec_code)
-        if info and info.lot_size and info.lot_size > 0:
-            return int(size // info.lot_size)
-        return size
-
-    async def _get_last_price(self, class_code: str, sec_code: str) -> float | None:
+    async def get_last_price(self, class_code: str, sec_code: str) -> float | None:
         with self._lock_qdata:
             data = self.qdata_last.get((class_code, sec_code), None)
         if data and len(data):
@@ -726,11 +723,11 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
                 self._ticker_stepprice[key] = (step_price, datetime.now(self.tz_msk))
         return step_price
 
-    async def _quik_price_to_SUR(self, class_code: str, sec_code: str, quik_price: float) -> float:
+    async def quik_price_to_SUR(self, class_code: str, sec_code: str, quik_price: float) -> float:
         """
         Перевод цены QUIK в цену в рублях за штуку
         """
-        si = await self._get_ticker_info(class_code, sec_code)
+        si = await self.get_ticker_info(class_code, sec_code)
         if not si:
             return quik_price  # то цена не изменяется
         if class_code in ('TQOB', 'TQCB', 'TQRD', 'TQIR'):  # Для облигаций (Т+ Гособлигации, Т+ Облигации, Т+ Облигации Д, Т+ Облигации ПИР)
@@ -745,9 +742,9 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
                     return lot_price / lot_size  # Цена за штуку
         return quik_price
 
-    async def _price_to_valid_price(self, class_code: str, sec_code: str, price: float) -> Decimal:
+    async def price_to_valid_price(self, class_code: str, sec_code: str, price: float) -> Decimal:
         """Перевод цены в рублях за штуку в корректную цену QUIK"""
-        si = await self._get_ticker_info(class_code, sec_code)
+        si = await self.get_ticker_info(class_code, sec_code)
         if not si:
             return Decimal(str(price))
         # Возращаем цену, которую примет QUIK в заявке
@@ -758,7 +755,7 @@ class QuikStore(with_metaclass(MetaSingleton, object)):
 
     async def _price_to_quik_price(self, class_code: str, sec_code: str, price: float) -> Decimal:
         """Перевод цены в рублях за штуку в цену QUIK"""
-        si = await self._get_ticker_info(class_code, sec_code)
+        si = await self.get_ticker_info(class_code, sec_code)
         if not si:
             return Decimal(str(price))
         min_price_step = si.min_price_step

{bn_quik-0.1.0 → bn_quik-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bn_quik"
-version = "0.1.0"
+version = "0.2.1"
 description = "Backtrader-next connector for QUIK terminal"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }
@@ -16,7 +16,7 @@ classifiers = [
 
 requires-python = ">=3.11"
 dependencies = [
-    "backtrader-next>=2.1.0",
+    "backtrader-next>=2.3.2",
     "quik-python>=1.2.0",
 ]
 [project.urls]

bn_quik-0.2.1/requirements.txt

@@ -0,0 +1,2 @@
+backtrader-next>=2.3.2
+quik-python>=1.2.0

bn_quik-0.1.0/README.md

@@ -1,2 +0,0 @@
-# bn_quik
-Live trading intergartion of backtrader-next with QUIK trade terminal

bn_quik-0.1.0/requirements.txt

@@ -1,2 +0,0 @@
-backtrader-next>=2.1.0
-quik-python>=1.2.0