onetick-py 1.173.0__py3-none-any.whl → 1.175.0__py3-none-any.whl

onetick/py/_version.py

@@ -1,2 +1,2 @@
 # This file was generated automatically. DO NOT CHANGE.
-VERSION = '1.173.0'
+VERSION = '1.175.0'

onetick/py/aggregations/_base.py

@@ -547,7 +547,7 @@ class _AggregationTSSelection(_Aggregation):
 
 class _FloatAggregation(_Aggregation):
 
-    require_type = (int, float, ott._inf)
+    require_type = (int, float, ott._inf, ott.decimal)
 
     """
     Aggregation that expect int or float as input

onetick/py/aggregations/order_book.py

@@ -229,6 +229,9 @@ class ObSnapshot(_OrderBookAggregation):
         # we don't want to set hard limit on the output of order book aggregations
         if self.show_full_detail:
             kwargs['all_fields'] = True
+        self._size_type = int
+        if self.size_max_fractional_digits > 0:
+            self._size_type = float  # type: ignore[assignment]
         super().__init__(*args, **kwargs)
 
     def _param_validation(self):
@@ -244,7 +247,7 @@ class ObSnapshot(_OrderBookAggregation):
     def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
         schema = {
             'PRICE': float,
-            'SIZE': int,
+            'SIZE': self._size_type,
             'LEVEL': int,
             'UPDATE_TIME': otp.nsectime,
             'BUY_SELL_FLAG': int,
@@ -265,10 +268,10 @@ class ObSnapshotWide(ObSnapshot):
     def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
         schema = {
             'BID_PRICE': float,
-            'BID_SIZE': int,
+            'BID_SIZE': self._size_type,
             'BID_UPDATE_TIME': otp.nsectime,
             'ASK_PRICE': float,
-            'ASK_SIZE': int,
+            'ASK_SIZE': self._size_type,
             'ASK_UPDATE_TIME': otp.nsectime,
             'LEVEL': int,
         }
@@ -299,10 +302,10 @@ class ObSnapshotFlat(ObSnapshot):
         for level in range(1, self.max_levels + 1):
             schema.update({
                 f'BID_PRICE{level}': float,
-                f'BID_SIZE{level}': int,
+                f'BID_SIZE{level}': self._size_type,
                 f'BID_UPDATE_TIME{level}': otp.nsectime,
                 f'ASK_PRICE{level}': float,
-                f'ASK_SIZE{level}': int,
+                f'ASK_SIZE{level}': self._size_type,
                 f'ASK_UPDATE_TIME{level}': otp.nsectime,
             })
         return schema
@@ -343,6 +346,9 @@ class ObSummary(_OrderBookAggregation):
         self.state_key_max_inactivity_sec = state_key_max_inactivity_sec
         self.size_max_fractional_digits = size_max_fractional_digits
         self.include_market_order_ticks = include_market_order_ticks
+        self._size_type = int
+        if self.size_max_fractional_digits > 0:
+            self._size_type = float   # type: ignore[assignment]
         super().__init__(*args, **kwargs)
 
     def _param_validation(self):
@@ -357,12 +363,12 @@ class ObSummary(_OrderBookAggregation):
 
     def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
         schema = {
-            'BID_SIZE': int,
+            'BID_SIZE': self._size_type,
             'BID_VWAP': float,
             'BEST_BID_PRICE': float,
             'WORST_BID_PRICE': float,
             'NUM_BID_LEVELS': int,
-            'ASK_SIZE': int,
+            'ASK_SIZE': self._size_type,
             'ASK_VWAP': float,
             'BEST_ASK_PRICE': float,
             'WORST_ASK_PRICE': float,

onetick/py/aggregations/other.py

@@ -100,7 +100,7 @@ class Vwap(_Aggregation):
     FIELDS_TO_SKIP: List = ['column_name']
 
     output_field_type = float
-    require_type = (int, float, ott.nsectime)
+    require_type = (int, float, ott.nsectime, ott.decimal)
 
     def __init__(self,
                  price_column: str,
@@ -271,7 +271,7 @@ class Average(_FloatAggregation):
 class StdDev(_Aggregation):     # Stddev does not support inf, so no need to use _FloatAggregation
     NAME = "STDDEV"
     EP = otq.Stddev
-    require_type = (int, float)
+    require_type = (int, float, ott.decimal)
     output_field_type = float
     FIELDS_MAPPING = deepcopy(_Aggregation.FIELDS_MAPPING)
     FIELDS_MAPPING['biased'] = 'BIASED'

onetick/py/core/_source/source_methods/misc.py

@@ -618,6 +618,9 @@ def pnl_realized(
         The name of the field with price, default is **PRICE**.
     buy_sell_flag_field: str, :py:class:`otp.Column <onetick.py.Column>`
         The name of the field with buy/sell flag, default is **BUY_SELL_FLAG**.
+        If the type of this field is string, then possible values are 'B' or 'b' for buy and 'S' or 's' for sell.
+        If the type of this field is integer, then possible values are 0 for buy and 1 for sell.
+
 
     See also
     --------
@@ -625,20 +628,63 @@ def pnl_realized(
 
     Examples
     --------
+    Let's generate some data:
 
-    Simple usage
-
-    >>> data = otp.DataSource('SOME_DATABASE', tick_type='TT', symbols='AA')  # doctest: +SKIP
-    >>> data = data.pnl_realized()  # doctest: +SKIP
-    >>> otp.run(data)  # doctest: +SKIP
-                         Time  BUY_SELL_FLAG  PRICE  SIZE  PNL_REALIZED
-    0 2003-12-01 00:00:00.000              0      5    20           0.0
-    1 2003-12-01 00:00:00.001              0      4    30           0.0
-    2 2003-12-01 00:00:00.002              1      3    15         -30.0
-    3 2003-12-01 00:00:00.003              0     10    50           0.0
-    4 2003-12-01 00:00:00.004              1      7    18          49.0
-    5 2003-12-01 00:00:00.005              1      9     6          30.0
-    6 2003-12-01 00:00:00.006              0      8    40           0.0
+    >>> trades = otp.Ticks(
+    ...     PRICE=[1.0, 2.0, 3.0, 2.5, 4.0, 5.0, 6.0, 7.0, 3.0, 4.0, 1.0],
+    ...     SIZE=[700, 20, 570, 600, 100, 100, 100, 100, 150, 10, 100],
+    ...     SELL_FLAG=[0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1],
+    ...     SIDE=['B', 'B', 'B', 'S', 'S', 'S', 'S', 'S', 'B', 'B', 'S'],
+    ... )
+    >>> otp.run(trades)
+                          Time  PRICE  SIZE  SELL_FLAG SIDE
+    0  2003-12-01 00:00:00.000    1.0   700          0    B
+    1  2003-12-01 00:00:00.001    2.0    20          0    B
+    2  2003-12-01 00:00:00.002    3.0   570          0    B
+    3  2003-12-01 00:00:00.003    2.5   600          1    S
+    4  2003-12-01 00:00:00.004    4.0   100          1    S
+    5  2003-12-01 00:00:00.005    5.0   100          1    S
+    6  2003-12-01 00:00:00.006    6.0   100          1    S
+    7  2003-12-01 00:00:00.007    7.0   100          1    S
+    8  2003-12-01 00:00:00.008    3.0   150          0    B
+    9  2003-12-01 00:00:00.009    4.0    10          0    B
+    10 2003-12-01 00:00:00.010    1.0   100          1    S
+
+    And then calculate profit and loss metric for it.
+
+    First let's use string ``buy_sell_flag_field`` field:
+
+    >>> data = trades.pnl_realized(buy_sell_flag_field='SIDE')  # doctest: +SKIP
+    >>> otp.run(data)[['Time', 'PRICE', 'SIZE', 'SIDE', 'PNL_REALIZED']]  # doctest: +SKIP
+                          Time  PRICE  SIZE  SIDE  PNL_REALIZED
+    0  2003-12-01 00:00:00.000    1.0   700     B           0.0
+    1  2003-12-01 00:00:00.001    2.0    20     B           0.0
+    2  2003-12-01 00:00:00.002    3.0   570     B           0.0
+    3  2003-12-01 00:00:00.003    2.5   600     S         900.0
+    4  2003-12-01 00:00:00.004    4.0   100     S         300.0
+    5  2003-12-01 00:00:00.005    5.0   100     S         220.0
+    6  2003-12-01 00:00:00.006    6.0   100     S         300.0
+    7  2003-12-01 00:00:00.007    7.0   100     S         400.0
+    8  2003-12-01 00:00:00.008    3.0   150     B           0.0
+    9  2003-12-01 00:00:00.009    4.0    10     B           0.0
+    10 2003-12-01 00:00:00.010    1.0   100     S        -200.0
+
+    We can get the same result using integer ``buy_sell_flag_field`` field:
+
+    >>> data = trades.pnl_realized(buy_sell_flag_field='SELL_FLAG')  # doctest: +SKIP
+    >>> otp.run(data)[['Time', 'PRICE', 'SIZE', 'SELL_FLAG', 'PNL_REALIZED']]  # doctest: +SKIP
+                          Time  PRICE  SIZE  SELL_FLAG  PNL_REALIZED
+    0  2003-12-01 00:00:00.000    1.0   700          0           0.0
+    1  2003-12-01 00:00:00.001    2.0    20          0           0.0
+    2  2003-12-01 00:00:00.002    3.0   570          0           0.0
+    3  2003-12-01 00:00:00.003    2.5   600          1         900.0
+    4  2003-12-01 00:00:00.004    4.0   100          1         300.0
+    5  2003-12-01 00:00:00.005    5.0   100          1         220.0
+    6  2003-12-01 00:00:00.006    6.0   100          1         300.0
+    7  2003-12-01 00:00:00.007    7.0   100          1         400.0
+    8  2003-12-01 00:00:00.008    3.0   150          0           0.0
+    9  2003-12-01 00:00:00.009    4.0    10          0           0.0
+    10 2003-12-01 00:00:00.010    1.0   100          1        -200.0
     """
     if computation_method not in ['fifo']:
         raise ValueError(

onetick/py/core/column_operations/_methods/conversions.py

@@ -31,7 +31,7 @@ def float_to_str(prev_op, dtype=str):
     return MethodResult(op_str, dtype)
 
 
-def float_to_decimal(prev_op):
+def num_to_decimal(prev_op):
     return MethodResult(f'decimal({str(prev_op)})', ott.decimal)
 
 
@@ -192,7 +192,7 @@ class _ConversionsDict(UserDict):
 
 CONVERSIONS = _ConversionsDict({(float, int): float_to_int,
                                 (float, str): float_to_str,
-                                (float, ott.decimal): float_to_decimal,
+                                (float, ott.decimal): num_to_decimal,
                                 (ott.decimal, int): float_to_int,
                                 (ott.decimal, str): decimal_to_str,
                                 (ott.decimal, float): decimal_to_float,
@@ -206,6 +206,7 @@ CONVERSIONS = _ConversionsDict({(float, int): float_to_int,
                                 (int, float): int_to_float,
                                 (int, ott.nsectime): int_to_nsectime,
                                 (int, ott.msectime): int_to_msectime,
+                                (int, ott.decimal): num_to_decimal,
                                 (str, float): str_to_float,
                                 (str, ott.decimal): str_to_decimal,
                                 (str, int): str_to_int,

onetick/py/core/column_operations/_methods/op_types.py

@@ -8,9 +8,12 @@ from onetick.py import types as ott
 
 
 def are_numerics(*dtypes):
-    return all(inspect.isclass(dtype)
-               and (issubclass(dtype, (float, int)) or np.issubdtype(dtype, np.integer))
-               and not issubclass(dtype, (ott.nsectime, ott.msectime)) for dtype in dtypes)
+    return all(
+        inspect.isclass(dtype)
+        and (issubclass(dtype, (float, int)) or np.issubdtype(dtype, np.integer) or issubclass(dtype, ott.decimal))
+        and not issubclass(dtype, (ott.nsectime, ott.msectime))
+        for dtype in dtypes
+    )
 
 
 def are_ints_not_time(*dtypes):
@@ -109,6 +112,12 @@ def _get_widest_type(left, right):
     (<class '...MyTime'>, None, <class '...MyNSec'>)
     """
 
+    # decimal takes precedence before integer and floating point types
+    if issubclass(left, ott.decimal) and are_numerics(right):
+        return left
+    if are_numerics(left) and issubclass(right, ott.decimal):
+        return right
+
     if issubclass(left, float) and issubclass(right, float):
         # between np.float and float we choose base float
         if left is not float and np.issubdtype(left, np.floating):

onetick/py/core/column_operations/base.py

@@ -476,7 +476,7 @@ class Operation:
         Property that provides access to
         methods specific to float type.
         """
-        if issubclass(self.dtype, float) and self.dtype is not ott.decimal:
+        if issubclass(self.dtype, float):
             from onetick.py.core.column_operations.accessors.float_accessor import _FloatAccessor
             return _FloatAccessor(self)
         else:
@@ -1043,7 +1043,7 @@ class Raw(Operation):
     def __init__(self, raw, dtype):
         if dtype is str:
             warnings.warn(
-                f'Be careful, default string length in OneTick is {ott.string.DEFAULT_LENGTH}.'
+                f'Be careful, default string length in OneTick is {ott.string.DEFAULT_LENGTH}. '
                 "Length of the result raw expression can't be calculated automatically, "
                 "so you'd better use onetick.py.string type.",
                 stacklevel=2,

onetick/py/core/source.py

@@ -947,7 +947,9 @@ class Source:
         view: bool = False,
         line_limit: Optional[Tuple[int, int]] = (10, 30),
         parse_eval_from_params: bool = False,
+        render_debug_info: bool = False,
         debug: bool = False,
+        graphviz_compat_mode: bool = False,
         **kwargs,
     ):
         """
@@ -973,8 +975,13 @@ class Source:
             If one of tuple values set to zero the corresponding limit disabled.
         parse_eval_from_params: bool
             Enable parsing and printing `eval` sub-queries from EP parameters.
+        render_debug_info: bool
+            Render additional debug information.
         debug: bool
             Allow to print stdout or stderr from `Graphviz` render.
+        graphviz_compat_mode: bool
+            Change internal parameters of result graph for better compatibility with old `Graphviz` versions.
+            Could produce larger and less readable graphs.
         kwargs:
             Additional arguments to be passed to :py:meth:`onetick.py.Source.to_otq` method (except
             ``file_name``, ``file_suffix`` and ``query_name`` parameters)
@@ -1006,7 +1013,8 @@ class Source:
 
         otq_path = self.to_otq(**kwargs)
         return render_otq(
-            otq_path, image_path, output_format, load_external_otqs, view, line_limit, parse_eval_from_params, debug,
+            otq_path, image_path, output_format, load_external_otqs, view, line_limit, parse_eval_from_params,
+            render_debug_info, debug, graphviz_compat_mode,
         )
 
     def copy(self, ep=None, columns=None, deep=False) -> 'Source':

onetick/py/functions.py

@@ -327,6 +327,7 @@ def merge(sources, align_schema=True, symbols=None, identify_input_ts=False,
 
     if enforce_order:
         result.drop('OMDSEQ', inplace=True)
+        merged_columns.pop('OMDSEQ')
 
     if identify_input_ts:
         result.schema['SYMBOL_NAME' + added_field_name_suffix] = str
@@ -2030,7 +2031,7 @@ def _add_element(cur_res, element, format_spec_additional=None):
     if isinstance(element, Operation):
         if format_spec_additional is None:
             cur_res += element.apply(str)
-        elif issubclass(element.dtype, float) and re.fullmatch(r'\.\d+f', format_spec_additional):
+        elif issubclass(element.dtype, (float, ott.decimal)) and re.fullmatch(r'\.\d+f', format_spec_additional):
             # float has strange behavior when precision=0
             decimal_elem = element.apply(ott.decimal)
             precision_str = re.findall(r'\d+', format_spec_additional)[0]
@@ -2047,7 +2048,7 @@ def _add_element(cur_res, element, format_spec_additional=None):
     else:
         if format_spec_additional is None:
             cur_res += str(element)
-        elif isinstance(element, float):
+        elif isinstance(element, (float, ott.decimal)):
             formatting = f'{{:{format_spec_additional}}}'
             cur_res += formatting.format(element)
         else:

onetick/py/types.py

@@ -2,6 +2,7 @@ import ctypes
 import functools
 import inspect
 import warnings
+import decimal as _decimal
 from typing import Optional, Type, Union
 from datetime import date as _date
 from datetime import datetime as _datetime
@@ -707,18 +708,23 @@ class _inf(float, metaclass=_nan_base):
 inf = _inf()
 
 
-class _decimal_str(type):
-    def __str__(cls):
-        return 'decimal'
-
-
-class decimal(float, metaclass=_decimal_str):
+class decimal:
     """
     Object that represents decimal OneTick value.
     Decimal is 128 bit base 10 floating point number.
 
+    Parameters
+    ----------
+    value: int, float, str
+        The value to initialize decimal from.
+        Note that float values may be converted with precision lost.
+
     Examples
     --------
+
+    :py:class:`~onetick.py.types.decimal` objects can be used in tick generators
+    and column operations as any other onetick-py type:
+
     >>> t = otp.Ticks({'A': [otp.decimal(1), otp.decimal(2)]})
     >>> t['B'] = otp.decimal(1.23456789)
     >>> t['C'] = t['A'] / 0
@@ -727,43 +733,107 @@ class decimal(float, metaclass=_decimal_str):
                          Time    A         B    C    D
     0 2003-12-01 00:00:00.000  1.0  1.234568  inf  NaN
     1 2003-12-01 00:00:00.001  2.0  1.234568  inf  NaN
-    """
-    def __wrap(self, res):
-        # if parent class doesn't support some operation, it returns NotImplemented and so do we
-        # In other case we wrap float result with our decimal class
-        if isinstance(res, type(NotImplemented)):
-            return NotImplemented
-        return self.__class__(res)
-
-    def __add__(self, other):
-        return self.__wrap(super().__add__(other))
 
-    def __radd__(self, other):
-        return self.__wrap(super().__radd__(other))
-
-    def __sub__(self, other):
-        return self.__wrap(super().__sub__(other))
+    Additionally, any arithmetic operation with :py:class:`~onetick.py.types.decimal` object will return
+    an :py:class:`~onetick.py.Operation` object:
 
-    def __rsub__(self, other):
-        return self.__wrap(super().__rsub__(other))
+    >>> t = otp.Tick(A=1)
+    >>> t['X'] = otp.decimal(1) / 0
+    >>> otp.run(t)
+            Time    A    X
+    0 2003-12-01    1  inf
+
+    Note that converting from float (first row) may result in losing precision.
+    :py:class:`~onetick.py.types.decimal` objects are created from strings or integers, so they don't lose precision:
+
+    >>> t0 = otp.Tick(A=0.1)
+    >>> t1 = otp.Tick(A=otp.decimal(0.01))
+    >>> t2 = otp.Tick(A=otp.decimal('0.001'))
+    >>> t3 = otp.Tick(A=otp.decimal(1) / otp.decimal(10_000))
+    >>> t = otp.merge([t0, t1, t2, t3], enforce_order=True)
+    >>> t['STR_A'] = t['A'].decimal.str(34)
+    >>> otp.run(t)
+            Time       A                                 STR_A
+    0 2003-12-01  0.1000  0.1000000000000000055511151231257827
+    1 2003-12-01  0.0100  0.0100000000000000000000000000000000
+    2 2003-12-01  0.0010  0.0010000000000000000000000000000000
+    3 2003-12-01  0.0001  0.0001000000000000000000000000000000
 
-    def __mul__(self, other):
-        return self.__wrap(super().__mul__(other))
+    Note that :py:class:`otp.Ticks <onetick.py.Ticks>` will convert everything from string under the hood,
+    so even the float values will not lose precision:
 
-    def __rmul__(self, other):
-        return self.__wrap(super().__rmul__(other))
+    >>> t = otp.Ticks({'A': [0.1, otp.decimal(0.01), otp.decimal('0.001'), otp.decimal(1e-4)]})
+    >>> t['STR_A'] = t['A'].decimal.str(34)
+    >>> otp.run(t)
+                         Time       A                                 STR_A
+    0 2003-12-01 00:00:00.000  0.1000  0.1000000000000000000000000000000000
+    1 2003-12-01 00:00:00.001  0.0100  0.0100000000000000000000000000000000
+    2 2003-12-01 00:00:00.002  0.0010  0.0010000000000000000000000000000000
+    3 2003-12-01 00:00:00.003  0.0001  0.0001000000000000000000000000000000
+    """
+    def __new__(cls, *args, **kwargs):
+        # this method dynamically adds properties and methods
+        # from otp.Operation class to this one
+
+        # otp.decimal class doesn't fit well in onetick-py type system,
+        # so this class is a mix of both type and Operation logic
+
+        # Basically it works like this:
+        #   otp.decimal is a OneTick type
+        #   otp.decimal(1) is a decimal type object
+        # Doing anything with this object returns an otp.Operation:
+        #   otp.decimal(1) / 2
+
+        def proxy_wrap(attr, value):
+            if callable(value):
+                @functools.wraps(value)
+                def f(self, *args, **kwargs):
+                    op = self.to_operation()
+                    return getattr(op, attr)(*args, **kwargs)
+                return f
+            else:
+                @functools.wraps(value)
+                def f(self):
+                    op = self.to_operation()
+                    return getattr(op, attr)
+                return property(f)
+
+        for attr, value in inspect.getmembers(otp.Operation):
+            # comparison methods are defined by default for some reason,
+            # but we want to get them from otp.Operation
+            if not hasattr(cls, attr) or attr in ('__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__'):
+                setattr(cls, attr, proxy_wrap(attr, value))
+
+        return super().__new__(cls)
+
+    def __init__(self, value):
+        supported_types = (str, int, float)
+        if not isinstance(value, supported_types):
+            raise TypeError("Parameter 'value' must be one of these types: {supported_types}")
+        self.__value = value
+
+    @classmethod
+    def _to_onetick_type_string(cls):
+        # called by ott.type2str
+        return 'decimal'
 
-    def __truediv__(self, other):
-        return self.__wrap(super().__truediv__(other))
+    def _to_onetick_string(self):
+        # called by ott.value2str
+        value = str(self.__value)
+        return f'STRING_TO_DECIMAL({value2str(value)})'
 
-    def __rtruediv__(self, other):
-        return self.__wrap(super().__rtruediv__(other))
+    def to_operation(self):
+        return otp.Operation(op_str=self._to_onetick_string(), dtype=decimal)
 
     def __str__(self):
-        return super().__repr__()
+        # called by otp.CSV, we don't need to convert the value with OneTick functions in this case
+        return str(self.__value)
 
     def __repr__(self):
-        return f"{self.__class__.__name__}({self})"
+        return f"{self.__class__.__name__}({value2str(self.__value)})"
+
+    def __format__(self, __format_spec: str) -> str:
+        return _decimal.Decimal(self.__value).__format__(__format_spec)
 
 # --------------------------------------------------------------- #
 # AUXILIARY FUNCTIONS
@@ -809,7 +879,7 @@ def get_source_base_type(value):
         value_type = nsectime
 
     # check valid value type
-    if get_base_type(value_type) not in [int, float, str, bool]:
+    if get_base_type(value_type) not in [int, float, str, bool, decimal]:
         raise TypeError(f'Type "{repr(value_type)}" is not supported.')
 
     if not is_type_basic(value_type):
@@ -818,7 +888,7 @@ def get_source_base_type(value):
 
 
 def is_type_supported(dtype):
-    return get_base_type(dtype) in [int, float, str, bool] or issubclass(dtype, (datetime, date))
+    return get_base_type(dtype) in [int, float, str, bool, decimal] or issubclass(dtype, (datetime, date))
 
 
 def get_base_type(obj):
@@ -830,6 +900,8 @@ def get_base_type(obj):
         return int
     elif issubclass(obj, float):
         return float
+    elif issubclass(obj, decimal):
+        return decimal
 
     return type(None)
 
@@ -1686,6 +1758,8 @@ def type2str(t):
         return "double"
     if t is None:
         return ''
+    if t is decimal:
+        return t._to_onetick_type_string()
     return str(t)
 
 
@@ -1841,15 +1915,16 @@ def value2str(v):
         # there is no escape, so replacing double quotes with concatenation with it
         return '"' + str(v).replace('"', '''"+'"'+"''') + '"'
 
-    if isinstance(v, (float, decimal)) and not (isinstance(v, (_inf, _nan))):
+    if isinstance(v, decimal):
+        return v._to_onetick_string()
+
+    if isinstance(v, float) and not (isinstance(v, (_inf, _nan))):
         # PY-286: support science notation
         s = str(v)
         if "e" in s:
-            s = f"{v:.20f}".rstrip("0")
+            return f'atof({value2str(s)})'
         if s == "nan":
             return str(nan)
-        if isinstance(v, decimal):
-            return f'DECIMAL({s})'
         return s
 
     if is_time_type(v):
@@ -1960,7 +2035,7 @@ def default_by_type(dtype):
     >>> otp.default_by_type(float)
     nan
     >>> otp.default_by_type(otp.decimal)
-    decimal(0.0)
+    decimal(0)
     >>> otp.default_by_type(int)
     0
     >>> otp.default_by_type(otp.ulong)

onetick/py/utils/render.py

@@ -1,6 +1,7 @@
 import os
 import re
 import html
+import textwrap
 import graphviz as gv
 from collections import defaultdict, deque
 from datetime import datetime
@@ -29,6 +30,82 @@ IF_ELSE_EPS = {
 }
 
 
+def _parse_table_fields(line: str) -> list:
+    result = line.strip().split(',')
+    for idx in range(0, len(result) - 1):
+        result[idx] = result[idx] + ','
+
+    return result
+
+
+def _light_function_splitter(line: str, sep=',') -> list:
+    lines = []
+    current_line: list = []
+    parentheses_stack = 0
+    quotes_stack = 0
+    lead_quote_type = None
+
+    for ch in line:
+        if ch == sep and not parentheses_stack and not quotes_stack:
+            lines.append(''.join(current_line) + sep)
+            current_line = []
+            continue
+
+        current_line.append(ch)
+
+        if ch == '(' and not quotes_stack:
+            parentheses_stack += 1
+            continue
+
+        if ch == ')' and not quotes_stack:
+            parentheses_stack -= 1
+            if parentheses_stack < 0:
+                break
+
+        if ch in ["\"", "'"]:
+            if lead_quote_type is None:
+                lead_quote_type = ch
+                quotes_stack = 1
+            elif ch == lead_quote_type:
+                lead_quote_type = None
+                quotes_stack = 0
+
+    if parentheses_stack != 0:
+        raise ValueError(f'Incorrect parentheses count in function: `{line}`')
+
+    if quotes_stack != 0:
+        raise ValueError(f'Incorrect quotes count in function: `{line}`')
+
+    lines.append(''.join(current_line))
+
+    return lines
+
+
+EP_TO_MULTILINE_ATTRS: dict = {
+    "ADD_FIELDS": {
+        "set": _light_function_splitter,
+    },
+    "UPDATE_FIELDS": {
+        "set": _light_function_splitter,
+    },
+    "TABLE": {
+        "fields": _parse_table_fields,
+    },
+    "PASSTHROUGH": {
+        "fields": _parse_table_fields,
+    },
+    "COMPUTE": {
+        "compute": _light_function_splitter,
+    },
+    "DECLARE_STATE_VARIABLES": {
+        "variables": _light_function_splitter,
+    },
+    "RENAME_FIELDS": {
+        "rename_fields": _parse_table_fields,
+    }
+}
+
+
 @dataclass
 class NestedQuery:
     name: str
@@ -53,6 +130,14 @@ class NestedQuery:
             return "::".join(i for i in [self.file_path, self.query] if i)
 
 
+@dataclass
+class Config:
+    height: int = field(default=0)
+    width: int = field(default=0)
+    render_debug_info: bool = field(default=False)
+    constraint_edges: str = field(default="true")
+
+
 @dataclass
 class EP:
     name: str
@@ -341,11 +426,14 @@ def _parse_function_params(func_params: str) -> Tuple[list, dict]:
     return args, kwargs
 
 
-def _parse_function(expression: str) -> Tuple[Optional[str], list, dict]:
+def _parse_function(expression: str, pattern: Optional[str] = None) -> Tuple[Optional[str], list, dict]:
     # EP_NAME(PARAM_NAME=PARAM_VALUE,...)
     # [a-zA-Z_:] is EP_NAME, can contain letters, underscore and colon
     # [\s\S] is any symbol including newline (because . doesn't include newline by default)
-    m = re.search(r"^([a-zA-Z_:]*)\s*\(([\s\S]*)\)\s*$", expression)
+    if not pattern:
+        pattern = r"^([a-zA-Z_:]*)\s*\(([\s\S]*)\)\s*$"
+
+    m = re.search(pattern, expression)
 
     if not m:
         return None, [], {}
@@ -412,9 +500,9 @@ def _parse_ep(ep_string: str, parse_eval_from_params: bool = False) -> Union[EP,
         is_query_found = True
 
         if kwargs_key in kwargs:
-            query_path = kwargs.pop(kwargs_key)[1]
+            query_path = kwargs[kwargs_key][1]
         elif 0 <= args_idx < len(args):
-            query_path = args.pop(args_idx)
+            query_path = args[args_idx]
         else:
             # don't do anything, just process as EP
             is_query_found = False
@@ -697,32 +785,59 @@ def read_otq(path: str, parse_eval_from_params: bool = False) -> Optional[Graph]
     return graph
 
 
-def truncate_param_value(ep: Any, param, value, line_limit: Optional[Tuple[int, int]] = None):
-    if line_limit is None:
-        return value
+def _truncate_param_value(value, height, width):
+    lines = [
+        line if len(line) <= width or not width else line[:width] + "..."
+        for line in value.splitlines()
+    ]
 
-    height, width = line_limit
-    if height < 0 or width < 0:
-        raise ValueError("line_limit values should not be negative")
+    if height and len(lines) > height:
+        lines = lines[:height] + ["..."]
+
+    return "\n".join(lines)
+
+
+def _split_long_value_to_lines(value, height, width, indent=0, escape=False) -> list:
+    if len(value) <= width:
+        return [value]
+
+    result = []
+    lines = value.splitlines()
+
+    # textwrap.wrap replaces newline character to whitespace and brakes multiline strings
+    # If replace_whitespace=False, it preserves newline, but not use it for result array line splitting
+    for line in lines:
+        result.extend(textwrap.wrap(line, width=width, replace_whitespace=False))
+
+    if escape:
+        result = [html.escape(s) for s in result]
+
+    if indent:
+        indent_str = "&nbsp;" * indent
+        for i in range(1, len(result)):
+            result[i] = indent_str + result[i]
 
+    if height and len(result) > height:
+        result = result[:height] + ['...']
+    return result
+
+
+def transform_param_value(ep: Any, param, value, height, width):
     if isinstance(ep, EP) and (
         ep.name == "PER_TICK_SCRIPT" and param.lower() == "script" or
         ep.name == "CSV_FILE_LISTING" and param.lower() == "file_contents"
     ):
-        lines = [
-            line if len(line) <= width or not width else line[:width] + "..."
-            for line in value.split("\n")
-        ]
-
-        if height and len(lines) > height:
-            lines = lines[:height] + ["..."]
+        return _truncate_param_value(value, height, width)
 
-        return "\n".join(lines)
+    if not (isinstance(ep, EP) and EP_TO_MULTILINE_ATTRS.get(ep.name, {}).get(param.lower())):
+        return "\n".join(_split_long_value_to_lines(value, height, width))
 
     return value
 
 
-def build_symbols(symbols, gr_nested, gr_static, graphs: GraphStorage, graph_node, reverse=False):
+def build_symbols(
+    symbols, gr_nested, gr_static, graphs: GraphStorage, graph_node, config: Config, reverse=False, graph_file=None,
+):
     table = GVTable()
 
     for symbol_data in symbols:
@@ -732,11 +847,17 @@ def build_symbols(symbols, gr_nested, gr_static, graphs: GraphStorage, graph_nod
             if symbol.query:
                 if symbol.is_local:
                     # reversed directions here brakes everything
+
+                    if graph_file is None:
+                        raise ValueError('`graph_file` parameter required for this case')
+
+                    nested_cluster_id = graphs.get_query_unique_id(symbol.query, graph_file)
+
                     gr_nested.edge(
-                        f"cluster__{symbol.query}__footer",
+                        f"{nested_cluster_id}__footer",
                         f"{graph_node}:symbols",
-                        ltail=f"cluster__{symbol.query}",
-                        style="dashed", constraint="false",
+                        ltail=f"{nested_cluster_id}",
+                        style="dashed", dir="both", constraint=config.constraint_edges,
                     )
                     continue
 
@@ -747,7 +868,7 @@ def build_symbols(symbols, gr_nested, gr_static, graphs: GraphStorage, graph_nod
                         f"{nested_cluster_id}__footer",
                         f"{graph_node}:symbols",
                         ltail=nested_cluster_id,
-                        style="dashed", constraint="false",
+                        style="dashed", dir="both", constraint=config.constraint_edges,
                     )
                     continue
 
@@ -764,11 +885,48 @@ def build_symbols(symbols, gr_nested, gr_static, graphs: GraphStorage, graph_nod
         gr_static.edge(
             f"{graph_node}__symbols" if not reverse else f"{graph_node}:symbols",
             f"{graph_node}:symbols" if not reverse else f"{graph_node}__symbols",
-            style="dashed", constraint="false" if not reverse else "true",
+            style="dashed", constraint=config.constraint_edges,
         )
 
 
-def build_node(graphs: GraphStorage, node: Node, line_limit: Optional[Tuple[int, int]] = None):
+def _parse_special_attribute(param_name, param_lines, parser, height, width, cols=4):
+    """
+    Builds better param representation for selected parameters and EPs
+    """
+    def generate_row_string(_line: list) -> list:
+        sep = "&nbsp;&nbsp;&nbsp;&nbsp;"
+
+        # only in this case line could be longer than width
+        if len(_line) == 1 and len(_line[0]) > width:
+            _lines = _split_long_value_to_lines(_line[0], height, width, indent=4, escape=True)
+        else:
+            _lines = [sep.join(html.escape(s) for s in _line)]
+
+        return ["&nbsp;" * 2 + s for s in _lines]
+
+    param_value = ' '.join(param_lines)
+    params = parser(param_value)
+
+    params_table = [f"{param_name}:"]
+    current_line = []
+    current_width = 0
+
+    for param in params:
+        if width and current_line and current_width + len(param) >= width or len(current_line) == cols:
+            params_table.extend(generate_row_string(current_line))
+            current_line = []
+            current_width = 0
+
+        current_line.append(param)
+        current_width += len(param)
+
+    if current_line:
+        params_table.extend(generate_row_string(current_line))
+
+    return [(params_table, {"ALIGN": "LEFT", "BALIGN": "LEFT"})]
+
+
+def build_node(graphs: GraphStorage, node: Node, config: Config):
     if node.ep is None:
         raise ValueError(f"EP of node {node.id} could not be None")
 
@@ -786,6 +944,9 @@ def build_node(graphs: GraphStorage, node: Node, line_limit: Optional[Tuple[int,
     if node.tick_type:
         table.cell([node.tick_type])
 
+    if config.render_debug_info:
+        table.cell([node.id])
+
     if node.symbols:
         table.cell([("[■]", {"port": "symbols"})])
 
@@ -793,6 +954,10 @@ def build_node(graphs: GraphStorage, node: Node, line_limit: Optional[Tuple[int,
         params: List[Tuple[Optional[str], Union[str, NestedQuery]]] = \
             [(None, v) for v in node.ep.args] + list(node.ep.kwargs.values())
 
+        param_args_lines = []
+        param_kwargs_lines = []
+        special_params = []
+
         for idx, data in enumerate(params):
             k, v = data
             attrs = {"port": k}
@@ -806,34 +971,53 @@ def build_node(graphs: GraphStorage, node: Node, line_limit: Optional[Tuple[int,
             else:
                 param_value = v
 
-            param_value = truncate_param_value(node.ep, k, param_value, line_limit)
-            param_value = html.escape(param_value).replace("\t", "&nbsp;" * 4)
-            param_lines = param_value.split("\n")
+            is_special_attribute = k and EP_TO_MULTILINE_ATTRS.get(node.ep.name, {}).get(k.lower())
 
-            if k:
-                if len(param_lines) == 1:
-                    param_lines[0] = f"{html.escape(k)}={param_lines[0]}"
-                else:
-                    param_lines = [f"{html.escape(k)}="] + param_lines
+            param_value = transform_param_value(node.ep, k, param_value, config.height, config.width)
 
-            if len(param_lines) > 1:
-                # Add idents disable default horizontal central align
-                # if there are multiline parameter for EP.
-                # Align change affects all parameters for EP.
-                for i in range(len(param_lines)):
-                    if i > 0:
-                        param_lines[i] = "&nbsp;" * 2 + param_lines[i]
+            if not is_special_attribute:
+                param_value = html.escape(param_value)
 
-                attrs.update({"ALIGN": "LEFT", "BALIGN": "LEFT"})
+            param_value = param_value.replace("\t", "&nbsp;" * 4)
+            param_lines = param_value.splitlines()
 
+            # additional k check required by mypy
+            if is_special_attribute and k:
+                special_params.extend(
+                    _parse_special_attribute(
+                        k, param_lines, EP_TO_MULTILINE_ATTRS[node.ep.name][k.lower()], config.height, config.width,
+                    )
+                )
+            else:
+                if k:
+                    if len(param_lines) == 1:
+                        param_lines[0] = f"{html.escape(k)}={param_lines[0]}"
+                    else:
+                        param_lines = [f"{html.escape(k)}:"] + param_lines
+
+                if len(param_lines) > 1:
+                    # Add idents disable default horizontal central align
+                    # if there are multiline parameter for EP.
+                    # Align change affects all parameters for EP.
+                    for i in range(len(param_lines)):
+                        if i > 0:
+                            param_lines[i] = "&nbsp;" * 2 + param_lines[i]
+
+                    attrs.update({"ALIGN": "LEFT", "BALIGN": "LEFT"})
+
+                if k:
+                    param_kwargs_lines.append((param_lines, attrs))
+                else:
+                    param_args_lines.append((param_lines, attrs))
+
+        for param_lines, attrs in param_args_lines + special_params + param_kwargs_lines:
             table.row([param_lines], attrs=attrs)
 
     if node.params:
-        table.row([[f"{html.escape(k)}={html.escape(v)}" for k, v in node.params.items()]])
-
-    if isinstance(node.ep, NestedQuery):
-        if not (node.ep.is_local and node.ep.query or graphs.get_query(node.ep.file_path, node.ep.query)):
-            table.row([node.ep.to_string()])
+        table.row([[
+            f"{html.escape(k)}={html.escape(_truncate_param_value(v, config.height, config.width))}"
+            for k, v in node.params.items()
+        ]])
 
     if isinstance(node.ep, IfElseEP):
         table.row([
@@ -886,7 +1070,7 @@ def _get_nested_query(nested_query: NestedQuery, local_graph: Graph, graphs: Gra
 
 
 def _render_graph(
-    gr_root, gr, graphs: GraphStorage, graph_name: str, queries: set, line_limit: Optional[Tuple[int, int]] = None,
+    gr_root, gr, graphs: GraphStorage, graph_name: str, queries: set, config: Config,
 ):
     graph = graphs[graph_name]
 
@@ -947,15 +1131,18 @@ def _render_graph(
 
                 gr_sub.edge(
                     f"{footer_id}:params", f"{query_id}__params",
-                    style="dashed", constraint="true",
+                    style="dashed", constraint=config.constraint_edges,
                 )
 
             if query.symbols:
-                build_symbols(query.symbols, gr, gr_sub, graphs, f"{query_id}__footer", reverse=True)
+                build_symbols(
+                    query.symbols, gr, gr_sub, graphs, f"{query_id}__footer", config,
+                    reverse=True, graph_file=graph.file_path,
+                )
 
             for node_id, node in query.nodes.items():
                 node_unique_id = _get_node_unique_id(node, query)
-                gr_sub.node(node_unique_id, build_node(graphs, node, line_limit), group=query_name)
+                gr_sub.node(node_unique_id, build_node(graphs, node, config), group=query_name)
 
                 for sink in node.sinks:
                     if "OUT" in node.labels:
@@ -989,11 +1176,11 @@ def _render_graph(
                             f"{node_unique_id}:{param_name}",
                             _get_node_unique_id(nested_cluster.roots[0], nested_cluster),
                             lhead=nested_cluster.get_id(),
-                            style="dashed", dir="both",
+                            style="dashed", dir="both", constraint=config.constraint_edges,
                         )
 
                 if node.symbols:
-                    build_symbols(node.symbols, gr, gr_sub, graphs, node_unique_id)
+                    build_symbols(node.symbols, gr, gr_sub, graphs, node_unique_id, config, graph_file=graph.file_path)
 
                 if isinstance(node.ep, NestedQuery):
                     nested_cluster = _get_nested_query(node.ep, graph, graphs)
@@ -1004,7 +1191,7 @@ def _render_graph(
                         node_unique_id,
                         _get_node_unique_id(nested_cluster.roots[0], nested_cluster),
                         lhead=nested_cluster.get_id(),
-                        style="dashed", dir="both",
+                        style="dashed", dir="both", constraint=config.constraint_edges,
                     )
 
 
@@ -1014,9 +1201,11 @@ def render_otq(
     output_format: Optional[str] = None,
     load_external_otqs: bool = True,
     view: bool = False,
-    line_limit: Optional[Tuple[int, int]] = (10, 30),
+    line_limit: Optional[Tuple[int, int]] = (10, 60),
     parse_eval_from_params: bool = False,
+    render_debug_info: bool = False,
     debug: bool = False,
+    graphviz_compat_mode: bool = False,
 ) -> str:
     """
     Render queries from .otq files.
@@ -1029,7 +1218,7 @@ def render_otq(
     image_path: str, None
         Path for generated image. If omitted, image will be saved in a temp dir
     output_format: str, None
-        `Graphviz` rendering format. Default: `png`.
+        `Graphviz` rendering format. Default: `svg`.
         If `image_path` contains one of next extensions, `output_format` will be set automatically: `png`, `svg`, `dot`.
     load_external_otqs: bool
         If set to `True` (default) dependencies from external .otq files (not listed in ``path`` param)
@@ -1043,8 +1232,13 @@ def render_otq(
         If one of tuple values set to zero the corresponding limit disabled.
     parse_eval_from_params: bool
         Enable parsing and printing `eval` sub-queries from EP parameters.
+    render_debug_info: bool
+        Render additional debug information.
     debug: bool
         Allow to print stdout or stderr from `Graphviz` render.
+    graphviz_compat_mode: bool
+        Change internal parameters of result graph for better compatibility with old `Graphviz` versions.
+        Could produce larger and less readable graphs.
 
     Returns
     -------
@@ -1069,6 +1263,19 @@ def render_otq(
 
     >>> otp.utils.render_otq(["./first.otq", "./second.otq::some_query"])  # doctest: +SKIP
     """
+    if line_limit is None:
+        line_limit = (0, 0)
+
+    height, width = line_limit
+    if height < 0 or width < 0:
+        raise ValueError("line_limit values should not be negative")
+
+    config_kwargs = {}
+    if graphviz_compat_mode:
+        config_kwargs["constraint_edges"] = "false"
+
+    config = Config(height=height, width=width, render_debug_info=render_debug_info, **config_kwargs)
+
     if not isinstance(path, list):
         path = [path]
 
@@ -1137,7 +1344,7 @@ def render_otq(
                     output_format = extension
 
     if not output_format:
-        output_format = "png"
+        output_format = "svg"
 
     if not image_path:
         image_path = TmpFile().path
@@ -1154,8 +1361,14 @@ def render_otq(
         with gr.subgraph(name=f"cluster__graph__{idx}", node_attr={"shape": "plaintext"}) as gr_otq:
             gr_otq.attr(label=otq_path)
             gr_otq.attr(margin="16")
-            _render_graph(gr, gr_otq, graphs, otq_path, queries_to_render[otq_path], line_limit)
+            _render_graph(gr, gr_otq, graphs, otq_path, queries_to_render[otq_path], config)
 
         idx += 1
 
-    return gr.render(view=view, quiet=not debug)
+    try:
+        return gr.render(view=view, quiet=not debug)
+    except Exception as exc:
+        raise RuntimeError(
+            "Graphviz render failed. Try to set parameter `graphviz_compat_mode=True` "
+            "for better compatibility if you use old Graphviz version"
+        ) from exc

onetick/py/utils/types.py

@@ -8,6 +8,8 @@ def get_type_that_includes(types):
         if b_type1 != b_type2:
             if {b_type1, b_type2} == {int, float}:
                 dtype = float
+            elif {b_type1, b_type2} == {ott.decimal, float} or {b_type1, b_type2} == {ott.decimal, int}:
+                dtype = ott.decimal
             elif {b_type1, b_type2} == {ott.nsectime, ott.msectime}:
                 dtype = ott.nsectime
             else:

{onetick_py-1.173.0.dist-info → onetick_py-1.175.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onetick-py
-Version: 1.173.0
+Version: 1.175.0
 Summary: Python package that allows you to work with OneTick
 Author-email: solutions <solutions@onetick.com>
 License-Expression: MIT
@@ -36,7 +36,7 @@ Requires-Dist: numpy==1.26.4; python_version == "3.12" and extra == "strict"
 Requires-Dist: pandas==1.5.2; python_version == "3.9" and extra == "strict"
 Requires-Dist: pandas==1.5.3; python_version == "3.10" and extra == "strict"
 Requires-Dist: pandas==1.5.3; python_version == "3.11" and extra == "strict"
-Requires-Dist: pandas==2.2.0; python_version == "3.12" and extra == "strict"
+Requires-Dist: pandas==2.2.1; python_version == "3.12" and extra == "strict"
 Requires-Dist: pandas==2.3.0; python_version == "3.13" and extra == "strict"
 Requires-Dist: pandas==2.3.3; python_version == "3.14" and extra == "strict"
 Provides-Extra: webapi

{onetick_py-1.173.0.dist-info → onetick_py-1.175.0.dist-info}/RECORD

@@ -13,12 +13,12 @@ onetick/lib/__init__.py,sha256=Rp7CIDoA4E6LIm1f2mNvl_5b_n-0U3suA3FmBXbmKoU,114
 onetick/lib/instance.py,sha256=3FJB8PWs2ap-EGb6DzsnLRL2meTMUViTdy343m6tHvM,4825
 onetick/py/__init__.py,sha256=Ge1Ekl6OHRjm5KrXojq3AzLCaUGvLNWuaIK0C9DdwWU,11164
 onetick/py/_stack_info.py,sha256=PHZOkW_fK7Fbl4YEj5CaYK9L6vh4j-bUU7_cSYOWZ30,2546
-onetick/py/_version.py,sha256=xgAl00OwXSmPbqAEjJJgqhprH9I04svQhlQygpZzYfQ,76
+onetick/py/_version.py,sha256=T2BdtqEAyiIrXPUtz7ueDQGJEIwu9w3KvGz9NNm-yjE,76
 onetick/py/backports.py,sha256=mR00mxe7E7UgBljf-Wa93Mo6lpi-C4Op561uhPUoEt8,815
 onetick/py/cache.py,sha256=BBZg8n0AGjZzZapg4752LkSZdX5C6DGf7vU9sAStv6A,12798
 onetick/py/compatibility.py,sha256=PyQVs4h8vs_9qKocb117jyu1sNmUvqHj9o9r9NqI-9E,31036
 onetick/py/configuration.py,sha256=KCX44v_nEOZDvo-rItIrNVKKvqyM73QUwIivez2VHvY,28448
-onetick/py/functions.py,sha256=yJKL4thjNh_u-DKY08rCDMGJO_IMAeN2Odu70Q9U3Ew,97937
+onetick/py/functions.py,sha256=Kqromia64o1K4fgbLbijw64o5pFGBZRog52824wOxlA,98004
 onetick/py/license.py,sha256=50dsFrE-NKsPOdkAoyxHr44bH8DzFCr_6TabX0JH6tQ,6140
 onetick/py/log.py,sha256=Els2drZcVjJrD6kvbwgFGEpg6jAacoUEtyN6rCaauuk,2723
 onetick/py/math.py,sha256=MZvlyUjxOWGJvmxK8pfMkCr4THM52AE6NyGEidgDMyE,26311
@@ -30,17 +30,17 @@ onetick/py/servers.py,sha256=h6l0X55kcnpI25bZcYaBpPAAGBZjqk9mt1SQe4xZrh0,6840
 onetick/py/session.py,sha256=AqoS7BFN_Sz3JU2CAaZm0Bro8CmUy6VjmoDjwOU1wYM,49591
 onetick/py/sql.py,sha256=kJ0732bZ0OGF8x3VzcOUs38zEGsxcd1nZOSN75VKXhA,2993
 onetick/py/state.py,sha256=giQpUUXWwuz_CL_VvxNQDaM71LAMPqeRgHfoGhS1gTk,10330
-onetick/py/types.py,sha256=U4FSaMN_y1OUrcN6reVidbew-X2jIWj6S_lS6GvYsUo,64599
+onetick/py/types.py,sha256=jzGyG01UmjEy_ISCzgj2S7LzGx35oesQRSjYqVdg_D0,68079
 onetick/py/aggregations/__init__.py,sha256=02WnTc9ocTp34OkGyXRHY2QAZi_QjDMHClE5tvx6Gtk,736
-onetick/py/aggregations/_base.py,sha256=YQWlFYlq_QvGwTIaNGuyoU8rQsYfx-Yd-lNNq4R_o6o,25702
+onetick/py/aggregations/_base.py,sha256=HbiicjQI6nYmfGZxI1Hx9QdDJoQ4kcCmOI8E-3VZrjc,25715
 onetick/py/aggregations/_docs.py,sha256=7pz6XIhRuP_1vuOYO9UfTlzl6zGD2_jwbPMfJPOX-M8,34798
 onetick/py/aggregations/compute.py,sha256=GJpR8AWlEmfNsnl-L2oJPuY5rFb6PC-VwLZnnRGtCys,11854
 onetick/py/aggregations/functions.py,sha256=MnjINLAxoLehgInxhY-xSI1xw8TtCGzT7APD5HdFmjE,80801
 onetick/py/aggregations/generic.py,sha256=7mWRRAPS-t-e_umQc2T3GPPuW1Pia7mKhgjaVB2sSBM,3896
 onetick/py/aggregations/high_low.py,sha256=B7_Y6KhJjIqJthK0msW0JRkTpxINpnKPuSQjQa2QyZs,2508
 onetick/py/aggregations/num_distinct.py,sha256=s-VrU92kBKnJ6LIAGq2-j-t8amnolIF2EHkEt78A7_s,2830
-onetick/py/aggregations/order_book.py,sha256=RLzQk0HOG4Why7tNag3pT1GG5nBL_bBnJtID0kFr2y4,19070
-onetick/py/aggregations/other.py,sha256=wCXrb3BCUJy5e39i35V2tslp0bVR2-8Fa8E1lf45hO4,39410
+onetick/py/aggregations/order_book.py,sha256=4_NPXWy5GmtGK4W3fmT089sq3jIROn3mcgc-hX8fqVw,19439
+onetick/py/aggregations/other.py,sha256=0FZw8AIqo73duVsH7Jw7Sx7TcMABoUZAq866P-eII04,39436
 onetick/py/callback/__init__.py,sha256=lF6u1jDy0dv-2qBvonqmSaQAU7dWQAuq5FWyR5LzvLI,108
 onetick/py/callback/callback.py,sha256=i8yVsbceqhVxNTcXU2ie0-nBRyC0nS2LVDFFtqfCMlw,8618
 onetick/py/callback/callbacks.py,sha256=_8Yw_b-OITXUtNTxGJIXm-tz-KfHZYe6SdoyW7-QX4w,5011
@@ -54,7 +54,7 @@ onetick/py/core/lambda_object.py,sha256=ayob_2c2XYSG7vFsqp-2b9FSPD-3TFReLbx3de3t
 onetick/py/core/multi_output_source.py,sha256=f3dXr9kwmED77oWDFVr9cn44aYiJxC81loq2pX4u50Q,8766
 onetick/py/core/per_tick_script.py,sha256=I3pfidriS1TrFPc3DAABt91GKMgby9P_8KBatiFQx6U,83322
 onetick/py/core/query_inspector.py,sha256=Jwnw7qUVvjvaT63mQ5PkUSy8x36knoxWrNll3aXuLZw,16440
-onetick/py/core/source.py,sha256=AX4DUK1frV_FUCG5sywsn42xYX7Y2sYC7vMCOq6TeRg,63998
+onetick/py/core/source.py,sha256=h-J7Fkl5AyGiW7c0gPoUgjrZxD-6RXO6DHbJLgikByk,64421
 onetick/py/core/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onetick/py/core/_internal/_manually_bound_value.py,sha256=a4JF63g9MtXsIwpDqm_PCLBH51_SaG1-T6jWV5-IJ1k,191
 onetick/py/core/_internal/_nodes_history.py,sha256=fCpJ4FWFDzM-bmi-YyCHmNYuFM-CL_lE2bXySOi-TPY,7194
@@ -81,7 +81,7 @@ onetick/py/core/_source/source_methods/fields.py,sha256=6GozvRornClXfEu6oY9-JpN3
 onetick/py/core/_source/source_methods/filters.py,sha256=WuSnK-tQsP3fL2bqVfMZpbpPgk_LG4L8lrYULSSGoKE,33930
 onetick/py/core/_source/source_methods/joins.py,sha256=edLIJ-BTWbwvxga1YCzsN6NdhIwtJyZIksZawvPWCbU,61175
 onetick/py/core/_source/source_methods/merges.py,sha256=efk-R4WOjB2pcAIGWPsZsDzYuitADztH5xtRWTBfutk,23115
-onetick/py/core/_source/source_methods/misc.py,sha256=iWXre-Dker16oAnv6kGxyFk2FU_apMGiZQRppcUhr0c,57026
+onetick/py/core/_source/source_methods/misc.py,sha256=tPkyYc7aS6JxUOuPonFeDJ-bO0FKyhT7Zn0EuGvh5lg,59689
 onetick/py/core/_source/source_methods/pandases.py,sha256=BbvIlw6ipqC2dOiKSyyZ5jhAtE4ZtdL30OZXV_e_FuE,3670
 onetick/py/core/_source/source_methods/renames.py,sha256=T5EXq-oHq5NwApPZfYRDOJPVjclqLqAofRAP-Ykzu2M,13749
 onetick/py/core/_source/source_methods/sorts.py,sha256=tDFt3rObNHP-S_HOtDd6SLpgkCCGJnSDcMUxLake080,5583
@@ -90,12 +90,12 @@ onetick/py/core/_source/source_methods/symbols.py,sha256=MG0dgVVVJ6fD_-GJkkXEgTe
 onetick/py/core/_source/source_methods/times.py,sha256=2kbLHG-3RQM6uWmw8pBGDiAz4R83KK46Tp1smTY6SR8,27665
 onetick/py/core/_source/source_methods/writes.py,sha256=fPUbiqlm30Kb4QzXZLtWCsQiTFBDxK5oOWuVyfVXbYM,42717
 onetick/py/core/column_operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onetick/py/core/column_operations/base.py,sha256=Kcwfd4PErCGLSbkqtFKY6SZL1-pksWHB-Pc-5A8I3WM,36135
+onetick/py/core/column_operations/base.py,sha256=gn-4rz4FMAR2pp-7e9DulKc6L05YAMkGkIiEwzHmYmo,36102
 onetick/py/core/column_operations/_methods/__init__.py,sha256=_C5hpQG51MingtWW2N8vYzSVFpR314xIrtukBfEfPMk,207
 onetick/py/core/column_operations/_methods/_internal.py,sha256=M04DbbD9DjA3NrrbibuQPje8ylkaYnVB5Nmlwx1RvaE,878
-onetick/py/core/column_operations/_methods/conversions.py,sha256=QB8ZKJi5qlV8ydPn43nRHa3HMkaXCDV2Fkrq2gnVQ6U,7001
+onetick/py/core/column_operations/_methods/conversions.py,sha256=V7VREn8fFd1tanRO7x0mltrJtWFnc4ltTXTrxv1Lxpc,7065
 onetick/py/core/column_operations/_methods/methods.py,sha256=OaXiDcdPYXnPlWhwD-BCac5UAecZFnEKCkxBpQOVB5E,11054
-onetick/py/core/column_operations/_methods/op_types.py,sha256=rUMrtIPCp7TYYJIK4f836KxZIcvW60MYv3cYTGMpfRA,5004
+onetick/py/core/column_operations/_methods/op_types.py,sha256=HfoFQLVcfsAjDBigMOUxCLGoQMqEecS8IFHIE6yb2rQ,5283
 onetick/py/core/column_operations/accessors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onetick/py/core/column_operations/accessors/_accessor.py,sha256=b5K4OQmnO4NeFK1QsKjgZ1WfEyBjxKWMkb12RBbnGXQ,983
 onetick/py/core/column_operations/accessors/decimal_accessor.py,sha256=DwgJ-as0p_gex6UGxhxhsn9chSpne5YV-t1ntvr-saw,3345
@@ -139,14 +139,14 @@ onetick/py/utils/helpers.py,sha256=XY2PaMUSzFNIpiuiAY_gPQ0TnYTmfoPAGNAFh_6aB14,2
 onetick/py/utils/locator.py,sha256=YUOXU0yh0ZZZOJpJniAq9WNn0_u3X_M5q2tEwt1cp_4,2887
 onetick/py/utils/perf.py,sha256=g0r-9YUc2mx9Lj4PjG6Fk1keO3m9nC3t2cpHx3M-AeQ,19299
 onetick/py/utils/query.py,sha256=b60JmfJDx3mpP74rTQC3qnlCb6t4fYFEauVaH9ulwL8,1330
-onetick/py/utils/render.py,sha256=9SBKfKsHCrdF-FOZFGon7TalzXydCdPHINouRUwHMKM,38289
+onetick/py/utils/render.py,sha256=wTSUqkzrzrFeGQgeU5hEt1ckfW2i1hQjiEX1apUHAzs,44910
 onetick/py/utils/script.py,sha256=Y8NujEo2_5QaP6KDnLKJiKQ7SmMjw8_dv8sYL9rHDCE,11184
 onetick/py/utils/temp.py,sha256=j-BC155dE46k0zfKTTs26KTF0CK6WA1hO2GD54iunyM,17380
-onetick/py/utils/types.py,sha256=_tYf66r9JVgjtiCJfxIxrg_BQEjHkjlnck_i86dBYEY,3606
+onetick/py/utils/types.py,sha256=7u9s9uN1jlkgud8_TSLy6iFzQFBtKJ0v3yamgOVitrs,3747
 onetick/py/utils/tz.py,sha256=sYUKigaORonp7Xa6x806xVYJ69lYJHd6NrLxQHB5AZo,2878
-onetick_py-1.173.0.dist-info/licenses/LICENSE,sha256=Yhu7lKNFS0fsaN-jSattEMRtCOPueP58Eu5BPH8ZGjM,1075
-onetick_py-1.173.0.dist-info/METADATA,sha256=LDGWo1_fYz7O3MZnNC_hPpHaMy0QtQ5J_1LY__KmG4o,7218
-onetick_py-1.173.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onetick_py-1.173.0.dist-info/entry_points.txt,sha256=QmK_tFswIN-SQRmtnTSBEi8GvT0TVq-66IzXXZIsV3U,81
-onetick_py-1.173.0.dist-info/top_level.txt,sha256=Na1jSJmVMyYGOndaswt554QKIUwQjcYh6th2ATsmw0U,23
-onetick_py-1.173.0.dist-info/RECORD,,
+onetick_py-1.175.0.dist-info/licenses/LICENSE,sha256=Yhu7lKNFS0fsaN-jSattEMRtCOPueP58Eu5BPH8ZGjM,1075
+onetick_py-1.175.0.dist-info/METADATA,sha256=Xhk0Xhbx2mZ5VTLonvn-LFab_pint8OxKYU5VR_-7XU,7218
+onetick_py-1.175.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onetick_py-1.175.0.dist-info/entry_points.txt,sha256=QmK_tFswIN-SQRmtnTSBEi8GvT0TVq-66IzXXZIsV3U,81
+onetick_py-1.175.0.dist-info/top_level.txt,sha256=Na1jSJmVMyYGOndaswt554QKIUwQjcYh6th2ATsmw0U,23
+onetick_py-1.175.0.dist-info/RECORD,,