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

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/core/per_tick_script.py

@@ -1095,6 +1095,8 @@ class CaseExpressionParser(ExpressionParser):
             try:
                 return super().call(expr)
             except Exception:
+                if orig_err is not None:
+                    raise err from orig_err
                 raise ValueError(
                     f"Can't convert function '{astunparse(expr)}' to CASE() expression."
                 ) from err