onetick-py 1.174.0__tar.gz → 1.176.0__tar.gz

{onetick_py-1.174.0/src/onetick_py.egg-info → onetick_py-1.176.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onetick-py
-Version: 1.174.0
+Version: 1.176.0
 Summary: Python package that allows you to work with OneTick
 Author-email: solutions <solutions@onetick.com>
 License-Expression: MIT

{onetick_py-1.174.0 → onetick_py-1.176.0}/src/onetick/py/_version.py

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

{onetick_py-1.174.0 → onetick_py-1.176.0}/src/onetick/py/aggregations/order_book.py

@@ -147,6 +147,7 @@ class _OrderBookAggregation(_Aggregation, ABC):
         self.book_uncross_method = book_uncross_method
         self.dq_events_that_clear_book = ','.join(dq_events_that_clear_book) if dq_events_that_clear_book else None
         self.bound_symbols = None
+        self._validate_ob_input_columns = True
 
         super().__init__(_Column('TIMESTAMP'), *args, **kwargs)
 
@@ -163,8 +164,15 @@ class _OrderBookAggregation(_Aggregation, ABC):
             raise ValueError("'bucket_units' can be one of the following: "
                              f"'{', '.join(valid_units)}'; however, '{self.bucket_units}' was passed")
 
+    def disable_ob_input_columns_validation(self):
+        self._validate_ob_input_columns = False
+
     def validate_input_columns(self, src: 'Source'):
         super().validate_input_columns(src)
+
+        if not self._validate_ob_input_columns:
+            return
+
         if any([
             not {'BUY_SELL_FLAG', 'PRICE', 'SIZE'}.issubset(src.schema),
             'UPDATE_TIME' not in src.schema and 'DELETED_TIME' not in src.schema

{onetick_py-1.174.0 → onetick_py-1.176.0}/src/onetick/py/compatibility.py

@@ -779,3 +779,13 @@ def is_show_db_list_show_description_supported():
     # However on 20240330 builds it returns SHOW_DESCRIPTION column instead of DESCRIPTION
     return _is_min_build_or_version(1.25, 20241229055942,
                                     20240501000000)
+
+
+def is_symbols_prepend_db_name_supported():
+    # 20250924: Implemented 0036753: FIND_DB_SYMBOLS should have EP parameter PREPEND_DB_NAME (true by default)
+    return hasattr(otq.FindDbSymbols.Parameters, 'prepend_db_name')
+
+
+def is_diff_show_all_ticks_supported():
+    # 20250919: Implemented 0036784: Add SHOW_ALL_TICKS(false by default) ep parameter to DIFF EP.
+    return hasattr(otq.Diff.Parameters, 'show_all_ticks')

{onetick_py-1.174.0 → onetick_py-1.176.0}/src/onetick/py/core/_source/source_methods/joins.py

@@ -104,7 +104,12 @@ def _columns_to_params_for_joins(columns, query_params=False):
                     get_msecs_expression(value) + "+'.'+SUBSTR(NSECTIME_FORMAT('%J'," + str(value) + ",_TIMEZONE),3,6)"
                 )
         else:
-            convert_rule += "tostring(" + str(value) + ")"
+            if issubclass(dtype, float) or dtype is otp.decimal:
+                warnings.warn(f"Parameter '{key}' is of {dtype} type.\n"
+                              "Parameters passed to query will have to be converted to string"
+                              " so the precision may be lost (default precision of 8 will be used).\n"
+                              "Use other types like integers or strings to pass parameters with higher precision.")
+            convert_rule += "tostring(" + ott.value2str(value) + ")"
         params_list.append(convert_rule)
     return "+','+".join(params_list)
 

{onetick_py-1.174.0 → onetick_py-1.176.0}/src/onetick/py/core/_source/source_methods/merges.py

@@ -16,6 +16,7 @@ from onetick.py.aggregations._docs import (
 )
 from onetick.py.docs.utils import docstring, param_doc
 from onetick.py.aggregations._base import _Aggregation
+from onetick.py.compatibility import is_diff_show_all_ticks_supported
 
 
 if TYPE_CHECKING:
@@ -51,6 +52,7 @@ def diff(self: 'Source', other: 'Source',
          output_ignored_fields: Optional[bool] = None,
          show_only_fields_that_differ: Optional[bool] = None,
          show_matching_ticks: Optional[bool] = None,
+         show_all_ticks: bool = False,
          non_decreasing_value_fields: Optional[Union[str, List[str]]] = None,
          threshold: Optional[int] = None,
          left_prefix: str = 'L',
@@ -97,6 +99,15 @@ def diff(self: 'Source', other: 'Source',
         instead of unmatched ticks.
         The output tick timestamp is equal to the earliest timestamp of its corresponding input ticks.
         Default value is False.
+    show_all_ticks: bool
+        If specified, the output of this EP consists of both matched and unmatched ticks from both input time series.
+        ``MATCH_STATUS`` field will be added to the output tick with the possible values of:
+
+        * ``0`` - different ticks
+        * ``1`` - matching ticks
+        * ``2`` - tick from one source only
+
+        Default: ``False``
     non_decreasing_value_fields:
         List of *non-decreasing* value fields to be used for matching.
         If value of this parameter is **TIMESTAMP** (default), it compares two time series based on tick timestamp.
@@ -170,6 +181,24 @@ def diff(self: 'Source', other: 'Source',
        1 2003-12-01 00:00:01    1    3    1    4
        2 2003-12-01 00:00:02    1    4    1    6
        3 2003-12-01 00:00:02    1    5    1    7
+
+    Showing diff for every tick with ``show_all_ticks`` parameter:
+
+    .. testcode::
+       :skipif: not otp.compatibility.is_diff_show_all_ticks_supported()
+
+       t = otp.Ticks(A=[1, 2, 3], B=[0, 0, 1])
+       q = otp.Ticks(A=[1, 3], B=[0, 0])
+       data = t.diff(q, show_all_ticks=True)
+       print(otp.run(data))
+
+    .. testoutput::
+
+                            Time  MATCH_STATUS  L.A  R.A  L.B
+       0 2003-12-01 00:00:00.000             1    0    0    0
+       1 2003-12-01 00:00:00.001             0    2    3    0
+       2 2003-12-01 00:00:00.002             2    3    0    1
+
     """
 
     if not fields:
@@ -210,6 +239,13 @@ def diff(self: 'Source', other: 'Source',
         raise ValueError(
             "Parameters 'output_ignored_fields' and 'show_only_fields_that_differ' can't be set at the same time"
         )
+
+    if show_all_ticks:
+        if not is_diff_show_all_ticks_supported():
+            raise RuntimeError('`show_all_ticks` parameter not supported on current OneTick version')
+
+        ep_params['show_all_ticks'] = show_all_ticks
+
     if show_only_fields_that_differ is None and output_ignored_fields is None:
         if ignore:
             ep_params['output_ignored_fields'] = True
@@ -241,6 +277,9 @@ def diff(self: 'Source', other: 'Source',
                 continue
             schema[f'{src_prefix}.{field}'] = dtype
 
+    if show_all_ticks:
+        schema['MATCH_STATUS'] = int
+
     result = otp.Source(
         node=otq.Diff(**ep_params),
         schema=schema,

{onetick_py-1.174.0 → onetick_py-1.176.0}/src/onetick/py/core/column_operations/accessors/float_accessor.py

@@ -37,29 +37,32 @@ class _FloatAccessor(_Accessor):
         Examples
         --------
 
-        >>> data = otp.Ticks(X=[1, 2.17, 10.31861, 3.141593])
+        >>> data = otp.Ticks(X=[1, 2.17, 10.31861, 3.141593, otp.nan, otp.inf, -otp.inf])
         >>> # OTdirective: snippet-name: float operations.to string.constant precision;
-        >>> data["X"] = data["X"].float.str(15, 3)
-        >>> data = otp.run(data)
-        >>> data["X"]
-        0    1.000
-        1    2.170
-        2    10.319
-        3    3.142
-        Name: X, dtype: object
+        >>> data["Y"] = data["X"].float.str(15, 3)
+        >>> otp.run(data)
+                             Time          X       Y
+        0 2003-12-01 00:00:00.000   1.000000   1.000
+        1 2003-12-01 00:00:00.001   2.170000   2.170
+        2 2003-12-01 00:00:00.002  10.318610  10.319
+        3 2003-12-01 00:00:00.003   3.141593   3.142
+        4 2003-12-01 00:00:00.004        NaN     nan
+        5 2003-12-01 00:00:00.005        inf     inf
+        6 2003-12-01 00:00:00.006       -inf    -inf
+
+        Parameters ``length`` and ``precision`` can also be taken from the columns:
 
         >>> data = otp.Ticks(X=[1, 2.17, 10.31841, 3.141593],
         ...                  LENGTH=[2, 3, 4, 5],
         ...                  PRECISION=[5, 5, 3, 3])
         >>> # OTdirective: snippet-name: float operations.to string.precision from fields;
-        >>> data["X"] = data["X"].float.str(data["LENGTH"], data["PRECISION"])
-        >>> data = otp.run(data)
-        >>> data["X"]
-        0    1
-        1    2.2
-        2    10.3
-        3    3.142
-        Name: X, dtype: object
+        >>> data["Y"] = data["X"].float.str(data["LENGTH"], data["PRECISION"])
+        >>> otp.run(data)
+                             Time          X  LENGTH  PRECISION      Y
+        0 2003-12-01 00:00:00.000   1.000000       2          5      1
+        1 2003-12-01 00:00:00.001   2.170000       3          5    2.2
+        2 2003-12-01 00:00:00.002  10.318410       4          3   10.3
+        3 2003-12-01 00:00:00.003   3.141593       5          3  3.142
         """
         dtype = ott.string[length] if isinstance(length, int) else str
 
@@ -67,7 +70,10 @@ class _FloatAccessor(_Accessor):
             column = ott.value2str(column)
             _length = ott.value2str(_length)
             _precision = ott.value2str(_precision)
-            return f"str({column}, {_length}, {_precision})"
+            str_expr = f"str({column}, {_length}, {_precision})"
+            # BDS-478: str() function raises exception for nan and inf values, so converting them manually
+            str_expr = f'CASE({column}, NAN(), "nan", INFINITY(), "inf", -INFINITY(), "-inf", {str_expr})'
+            return str_expr
 
         return _FloatAccessor.Formatter(
             op_params=[self._base_column, length, precision],
@@ -108,15 +114,14 @@ class _FloatAccessor(_Accessor):
         ...                  OTHER=[1.01, 2.1, 10.32841, 3.14, 5],
         ...                  EPS=[0, 1, 0.1, 0.001, 0.001])
         >>> # OTdirective: snippet-name: float operations.approximate comparison.lt|eq|gt;
-        >>> data["X"] = data["X"].float.cmp(data["OTHER"], data["EPS"])
-        >>> data = otp.run(data)
-        >>> data["X"]
-        0   -1.0
-        1    0.0
-        2    0.0
-        3    0.0
-        4    1.0
-        Name: X, dtype: float64
+        >>> data["Y"] = data["X"].float.cmp(data["OTHER"], data["EPS"])
+        >>> otp.run(data)
+                             Time          X     OTHER    EPS    Y
+        0 2003-12-01 00:00:00.000   1.000000   1.01000  0.000 -1.0
+        1 2003-12-01 00:00:00.001   2.170000   2.10000  1.000  0.0
+        2 2003-12-01 00:00:00.002  10.318410  10.32841  0.100  0.0
+        3 2003-12-01 00:00:00.003   3.141593   3.14000  0.001  0.0
+        4 2003-12-01 00:00:00.004   6.000000   5.00000  0.001  1.0
         """
         def formatter(column, _other, _eps):
             column = ott.value2str(column)
@@ -157,15 +162,14 @@ class _FloatAccessor(_Accessor):
         ...                  OTHER=[1.01, 2.1, 10.32841, 3.14, 5],
         ...                  DELTA=[0, 1, 0.1, 0.01, 0.001])
         >>> # OTdirective: snippet-name: float operations.approximate comparison.eq;
-        >>> data["X"] = (1 + data["X"] - 1).float.eq(data["OTHER"], data["DELTA"])
-        >>> data = otp.run(data)
-        >>> data["X"]
-        0    0.0
-        1    1.0
-        2    1.0
-        3    1.0
-        4    0.0
-        Name: X, dtype: float64
+        >>> data["Y"] = (1 + data["X"] - 1).float.eq(data["OTHER"], data["DELTA"])
+        >>> otp.run(data)
+                             Time          X     OTHER  DELTA    Y
+        0 2003-12-01 00:00:00.000   1.000000   1.01000  0.000  0.0
+        1 2003-12-01 00:00:00.001   2.170000   2.10000  1.000  1.0
+        2 2003-12-01 00:00:00.002  10.318410  10.32841  0.100  1.0
+        3 2003-12-01 00:00:00.003   3.141593   3.14000  0.010  1.0
+        4 2003-12-01 00:00:00.004   6.000000   5.00000  0.001  0.0
         """
         def formatter(column, _other, _delta):
             column = ott.value2str(column)

{onetick_py-1.174.0 → onetick_py-1.176.0}/src/onetick/py/sources/order_book.py

@@ -58,6 +58,9 @@ class _ObSource(DataSource):
 
         self._ob_agg = self.__class__.OB_AGG_FUNC(**ob_agg_params)
 
+        if kwargs.get('schema_policy') in [DataSource.POLICY_MANUAL, DataSource.POLICY_MANUAL_STRICT]:
+            self._ob_agg.disable_ob_input_columns_validation()
+
         if use_bound_symbols:
             self._ob_agg.set_bound_symbols(symbols)
 

{onetick_py-1.174.0 → onetick_py-1.176.0}/src/onetick/py/sources/symbols.py

@@ -7,6 +7,7 @@ from onetick.py.core.source import Source
 from onetick.py.core.column_operations.base import Raw, OnetickParameter
 from onetick.py.core.eval_query import _QueryEvalWrapper
 from onetick.py.core._source.tmp_otq import TmpOtq
+from onetick.py.compatibility import is_symbols_prepend_db_name_supported
 
 from .. import types as ott
 from .. import utils
@@ -303,6 +304,9 @@ class Symbols(Source):
         _find_params.setdefault('symbology', symbology)
         _find_params.setdefault('show_original_symbols', show_original_symbols)
 
+        if 'prepend_db_name' in _find_params:
+            raise ValueError('Use parameter `keep_db` instead of passing `prepend_db_name` in `find_params`')
+
         if discard_on_match is not None:
             _find_params.setdefault('discard_on_match', discard_on_match)
         if cep_method is not None:
@@ -346,12 +350,16 @@ class Symbols(Source):
             self._tmp_otq.merge(_tmp_otq)
 
     def base_ep(self, ep_tick_type, keep_db, **params):
+        use_prepend_db_name = is_symbols_prepend_db_name_supported()
+        if use_prepend_db_name and not keep_db:
+            params['prepend_db_name'] = False
+
         src = Source(otq.FindDbSymbols(**params))
 
         update_node_tick_type(src, ep_tick_type)
         src.schema['SYMBOL_NAME'] = str
 
-        if not keep_db:
+        if not keep_db and not use_prepend_db_name:
             src["SYMBOL_NAME"] = src["SYMBOL_NAME"].str.regex_replace('.*::', '')
 
         return src

{onetick_py-1.174.0 → onetick_py-1.176.0}/src/onetick/py/types.py

@@ -807,9 +807,10 @@ class decimal:
         return super().__new__(cls)
 
     def __init__(self, value):
-        supported_types = (str, int, float)
+        from onetick.py.core.column_operations.base import OnetickParameter
+        supported_types = (str, int, float, OnetickParameter)
         if not isinstance(value, supported_types):
-            raise TypeError("Parameter 'value' must be one of these types: {supported_types}")
+            raise TypeError(f"Parameter 'value' must be one of these types: {supported_types}, got {type(value)}")
         self.__value = value
 
     @classmethod
@@ -819,7 +820,11 @@ class decimal:
 
     def _to_onetick_string(self):
         # called by ott.value2str
-        value = str(self.__value)
+        from onetick.py.core.column_operations.base import OnetickParameter
+        if isinstance(self.__value, OnetickParameter):
+            value = self.__value
+        else:
+            value = str(self.__value)
         return f'STRING_TO_DECIMAL({value2str(value)})'
 
     def to_operation(self):

{onetick_py-1.174.0 → onetick_py-1.176.0/src/onetick_py.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onetick-py
-Version: 1.174.0
+Version: 1.176.0
 Summary: Python package that allows you to work with OneTick
 Author-email: solutions <solutions@onetick.com>
 License-Expression: MIT