onetick-py 1.171.0__py3-none-any.whl → 1.172.0__py3-none-any.whl

onetick/py/_version.py

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

onetick/py/core/_source/source_methods/writes.py

@@ -23,8 +23,8 @@ def write(
     symbol: Union[str, 'otp.Column', None] = None,
     tick_type: Union[str, 'otp.Column', None] = None,
     date: Union[datetime.date, Type[adaptive], None] = adaptive,
-    start: Optional[datetime.date] = None,
-    end: Optional[datetime.date] = None,
+    start_date: Optional[datetime.date] = None,
+    end_date: Optional[datetime.date] = None,
     append: bool = False,
     keep_symbol_and_tick_type: Union[bool, Type[adaptive]] = adaptive,
     propagate: bool = True,
@@ -72,22 +72,21 @@ def write(
         date where to save data.
         Should be set to `None` if writing to accelerator or memory database.
         By default, it is set to `otp.config.default_date`.
-    start: :py:class:`otp.datetime <onetick.py.datetime>` or None
+    start_date: :py:class:`otp.datetime <onetick.py.datetime>` or None
         Start date for data to save. It is inclusive.
         Cannot be used with ``date`` parameter.
         Also cannot be used with ``inplace`` set to ``True``.
         Should be set to `None` if writing to accelerator or memory database.
         By default, None.
-    end: :py:class:`otp.datetime <onetick.py.datetime>` or None
-        End date for data to save. It is exclusive, so be sure to set
-        it to the next day after the last day in data.
+    end_date: :py:class:`otp.datetime <onetick.py.datetime>` or None
+        End date for data to save. It is inclusive.
         Cannot be used with ``date`` parameter.
         Also cannot be used with ``inplace`` set to ``True``.
         Should be set to `None` if writing to accelerator or memory database.
         By default, None.
     append: bool
         If False - data will be rewritten for this ``date``
-        or range of dates (from ``start`` to ``end``),
+        or range of dates (from ``start_date`` to ``end_date``),
         otherwise data will be appended: new symbols are added,
         existing symbols can be modified (append new ticks, modify existing ticks).
         This option is not valid for accelerator databases.
@@ -100,12 +99,12 @@ def write(
     propagate: bool
         Propagate ticks after that event processor or not.
     out_of_range_tick_action: str
-        Action to be executed if tick's timestamp's date is not ``date`` or between ``start`` or ``end``:
+        Action to be executed if tick's timestamp's date is not ``date`` or between ``start_date`` or ``end_date``:
 
             * `exception`: runtime exception will be raised
             * `ignore`: tick will not be written to the database
             * `load`: writes tick to the database anyway.
-                Can be used only with ``date``, not with ``start``+``end``.
+                Can be used only with ``date``, not with ``start_date``+``end_date``.
 
         Default: `exception`
     timestamp: Column
@@ -134,7 +133,7 @@ def write(
         A flag controls whether operation should be applied inplace.
         If ``inplace=True``, then it returns nothing.
         Otherwise, method returns a new modified object.
-        Cannot be ``True`` if ``start`` and ``end`` are set.
+        Cannot be ``True`` if ``start_date`` and ``end_date`` are set.
     kwargs:
         .. deprecated:: 1.21.0
 
@@ -176,6 +175,15 @@ def write(
         warnings.warn("Parameter 'keep_timestamp_field' is deprecated, use 'keep_timestamp'", FutureWarning)
         keep_timestamp = kwargs.pop('keep_timestamp_field')
 
+    if 'start' in kwargs:
+        warnings.warn("Parameter 'start' is deprecated, use 'start_date'", FutureWarning)
+        start_date = kwargs.pop('start')
+
+    if 'end' in kwargs:
+        warnings.warn("Parameter 'end' is deprecated, use 'end_date'", FutureWarning)
+        # Parameter 'end' was exclusive. Parameter 'end_date' is inclusive.
+        end_date = kwargs.pop('end') - otp.Day(1)
+
     if kwargs:
         raise TypeError(f'write() got unexpected arguments: {list(kwargs)}')
 
@@ -194,15 +202,18 @@ def write(
                     f'Field "{field_name}" contains lowercase characters and cannot be saved to a Onetick database'
                 )
 
-    if date is not adaptive and (start or end):
-        raise ValueError('date cannot be used with start+end')
+    if date is not adaptive and (start_date or end_date):
+        raise ValueError('date cannot be used with start_date+end_date')
 
-    if date is adaptive and (start and end) and inplace:
+    if date is adaptive and (start_date and end_date) and inplace:
         # join_with_query and merge are used for multiple dates, so inplace is not supported
-        raise ValueError('cannot run on multiple dates if inplace is True, use one value for date instead of start+end')
+        raise ValueError(
+            'cannot run on multiple dates if inplace is True,'
+            ' use one value for date instead of start_date+end_date'
+        )
 
-    if (start and not end) or (not start and end):
-        raise ValueError('start and end should be both specified or both None')
+    if (start_date and not end_date) or (not start_date and end_date):
+        raise ValueError('start_date and end_date should be both specified or both None')
 
     if date is adaptive:
         date = configuration.config.default_date
@@ -244,10 +255,10 @@ def write(
         # let's ignore
         pass
     elif out_of_range_tick_action.upper() == 'LOAD':
-        if start and end:
-            raise ValueError('LOAD out_of_range_tick_action cannot be used with start+end, use date instead')
+        if start_date and end_date:
+            raise ValueError('LOAD out_of_range_tick_action cannot be used with start_date+end_date, use date instead')
     elif out_of_range_tick_action.upper() == 'EXCEPTION':
-        if start and end:
+        if start_date and end_date:
             # WRITE_TO_ONETICK_DB use DAY_BOUNDARY_TZ and DAY_BOUNDARY_OFFSET
             # to check tick timestamp is out of range or not
             # so we mimic it here with THROW event processor
@@ -259,10 +270,12 @@ def write(
                 {'DAY_BOUNDARY_TZ': '__DAY_BOUNDARY_TZ', 'DAY_BOUNDARY_OFFSET': '__DAY_BOUNDARY_OFFSET'}, inplace=True
             )
             self = self.join_with_query(src, symbol=f"{str(db)}::DUMMY", caching='per_symbol')
-            start_formatted = start.strftime('%Y-%m-%d')
-            end_formatted = end.strftime('%Y-%m-%d')
-            convert_timestamp = self['TIMESTAMP'].dt.strftime('%Y%m%d%H%M%S.%J', timezone=self['__DAY_BOUNDARY_TZ'])
-            start_op = otp.dt(start).to_operation(timezone=self['__DAY_BOUNDARY_TZ']) + self['__DAY_BOUNDARY_OFFSET']
+            timezone = self['__DAY_BOUNDARY_TZ']
+            offset = self['__DAY_BOUNDARY_OFFSET']
+            convert_timestamp = self['TIMESTAMP'].dt.strftime('%Y%m%d%H%M%S.%J', timezone=timezone)
+
+            start_formatted = start_date.strftime('%Y-%m-%d')
+            start_op = otp.dt(start_date).to_operation(timezone=timezone) + offset
             self.throw(
                 where=(self['TIMESTAMP'] < start_op),
                 message=(
@@ -270,11 +283,14 @@ def write(
                     + convert_timestamp
                     + ' of a tick, visible or hidden, '
                     + f'earlier than {start_formatted} in timezone '
-                    + self['__DAY_BOUNDARY_TZ']
+                    + timezone
                 ),
                 inplace=True,
             )
-            end_op = otp.dt(end).to_operation(timezone=self['__DAY_BOUNDARY_TZ']) + self['__DAY_BOUNDARY_OFFSET']
+
+            end = end_date + otp.Day(1)  # end_date is inclusive
+            end_formatted = end.strftime('%Y-%m-%d')
+            end_op = otp.dt(end).to_operation(timezone=timezone) + offset
             self.throw(
                 where=(self['TIMESTAMP'] >= end_op),
                 message=(
@@ -282,10 +298,11 @@ def write(
                     + convert_timestamp
                     + ' of a tick, visible or hidden, '
                     + f'later than {end_formatted} in timezone '
-                    + self['__DAY_BOUNDARY_TZ']
+                    + timezone
                 ),
                 inplace=True,
             )
+            self.drop(['__DAY_BOUNDARY_TZ', '__DAY_BOUNDARY_OFFSET'], inplace=True)
     else:
         raise ValueError(
             f'Unknown out_of_range_tick_action: {out_of_range_tick_action}.'
@@ -303,18 +320,16 @@ def write(
         use_context_of_query=use_context_of_query,
     )
 
-    if start and end:
-        days = (end - start).days
+    if start_date and end_date:
+        days = (end_date - start_date).days
         if days < 0:
-            raise ValueError("Parameter 'start' must be less than parameter 'end'")
-        if days == 0:
-            raise ValueError("Parameters 'start' and 'end' must specify different dates")
+            raise ValueError("Parameter 'start_date' must be less than or equal to parameter 'end_date'")
         branches = []
-        for i in range(days):
+        for i in range(days + 1):
             branch = self.copy()
             branch.sink(
                 otq.WriteToOnetickDb(
-                    date=(start + otp.Day(i)).strftime('%Y%m%d'),
+                    date=(start_date + otp.Day(i)).strftime('%Y%m%d'),
                     propagate_ticks=propagate,
                     out_of_range_tick_action='IGNORE',
                     **kwargs,

onetick/py/core/column_operations/_methods/methods.py

@@ -14,10 +14,7 @@ class DatetimeSubtractionWarning(FutureWarning):
 
 
 def round(prev_op, precision):
-    if precision is not None:
-        return MethodResult(f'round_double({str(prev_op)},{str(precision)})', float)
-    else:
-        return MethodResult(f'round({str(prev_op)})', int)
+    return MethodResult(f'round_double({str(prev_op)},{str(precision)})', float)
 
 
 def isin(prev_op, items):

onetick/py/core/column_operations/accessors/_accessor.py

@@ -11,13 +11,11 @@ class _Accessor:
         self._base_column = base_column
 
     class Formatter(_Operation):
+        def __init__(self, dtype, formatter, op_params):
+            def op_func(*args, **kwargs):
+                return formatter(*args, **kwargs), dtype
 
-        def __init__(self, base_column, dtype, formatter):
-            super().__init__(dtype=dtype, op_params=[base_column])
-            self._formatter = formatter
-
-        def __str__(self):
-            return self._formatter(str(self._op_params[0]))
+            super().__init__(op_func=op_func, op_params=op_params, dtype=dtype)
 
     def _preprocess_tz_and_format(self,
                                   timezone: typing.Union[Operation, str, None],

onetick/py/core/column_operations/accessors/decimal_accessor.py

@@ -1,5 +1,6 @@
 from onetick.py import types as ott
 from onetick.py.core.column_operations.accessors._accessor import _Accessor
+from onetick.py.core.column_operations.base import _Operation
 
 
 class _DecimalAccessor(_Accessor):
@@ -37,10 +38,16 @@ class _DecimalAccessor(_Accessor):
         3    3.142
         Name: X, dtype: object
         """
+        def formatter(column, _precision):
+            column = ott.value2str(column)
+            _precision = ott.value2str(_precision)
+
+            return f'decimal_to_string({column}, {_precision})'
+
         return _DecimalAccessor.Formatter(
-            self._base_column,
-            str,
-            formatter=lambda x: f'decimal_to_string({x}, {precision})'
+            op_params=[self._base_column, precision],
+            dtype=str,
+            formatter=formatter,
         )
 
     def cmp(self, other, eps):
@@ -83,10 +90,15 @@ class _DecimalAccessor(_Accessor):
         4    1.0
         Name: X, dtype: float64
         """
-        other = ott.value2str(other)
-        eps = ott.value2str(eps)
+
+        def formatter(column, _other, _eps):
+            column = ott.value2str(column)
+            _other = ott.value2str(_other)
+            _eps = ott.value2str(_eps)
+            return f'decimal_compare({column}, {_other}, {_eps})'
+
         return _DecimalAccessor.Formatter(
-            self._base_column,
-            ott.decimal,
-            formatter=lambda x: f'decimal_compare({x}, {other}, {eps})'
+            op_params=[self._base_column, other, eps],
+            dtype=ott.decimal,
+            formatter=formatter,
         )

onetick/py/core/column_operations/accessors/dt_accessor.py

@@ -1,6 +1,7 @@
 from typing import Union
 
 from onetick.py import configuration, utils
+from onetick.py import types as ott
 from onetick.py.core.column_operations.accessors._accessor import _Accessor
 from onetick.py.backports import Literal
 from onetick.py.types import datetime, value2str
@@ -76,14 +77,17 @@ class _DtAccessor(_Accessor):
         """
         if timezone is utils.default:
             timezone = configuration.config.tz
-        timezone, format_str = self._preprocess_tz_and_format(timezone, format)
 
-        def formatter(x):
-            return f'nsectime_format({format_str},{x},{timezone})'
+        def formatter(column, _format, _timezone):
+            column = ott.value2str(column)
+            _timezone, _format = self._preprocess_tz_and_format(_timezone, _format)
+            return f'nsectime_format({_format},{column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     str,
-                                     formatter=formatter)
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, format, timezone],
+            dtype=str,
+            formatter=formatter,
+        )
 
     def date(self):
         """
@@ -103,7 +107,9 @@ class _DtAccessor(_Accessor):
         return self.strftime(format_str, None).str.to_datetime(format_str, None)
 
     @docstring(parameters=[_timezone_doc], add_self=True)
-    def day_of_week(self, start_index: int = 1, start_day: Literal['monday', 'sunday'] = 'monday', timezone=None):
+    def day_of_week(
+        self, start_index: Union[int, _Operation] = 1, start_day: Literal['monday', 'sunday'] = 'monday', timezone=None,
+    ):
         """
         Return the day of the week.
 
@@ -112,7 +118,7 @@ class _DtAccessor(_Accessor):
 
         Parameters
         ----------
-        start_index: int
+        start_index: int or Operation
             Sunday index.
         start_day: 'monday' or 'sunday'
             Day that will be denoted with ``start_index``
@@ -135,19 +141,22 @@ class _DtAccessor(_Accessor):
         if start_day not in ['monday', 'sunday']:
             raise ValueError(f"'start_day' parameter ({start_day}) not in ['monday', 'sunday']")
 
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
-
-        def formatter(x):
-            format_ = f'day_of_week({x},{timezone})'
-            if start_day == 'monday':
+        def formatter(column, _start_index, _start_day, _timezone):
+            column = ott.value2str(column)
+            _start_index = ott.value2str(_start_index)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            format_ = f'day_of_week({column},{_timezone})'
+            if _start_day == 'monday':
                 # CASE should be uppercased because it can be used in per-tick script
                 format_ = f'CASE({format_}, 0, 7, {format_})-1'
-            format_ += f'+{start_index}'
+            format_ += f'+{_start_index}'
             return format_
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=formatter)
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, start_index, start_day, timezone],
+            dtype=int,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def day_name(self, timezone=None):
@@ -168,11 +177,16 @@ class _DtAccessor(_Accessor):
         5 2022-05-15     Sunday
         6 2022-05-16     Monday
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'DAYNAME({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     str,
-                                     formatter=lambda x: f'DAYNAME({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=str,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def day_of_month(self, timezone=None):
@@ -193,11 +207,16 @@ class _DtAccessor(_Accessor):
         5 2022-05-15            15
         6 2022-05-16            16
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'DAYOFMONTH({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=lambda x: f'DAYOFMONTH({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=int,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def day_of_year(self, timezone=None):
@@ -218,11 +237,16 @@ class _DtAccessor(_Accessor):
         5 2022-05-15          135
         6 2022-05-16          136
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'DAYOFYEAR({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=lambda x: f'DAYOFYEAR({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=int,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def hour(self, timezone=None):
@@ -243,11 +267,16 @@ class _DtAccessor(_Accessor):
         5 2022-05-01 15:00:06    15
         6 2022-05-01 16:00:06    16
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'HOUR({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=lambda x: f'HOUR({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=int,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def minute(self, timezone=None):
@@ -269,11 +298,16 @@ class _DtAccessor(_Accessor):
         5 2022-05-01 15:15:06      15
         6 2022-05-01 15:16:06      16
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'MINUTE({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=lambda x: f'MINUTE({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=int,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def second(self, timezone=None):
@@ -294,11 +328,16 @@ class _DtAccessor(_Accessor):
         5 2022-05-01 15:11:15      15
         6 2022-05-01 15:11:16      16
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'SECOND({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=lambda x: f'SECOND({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=int,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def month(self, timezone=None):
@@ -320,11 +359,16 @@ class _DtAccessor(_Accessor):
         6 2022-09-01      9
         7 2022-10-01     10
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'MONTH({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=lambda x: f'MONTH({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=int,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def month_name(self, timezone=None):
@@ -346,11 +390,16 @@ class _DtAccessor(_Accessor):
         6 2022-09-01        Sep
         7 2022-10-01        Oct
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'MONTHNAME({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     str,
-                                     formatter=lambda x: f'MONTHNAME({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=str,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def quarter(self, timezone=None):
@@ -372,11 +421,16 @@ class _DtAccessor(_Accessor):
         6 2022-09-01        3
         7 2022-10-01        4
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'QUARTER({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=lambda x: f'QUARTER({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=int,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def year(self, timezone=None):
@@ -398,11 +452,16 @@ class _DtAccessor(_Accessor):
         6 2029-03-01  2029
         7 2030-03-01  2030
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'YEAR({column},{_timezone})'
 
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=lambda x: f'YEAR({x},{timezone})')
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=int,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def date_trunc(self,
@@ -434,12 +493,17 @@ class _DtAccessor(_Accessor):
         5 2020-11-11 05:04:13.101737879 2020-11-11 05:04:13.101000000  millisecond
         6 2020-11-11 05:04:13.101737879 2020-11-11 05:04:13.101737879   nanosecond
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
-        date_part = value2str(date_part)
-
-        return _DtAccessor.Formatter(self._base_column,
-                                     datetime,
-                                     formatter=lambda x: f'DATE_TRUNC({date_part},{x},{timezone})')
+        def formatter(column, _date_part, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            _date_part = value2str(_date_part)
+            return f'DATE_TRUNC({_date_part},{column},{_timezone})'
+
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, date_part, timezone],
+            dtype=datetime,
+            formatter=formatter,
+        )
 
     @docstring(parameters=[_timezone_doc], add_self=True)
     def week(self, timezone=None):
@@ -461,8 +525,13 @@ class _DtAccessor(_Accessor):
         6 2020-09-01    36
         7 2020-10-01    40
         """
-        timezone, _ = self._preprocess_tz_and_format(timezone, '')
-
-        return _DtAccessor.Formatter(self._base_column,
-                                     int,
-                                     formatter=lambda x: f'WEEK({x},{timezone})')
+        def formatter(column, _timezone):
+            column = ott.value2str(column)
+            _timezone, _ = self._preprocess_tz_and_format(_timezone, '')
+            return f'WEEK({column},{_timezone})'
+
+        return _DtAccessor.Formatter(
+            op_params=[self._base_column, timezone],
+            dtype=int,
+            formatter=formatter,
+        )

onetick/py/core/column_operations/accessors/float_accessor.py

@@ -1,5 +1,6 @@
 from onetick.py import types as ott
 from onetick.py.core.column_operations.accessors._accessor import _Accessor
+from onetick.py.core.column_operations.base import _Operation
 
 
 class _FloatAccessor(_Accessor):
@@ -61,11 +62,18 @@ class _FloatAccessor(_Accessor):
         Name: X, dtype: object
         """
         dtype = ott.string[length] if isinstance(length, int) else str
-        length = ott.value2str(length)
-        precision = ott.value2str(precision)
-        return _FloatAccessor.Formatter(self._base_column,
-                                        dtype,
-                                        formatter=lambda x: f"str({x}, {length}, {precision})")
+
+        def formatter(column, _length, _precision):
+            column = ott.value2str(column)
+            _length = ott.value2str(_length)
+            _precision = ott.value2str(_precision)
+            return f"str({column}, {_length}, {_precision})"
+
+        return _FloatAccessor.Formatter(
+            op_params=[self._base_column, length, precision],
+            dtype=dtype,
+            formatter=formatter,
+        )
 
     def cmp(self, other, eps):
         """
@@ -110,11 +118,17 @@ class _FloatAccessor(_Accessor):
         4    1.0
         Name: X, dtype: float64
         """
-        other = ott.value2str(other)
-        eps = ott.value2str(eps)
-        return _FloatAccessor.Formatter(self._base_column,
-                                        float,
-                                        formatter=lambda x: f"double_compare({x}, {other}, {eps})")
+        def formatter(column, _other, _eps):
+            column = ott.value2str(column)
+            _other = ott.value2str(_other)
+            _eps = ott.value2str(_eps)
+            return f"double_compare({column}, {_other}, {_eps})"
+
+        return _FloatAccessor.Formatter(
+            op_params=[self._base_column, other, eps],
+            dtype=float,
+            formatter=formatter,
+        )
 
     def eq(self, other, delta):
         """
@@ -153,8 +167,14 @@ class _FloatAccessor(_Accessor):
         4    0.0
         Name: X, dtype: float64
         """
-        other = ott.value2str(other)
-        delta = ott.value2str(delta)
-        return _FloatAccessor.Formatter(self._base_column,
-                                        bool,
-                                        formatter=lambda x: f"abs({x} - {other}) <= {delta}")
+        def formatter(column, _other, _delta):
+            column = ott.value2str(column)
+            _other = ott.value2str(_other)
+            _delta = ott.value2str(_delta)
+            return f"abs({column} - {_other}) <= {_delta}"
+
+        return _FloatAccessor.Formatter(
+            op_params=[self._base_column, other, delta],
+            dtype=bool,
+            formatter=formatter,
+        )

onetick/py/core/column_operations/accessors/str_accessor.py

@@ -21,13 +21,6 @@ class _StrAccessor(_Accessor):
     >>> data = otp.Ticks(X=['some string'])
     >>> data["Y"] = data["X"].str.<function_name>() # doctest: +SKIP
     """
-    class Formatter(_Operation):
-        def __init__(self, dtype, formatter, op_params):
-
-            def op_func(*args, **kwargs):
-                return formatter(*args, **kwargs), dtype
-
-            super().__init__(op_func=op_func, op_params=op_params, dtype=dtype)
 
     def to_datetime(self,
                     format='%Y/%m/%d %H:%M:%S.%J',

onetick/py/core/column_operations/base.py

@@ -139,9 +139,16 @@ class Operation:
         """
         return Expr(self)
 
-    def round(self, precision=None):
+    def round(self, precision=0):
         """
-        Rounds input column with specified `precision`.
+        Rounds input column with specified ``precision``.
+
+        Rounding :class:`otp.nan <onetick.py.nan>` returns NaN
+        and rounding :class:`otp.inf <onetick.py.inf>` returns Infinity.
+
+        For values that are exactly half-way between two integers (when the fraction part of value is exactly 0.5),
+        the rounding method used here is *upwards*, which returns the bigger number.
+        For other rounding methods see :func:`otp.math.round <onetick.py.math.round>` function.
 
         Parameters
         ----------
@@ -161,8 +168,8 @@ class Operation:
         >>> t['C'] = t['A'].round(2)
         >>> t['D'] = t['A'].round(-2)
         >>> otp.run(t)
-                Time          A     B        C       D
-        0 2003-12-01  1234.5678  1235  1234.57  1200.0
+                Time          A       B        C       D
+        0 2003-12-01  1234.5678  1235.0  1234.57  1200.0
 
         Returns
         -------
@@ -505,31 +512,84 @@ class Operation:
         """
         return _Operation(_methods.abs, [self])
 
-    def __round__(self, precision=None):
+    def __round__(self, precision=0):
         """
         Rounds value with specified ``precision``.
 
+        Rounding :class:`otp.nan <onetick.py.nan>` returns NaN
+        and rounding :class:`otp.inf <onetick.py.inf>` returns Infinity.
+
+        For values that are exactly half-way between two integers (when the fraction part of value is exactly 0.5),
+        the rounding method used here is *upwards*, which returns the bigger number.
+        For other rounding methods see :func:`otp.math.round <onetick.py.math.round>` function.
+
+        See also
+        --------
+        :func:`otp.math.round <onetick.py.math.round>`
+        :func:`otp.math.floor <onetick.py.math.floor>`
+        :func:`otp.math.ceil <onetick.py.math.ceil>`
+
         Parameters
         ----------
         precision: int
             Number from -12 to 12.
             Positive precision is precision after the floating point.
-            Negative precision is precision before the floating point.
+            Negative precision is precision before the floating point (and the fraction part is dropped in this case).
 
         Examples
         --------
-        >>> t = otp.Tick(A=1234.5678)
-        >>> t['B'] = round(t['A'])
-        >>> t['C'] = round(t['A'], 2)
-        >>> t['D'] = round(t['A'], -2)
+
+        By default the ``precision`` is zero and the number is rounded to the closest integer number
+        (and to the bigger number when the fraction part of value is exactly 0.5):
+
+        >>> t = otp.Ticks(A=[-123.45, 123.45, 123.5])
+        >>> t['ROUND'] = round(t['A'])
+        >>> otp.run(t)
+                             Time       A  ROUND
+        0 2003-12-01 00:00:00.000 -123.45 -123.0
+        1 2003-12-01 00:00:00.001  123.45  123.0
+        2 2003-12-01 00:00:00.002  123.50  124.0
+
+        Positive precision truncates to the number of digits *after* floating point:
+
+        >>> t = otp.Ticks(A=[-123.45, 123.45])
+        >>> t['ROUND1'] = round(t['A'], 1)
+        >>> t['ROUND2'] = round(t['A'], 2)
+        >>> otp.run(t)
+                             Time       A  ROUND1  ROUND2
+        0 2003-12-01 00:00:00.000 -123.45  -123.4 -123.45
+        1 2003-12-01 00:00:00.001  123.45   123.5  123.45
+
+        Negative precision truncates to the number of digits *before* floating point
+        (and the fraction part is dropped in this case):
+
+        >>> t = otp.Ticks(A=[-123.45, 123.45])
+        >>> t['ROUND_M1'] = round(t['A'], -1)
+        >>> t['ROUND_M2'] = round(t['A'], -2)
+        >>> otp.run(t)
+                             Time       A  ROUND_M1  ROUND_M2
+        0 2003-12-01 00:00:00.000 -123.45    -120.0    -100.0
+        1 2003-12-01 00:00:00.001  123.45     120.0     100.0
+
+        Rounding :class:`otp.nan <onetick.py.nan>` returns NaN
+        and rounding :class:`otp.inf <onetick.py.inf>` returns Infinity in all cases:
+
+        >>> t = otp.Ticks(A=[otp.inf, -otp.inf, otp.nan])
+        >>> t['ROUND_0'] = round(t['A'])
+        >>> t['ROUND_P2'] = round(t['A'], 2)
+        >>> t['ROUND_M2'] = round(t['A'], -2)
         >>> otp.run(t)
-                Time          A     B        C       D
-        0 2003-12-01  1234.5678  1235  1234.57  1200.0
+                             Time    A  ROUND_0  ROUND_P2  ROUND_M2
+        0 2003-12-01 00:00:00.000  inf      inf       inf       inf
+        1 2003-12-01 00:00:00.001 -inf     -inf      -inf      -inf
+        2 2003-12-01 00:00:00.002  NaN      NaN       NaN       NaN
 
         Returns
         -------
         Operation
         """
+        if precision is None:
+            precision = 0
         return _Operation(_methods.round, [self, precision])
 
     def __neg__(self):

onetick/py/core/multi_output_source.py

@@ -1,3 +1,4 @@
+from onetick import py as otp
 from onetick.py import configuration
 from onetick.py.otq import otq
 
@@ -94,8 +95,8 @@ class MultiOutputSource:
         # we create a set of keys for all outputs and see if all sets are connected;
         # two sets are connected if they have any key in common
 
-        if len(outputs) <= 1:
-            raise ValueError('At least two branches should be passed to a MultiOutputSource object')
+        if len(outputs) < 1:
+            raise ValueError('At least one branch should be passed to a MultiOutputSource object')
 
         def get_history_key_set(hist):
             keys = set()
@@ -155,6 +156,41 @@ class MultiOutputSource:
     def _side_branch_list(self):
         return list(self.__side_branches.values())
 
+    def get_branch(self, branch_name: str) -> otp.Source:
+        """
+        Retrieve a branch by its name.
+
+        Parameters
+        ----------
+        branch_name : str
+            The name of the branch to retrieve.
+
+        Returns
+        -------
+        otp.Source
+            The branch corresponding to the given name.
+        """
+        if branch_name == self.__main_branch_name:
+            return self.__main_branch
+
+        branch = self.__side_branches.get(branch_name)
+        if branch is None:
+            raise ValueError(f'Branch name "{branch_name}" not found among the outputs!')
+
+        return branch
+
+    @property
+    def main_branch(self) -> otp.Source:
+        """
+        Get the main branch.
+
+        Returns
+        -------
+        otp.Source
+            The main branch.
+        """
+        return self.__main_branch
+
     def _prepare_for_execution(self, symbols=None, start=None, end=None, start_time_expression=None,
                                end_time_expression=None, timezone=None,
                                has_output=None,  # NOSONAR
@@ -191,3 +227,6 @@ class MultiOutputSource:
                                          end=end,
                                          timezone=timezone,
                                          add_passthrough=False)
+
+    def _store_in_tmp_otq(self, *args, **kwargs):
+        return self.main_branch._store_in_tmp_otq(*args, **kwargs)

onetick/py/db/db.py

@@ -110,8 +110,8 @@ def write_to_db(src: 'otp.Source',
     if timezone is None:
         timezone = configuration.config.tz
     if date is None or date is otp.adaptive:
-        kwargs['start'] = start
-        kwargs['end'] = end
+        kwargs['start_date'] = start
+        kwargs['end_date'] = end
     else:
         kwargs['date'] = date
 

onetick/py/functions.py

@@ -2033,7 +2033,13 @@ def _add_element(cur_res, element, format_spec_additional=None):
         elif issubclass(element.dtype, float) and re.fullmatch(r'\.\d+f', format_spec_additional):
             # float has strange behavior when precision=0
             decimal_elem = element.apply(ott.decimal)
-            cur_res += decimal_elem.decimal.str(re.findall(r'\d+', format_spec_additional)[0])
+            precision_str = re.findall(r'\d+', format_spec_additional)[0]
+            try:
+                precision = int(precision_str)
+            except ValueError as exc:
+                raise ValueError('Incorrect value for `precision` for formatting decimal number') from exc
+
+            cur_res += decimal_elem.decimal.str(precision)
         elif issubclass(element.dtype, (ott.nsectime, ott.msectime)):
             cur_res += element.dt.strftime(format_spec_additional)
         else:

onetick/py/math.py

@@ -760,7 +760,12 @@ def gcd(value1, value2):
 
 def floor(value):
     """
-    Returns a long integer value representing the largest integer that is less than or equal to the ``value``.
+    Returns a float value representing the largest number that is less than or equal to the ``value``.
+
+    Note
+    ----
+    Rounding :class:`otp.nan <onetick.py.nan>` returns NaN
+    and rounding :class:`otp.inf <onetick.py.inf>` returns Infinity.
 
     Parameters
     ----------
@@ -772,29 +777,41 @@ def floor(value):
 
     Examples
     --------
-    >>> data = otp.Ticks(A=[-1.7, -1.5, -1.2, -1, 0 , 1, 1.2, 1.5, 1.7])
+    >>> data = otp.Ticks(A=[-1.7, -1.5, -1.2, -1, 0 , 1, 1.2, 1.5, 1.7, -otp.inf, otp.inf, otp.nan])
     >>> data['FLOOR'] = otp.math.floor(data['A'])
     >>> otp.run(data)
-                         Time    A  FLOOR
-    0 2003-12-01 00:00:00.000 -1.7     -2
-    1 2003-12-01 00:00:00.001 -1.5     -2
-    2 2003-12-01 00:00:00.002 -1.2     -2
-    3 2003-12-01 00:00:00.003 -1.0     -1
-    4 2003-12-01 00:00:00.004  0.0      0
-    5 2003-12-01 00:00:00.005  1.0      1
-    6 2003-12-01 00:00:00.006  1.2      1
-    7 2003-12-01 00:00:00.007  1.5      1
-    8 2003-12-01 00:00:00.008  1.7      1
-    """
+                          Time     A  FLOOR
+    0  2003-12-01 00:00:00.000  -1.7   -2.0
+    1  2003-12-01 00:00:00.001  -1.5   -2.0
+    2  2003-12-01 00:00:00.002  -1.2   -2.0
+    3  2003-12-01 00:00:00.003  -1.0   -1.0
+    4  2003-12-01 00:00:00.004   0.0    0.0
+    5  2003-12-01 00:00:00.005   1.0    1.0
+    6  2003-12-01 00:00:00.006   1.2    1.0
+    7  2003-12-01 00:00:00.007   1.5    1.0
+    8  2003-12-01 00:00:00.008   1.7    1.0
+    9  2003-12-01 00:00:00.009  -inf   -inf
+    10 2003-12-01 00:00:00.010   inf    inf
+    11 2003-12-01 00:00:00.011   NaN    NaN
+    """
+    def fun(v):
+        v = value2str(v)
+        return f'CASE({v}, NAN(), NAN(), INFINITY(), INFINITY(), -INFINITY(), -INFINITY(), FLOOR({v}) * 1.0)', float
+
     return _Operation(
-        op_func=lambda v: (f'FLOOR({value2str(v)})', int),
+        op_func=fun,
         op_params=[value],
     )
 
 
 def ceil(value):
     """
-    Returns a long integer value representing the smallest integer that is greater than or equal to the ``value``.
+    Returns a float value representing the smallest number that is greater than or equal to the ``value``.
+
+    Note
+    ----
+    Rounding :class:`otp.nan <onetick.py.nan>` returns NaN
+    and rounding :class:`otp.inf <onetick.py.inf>` returns Infinity.
 
     Parameters
     ----------
@@ -806,21 +823,113 @@ def ceil(value):
 
     Examples
     --------
-    >>> data = otp.Ticks(A=[-1.7, -1.5, -1.2, -1, 0 , 1, 1.2, 1.5, 1.7])
+    >>> data = otp.Ticks(A=[-1.7, -1.5, -1.2, -1, 0 , 1, 1.2, 1.5, 1.7, -otp.inf, otp.inf, otp.nan])
     >>> data['CEIL'] = otp.math.ceil(data['A'])
     >>> otp.run(data)
-                         Time    A  CEIL
-    0 2003-12-01 00:00:00.000 -1.7    -1
-    1 2003-12-01 00:00:00.001 -1.5    -1
-    2 2003-12-01 00:00:00.002 -1.2    -1
-    3 2003-12-01 00:00:00.003 -1.0    -1
-    4 2003-12-01 00:00:00.004  0.0     0
-    5 2003-12-01 00:00:00.005  1.0     1
-    6 2003-12-01 00:00:00.006  1.2     2
-    7 2003-12-01 00:00:00.007  1.5     2
-    8 2003-12-01 00:00:00.008  1.7     2
-    """
+                          Time     A  CEIL
+    0  2003-12-01 00:00:00.000  -1.7  -1.0
+    1  2003-12-01 00:00:00.001  -1.5  -1.0
+    2  2003-12-01 00:00:00.002  -1.2  -1.0
+    3  2003-12-01 00:00:00.003  -1.0  -1.0
+    4  2003-12-01 00:00:00.004   0.0   0.0
+    5  2003-12-01 00:00:00.005   1.0   1.0
+    6  2003-12-01 00:00:00.006   1.2   2.0
+    7  2003-12-01 00:00:00.007   1.5   2.0
+    8  2003-12-01 00:00:00.008   1.7   2.0
+    9  2003-12-01 00:00:00.009  -inf  -inf
+    10 2003-12-01 00:00:00.010   inf   inf
+    11 2003-12-01 00:00:00.011   NaN   NaN
+    """
+    def fun(v):
+        v = value2str(v)
+        return f'CASE({v}, NAN(), NAN(), INFINITY(), INFINITY(), -INFINITY(), -INFINITY(), CEIL({v}) * 1.0)', float
+
     return _Operation(
-        op_func=lambda v: (f'CEIL({value2str(v)})', int),
+        op_func=fun,
         op_params=[value],
     )
+
+
+def round(value, precision=0, rounding_method='upward'):
+    """
+    Rounds value with specified ``precision`` and ``rounding_method``.
+
+    Rounding :class:`otp.nan <onetick.py.nan>` returns NaN
+    and rounding :class:`otp.inf <onetick.py.inf>` returns Infinity.
+
+    Parameters
+    ----------
+    precision: int
+        Number from -12 to 12.
+        Positive precision is precision after the floating point.
+        Negative precision is precision before the floating point (and the fraction part is dropped in this case).
+    rounding_method: str
+        Used for values that are exactly half-way between two integers (when the fraction part of value is exactly 0.5).
+        Available values are **upward**, **downward**, **towards_zero**, **away_from_zero**.
+        Default is **upward**.
+
+    Examples
+    --------
+
+    Different rounding methods produce different results for values that are exactly half-way between two integers:
+
+    >>> t = otp.Ticks(A=[-123.45, 123.45, -123.4, 123.6])
+    >>> t['UPWARD'] = otp.math.round(t['A'], precision=1, rounding_method='upward')
+    >>> t['DOWNWARD'] = otp.math.round(t['A'], precision=1, rounding_method='downward')
+    >>> t['TOWARDS_ZERO'] = otp.math.round(t['A'], precision=1, rounding_method='towards_zero')
+    >>> t['AWAY_FROM_ZERO'] = otp.math.round(t['A'], precision=1, rounding_method='away_from_zero')
+    >>> otp.run(t).head(2)
+                         Time       A  UPWARD  DOWNWARD  TOWARDS_ZERO  AWAY_FROM_ZERO
+    0 2003-12-01 00:00:00.000 -123.45  -123.4    -123.5        -123.4          -123.5
+    1 2003-12-01 00:00:00.001  123.45   123.5     123.4         123.4           123.5
+
+    Note that for other cases all methods produce the same results:
+
+    >>> otp.run(t).tail(2)
+                         Time      A  UPWARD  DOWNWARD  TOWARDS_ZERO  AWAY_FROM_ZERO
+    2 2003-12-01 00:00:00.002 -123.4  -123.4    -123.4        -123.4          -123.4
+    3 2003-12-01 00:00:00.003  123.6   123.6     123.6         123.6           123.6
+
+    Positive precision truncates to the number of digits *after* floating point:
+
+    >>> t = otp.Ticks(A=[-123.45, 123.45])
+    >>> t['ROUND1'] = otp.math.round(t['A'], 1)
+    >>> t['ROUND2'] = otp.math.round(t['A'], 2)
+    >>> otp.run(t)
+                            Time       A  ROUND1  ROUND2
+    0 2003-12-01 00:00:00.000 -123.45  -123.4 -123.45
+    1 2003-12-01 00:00:00.001  123.45   123.5  123.45
+
+    Negative precision truncates to the number of digits *before* floating point
+    (and the fraction part is dropped in this case):
+
+    >>> t = otp.Ticks(A=[-123.45, 123.45])
+    >>> t['ROUND_M1'] = otp.math.round(t['A'], -1)
+    >>> t['ROUND_M2'] = otp.math.round(t['A'], -2)
+    >>> otp.run(t)
+                            Time       A  ROUND_M1  ROUND_M2
+    0 2003-12-01 00:00:00.000 -123.45    -120.0    -100.0
+    1 2003-12-01 00:00:00.001  123.45     120.0     100.0
+
+    Rounding :class:`otp.nan <onetick.py.nan>` returns NaN
+    and rounding :class:`otp.inf <onetick.py.inf>` returns Infinity in all cases:
+
+    >>> t = otp.Ticks(A=[otp.inf, -otp.inf, otp.nan])
+    >>> t['ROUND_0'] = otp.math.round(t['A'])
+    >>> t['ROUND_P2'] = otp.math.round(t['A'], 2)
+    >>> t['ROUND_M2'] = otp.math.round(t['A'], -2)
+    >>> otp.run(t)
+                         Time    A  ROUND_0  ROUND_P2  ROUND_M2
+    0 2003-12-01 00:00:00.000  inf      inf       inf       inf
+    1 2003-12-01 00:00:00.001 -inf     -inf      -inf      -inf
+    2 2003-12-01 00:00:00.002  NaN      NaN       NaN       NaN
+    """
+    if not -12 <= precision <= 12:
+        raise ValueError("Parameter 'precision' must be an integer in range [-12, 12]")
+    supported_rounding_methods = {'upward', 'downward', 'towards_zero', 'away_from_zero'}
+    if rounding_method not in supported_rounding_methods:
+        raise ValueError(f"Parameter 'rounding_method' must be one of {supported_rounding_methods}")
+    return _Operation(
+        op_func=lambda v, p, r: (f'ROUND_DOUBLE({value2str(v)},{value2str(p)},{value2str(r)})', float),
+        op_params=[value, precision, rounding_method],
+    )

{onetick_py-1.171.0.dist-info → onetick_py-1.172.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onetick-py
-Version: 1.171.0
+Version: 1.172.0
 Summary: Python package that allows you to work with OneTick
 Author-email: solutions <solutions@onetick.com>
 License-Expression: MIT
@@ -85,7 +85,7 @@ The latest version of ``onetick-py`` is available on PyPI: <https://pypi.org/pro
 
     pip install onetick-py[webapi]
 
-Use ``webapi`` extra to easily use it with remote OneTick Cloud server.
+Use ``webapi`` extra to easily use it with remote OneTick REST Servers, such as [OneTick Cloud](https://www.onetick.com/cloud-services).
 
 See [Getting Started](https://docs.pip.distribution.sol.onetick.com/static/getting_started/root.html)
 section in the documentation to see how quickly set up ``onetick-py`` configuration
@@ -112,6 +112,8 @@ section in the documentation.
 - **Data Visualization**: Compatible with OneTick's visualization tool, OneTick Dashboard.
 - **Machine Learning**: Integrates with the OneTick ML library [onetick-ml](https://dsframework.pip.distribution.sol.onetick.com/intro.html).
 - **Industry Applications**: Industry leading OneTick's Trade Surveillance and BestEx/TCA solutions are written in ``onetick.py``.
+- **Back Testing**: Retrieve historic market data and metrics.
+- **Market Microstructure**:  Consolidated Book Depth analysis.
 
 ## Advantages Over Competitors
 

{onetick_py-1.171.0.dist-info → onetick_py-1.172.0.dist-info}/RECORD

@@ -13,15 +13,15 @@ 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=R6vgYKh_qtyxN49H_qTnzUglwwB5_XMe8UEeYU-DvfM,76
+onetick/py/_version.py,sha256=7nbtSF9w76mnK4B_3vuXM8dDMY1zw1fS3UowT04mTiE,76
 onetick/py/backports.py,sha256=mR00mxe7E7UgBljf-Wa93Mo6lpi-C4Op561uhPUoEt8,815
 onetick/py/cache.py,sha256=BBZg8n0AGjZzZapg4752LkSZdX5C6DGf7vU9sAStv6A,12798
 onetick/py/compatibility.py,sha256=x-TXsOqPNb2gnARSDwyZba-1FE7bvuat2vrObRCSywo,30917
 onetick/py/configuration.py,sha256=cMUl6XNjO3qgpO5PmOplb2uFSAQtWPu7pIUNhhRpjL4,28408
-onetick/py/functions.py,sha256=LyLQ7NTNFzKfkR3A5RazS3tOtVqORe1BPrg6B4AAuLM,97689
+onetick/py/functions.py,sha256=yJKL4thjNh_u-DKY08rCDMGJO_IMAeN2Odu70Q9U3Ew,97937
 onetick/py/license.py,sha256=50dsFrE-NKsPOdkAoyxHr44bH8DzFCr_6TabX0JH6tQ,6140
 onetick/py/log.py,sha256=Els2drZcVjJrD6kvbwgFGEpg6jAacoUEtyN6rCaauuk,2723
-onetick/py/math.py,sha256=LcbVcmW6GJHcjJJiPNZe5Mh5ZJBpdC8AxJMltMA1Apk,21357
+onetick/py/math.py,sha256=MZvlyUjxOWGJvmxK8pfMkCr4THM52AE6NyGEidgDMyE,26311
 onetick/py/misc.py,sha256=mD-EJslLGjQ0ROEez76HvOY0tsX8_1bC1QOkyHY9FZ8,13934
 onetick/py/otq.py,sha256=VSdCrp3zTzNQHv9gM_xE4Al4ujBsio7uWk3SqU4eC4Y,8271
 onetick/py/pyomd_mock.py,sha256=A7IIUraN9yCsPhvnHXQUZrmwFjlh7vofSnYm4G7bdsc,2006
@@ -51,7 +51,7 @@ onetick/py/core/cut_builder.py,sha256=rj5aPJ25Dr5fsd9Dw1SO8k9kPGy0hV06anxFqBppFW
 onetick/py/core/db_constants.py,sha256=OqBbBKLECf8Bw8ylw30jc72xgCJ0gRIC-K-QkkbQ4LI,437
 onetick/py/core/eval_query.py,sha256=mcsOVlQ2vNSfZ-tRUB2z1gdiMJw4MpU2fK2hW-ua3e4,11528
 onetick/py/core/lambda_object.py,sha256=ayob_2c2XYSG7vFsqp-2b9FSPD-3TFReLbx3de3tkqE,16812
-onetick/py/core/multi_output_source.py,sha256=i9mxtM3yIF30hsVZ-6XttU407VmHklCdPjNDabgB374,7769
+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
@@ -88,23 +88,23 @@ onetick/py/core/_source/source_methods/sorts.py,sha256=tDFt3rObNHP-S_HOtDd6SLpgk
 onetick/py/core/_source/source_methods/switches.py,sha256=pcnfT45QWn87qq1pWkvZbqeEoM7lrq8qNPxM8g9raxs,3846
 onetick/py/core/_source/source_methods/symbols.py,sha256=MG0dgVVVJ6fD_-GJkkXEgTeAsfS79ymJWmuKSL-0QSs,3968
 onetick/py/core/_source/source_methods/times.py,sha256=2kbLHG-3RQM6uWmw8pBGDiAz4R83KK46Tp1smTY6SR8,27665
-onetick/py/core/_source/source_methods/writes.py,sha256=W00hAJtQ0phPv5vzS08rSj_N0-ofhih39DalpR8RntQ,42129
+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=ihNaKhhDFk7-v-wpXE11Wqy0WAqEGI1OC2PG4POK1mc,33203
+onetick/py/core/column_operations/base.py,sha256=Kcwfd4PErCGLSbkqtFKY6SZL1-pksWHB-Pc-5A8I3WM,36135
 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/methods.py,sha256=-zl2gg7rGtsbxnfoSoMIvg3Pjanxwlijrd1RJflu3Nw,11157
+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/accessors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onetick/py/core/column_operations/accessors/_accessor.py,sha256=GJtqxDNzve6TM8ESJp0gzhSqfKPUYA7_vvLKFO1_rAA,1001
-onetick/py/core/column_operations/accessors/decimal_accessor.py,sha256=7B-h932PhUmUV3flAAvPpKeVR7BbaESwSPyBTkxdxoI,2930
-onetick/py/core/column_operations/accessors/dt_accessor.py,sha256=RvgIuCXs3nMXTNqJvP0Iqu7i_vUoUDgrG7QvfnrKvRs,16837
-onetick/py/core/column_operations/accessors/float_accessor.py,sha256=6di5Pw0nLwKEqnzQImzQ9ORv45xGm-uevFGCg-FZz4w,5541
-onetick/py/core/column_operations/accessors/str_accessor.py,sha256=65WdZQWayVy8HEh7xn5M3j08AO_fTJ5vSU8CyxNmOrY,55519
+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
+onetick/py/core/column_operations/accessors/dt_accessor.py,sha256=UeY7UNUiaLdrX0S68SuEk7gXASGCjJoRdTq0pm30ktQ,18616
+onetick/py/core/column_operations/accessors/float_accessor.py,sha256=IjZNrUzdT_u1szJFOI5ivExbvzC5KwiHwz6CFMMZRo0,5994
+onetick/py/core/column_operations/accessors/str_accessor.py,sha256=kpCQQQJd02yWsTVwkAMYBfJMTePSffzDiT-6utRqNB4,55248
 onetick/py/db/__init__.py,sha256=-TKRO0suXTR-mLAppYt-Vegu9HQn7LU_JcObXpS3N9M,61
 onetick/py/db/_inspection.py,sha256=oBd5XAk2RGHad7KpS62Ftwlmqx96EUxIFYCbZ-Qyt94,48288
-onetick/py/db/db.py,sha256=nlkwQ0cDo2T7am4stNbbP_5NVDWD-nOIcoWYFVzr-_w,55920
+onetick/py/db/db.py,sha256=3K1X9RQ2ObXGxyxSi-jSSl6b7p0OuGZJJkx9SGzkBsc,55930
 onetick/py/db/utils.py,sha256=gt-KmbGgcp1tH81LH-cLO08n2Hx8GaBPbvfEN22mgLg,2309
 onetick/py/docs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onetick/py/docs/docstring_parser.py,sha256=j38L1jO1JFAzYqR1F5hilIzcIjOWILqNQSB25Fd2hhM,3695
@@ -144,9 +144,9 @@ onetick/py/utils/script.py,sha256=Y8NujEo2_5QaP6KDnLKJiKQ7SmMjw8_dv8sYL9rHDCE,11
 onetick/py/utils/temp.py,sha256=j-BC155dE46k0zfKTTs26KTF0CK6WA1hO2GD54iunyM,17380
 onetick/py/utils/types.py,sha256=_tYf66r9JVgjtiCJfxIxrg_BQEjHkjlnck_i86dBYEY,3606
 onetick/py/utils/tz.py,sha256=QXclESLGU8YXysUT9DXkcBqLWWO47Bb_tanFUzYpPZI,2800
-onetick_py-1.171.0.dist-info/licenses/LICENSE,sha256=Yhu7lKNFS0fsaN-jSattEMRtCOPueP58Eu5BPH8ZGjM,1075
-onetick_py-1.171.0.dist-info/METADATA,sha256=xbh4fMhGnAy3uBraumRUWLE9ynOdvCc-sWefGxlcCjg,8024
-onetick_py-1.171.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onetick_py-1.171.0.dist-info/entry_points.txt,sha256=QmK_tFswIN-SQRmtnTSBEi8GvT0TVq-66IzXXZIsV3U,81
-onetick_py-1.171.0.dist-info/top_level.txt,sha256=Na1jSJmVMyYGOndaswt554QKIUwQjcYh6th2ATsmw0U,23
-onetick_py-1.171.0.dist-info/RECORD,,
+onetick_py-1.172.0.dist-info/licenses/LICENSE,sha256=Yhu7lKNFS0fsaN-jSattEMRtCOPueP58Eu5BPH8ZGjM,1075
+onetick_py-1.172.0.dist-info/METADATA,sha256=NOHCPlqgp-lzXlGekA1oDazmitCNBSoDrhnqlgkjOrg,8216
+onetick_py-1.172.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onetick_py-1.172.0.dist-info/entry_points.txt,sha256=QmK_tFswIN-SQRmtnTSBEi8GvT0TVq-66IzXXZIsV3U,81
+onetick_py-1.172.0.dist-info/top_level.txt,sha256=Na1jSJmVMyYGOndaswt554QKIUwQjcYh6th2ATsmw0U,23
+onetick_py-1.172.0.dist-info/RECORD,,