onetick-py 1.171.0__py3-none-any.whl → 1.173.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.173.0'

onetick/py/compatibility.py

@@ -3,6 +3,7 @@ import warnings
 from dataclasses import dataclass, astuple
 from datetime import datetime
 from typing import Optional
+
 from packaging.version import parse as parse_version
 
 import onetick.py as otp
@@ -416,14 +417,15 @@ def is_odbc_query_supported():
 
 
 def is_event_processor_repr_upper():
-    return _is_min_build_or_version(None, None,
-                                    20240205120000, min_update_number=0) or otq.webapi
+    if otq.webapi:
+        return True
+    return _is_min_build_or_version(1.25, None,
+                                    20240205120000, min_update_number=0)
 
 
 def is_date_trunc_fixed():
-    # tests/core/accessors/test_dt.py::TestDateTrunc::test_dst_year
-    # this test will show, when release fixes the issue
-    return _is_min_build_or_version(None, None,
+    # Fixed 0032253: DATE_TRUNC function returns wrong answer in case of daylight saving time
+    return _is_min_build_or_version(1.25, None,
                                     20240205120000, min_update_number=0)
 
 
@@ -511,7 +513,8 @@ def is_duplicating_quotes_not_supported():
     # 20240329: Fixed 0032754:
     # Logical expressions should trigger error when duplicate single(or double) quote
     # is directly followed or preceded by some name
-    return _is_min_build_or_version(None, None, 20240330120000)
+    return _is_min_build_or_version(1.25, None,
+                                    20240330120000)
 
 
 def are_quotes_in_query_params_supported():
@@ -681,9 +684,9 @@ def is_ob_virtual_prl_and_show_full_detail_supported():
 
 
 def is_per_tick_script_boolean_problem():
-    # strange problem, couldn't reproduce it anywhere except a single onetick build
+    # strange problem, couldn't reproduce it anywhere except a single onetick release
     version = get_onetick_version()
-    return version.release_version == '1.22' and version.build_number in (20220815034358, 20220128183755)
+    return version.release_version == '1.22'
 
 
 def is_symbol_time_override_fixed():
@@ -709,8 +712,10 @@ def is_native_plus_zstd_supported():
 
 def is_save_snapshot_database_parameter_supported():
     # 20220929: Implemented 0028559: Update SAVE_SNAPSHOT to specify output database
-    return _is_min_build_or_version(1.23, 20230605193357,
-                                    20221111120000)
+    client_support = 'database' in otq.SaveSnapshot.Parameters.list_parameters()
+    server_support = _is_min_build_or_version(1.23, 20230605193357,
+                                              20221111120000)
+    return client_support and server_support
 
 
 def is_join_with_snapshot_snapshot_fields_parameter_supported():

onetick/py/configuration.py

@@ -656,8 +656,9 @@ class Config:
     )
 
     max_expected_ticks_per_symbol = OtpProperty(
-        description='Expected maximum number of ticks per symbol (used for performance optimizations).',
-        base_default=2000,
+        description='Expected maximum number of ticks per symbol (used for performance optimizations). '
+                    'Default is 2000.',
+        base_default=None,
         allowed_types=int,
         env_var_name='OTP_MAX_EXPECTED_TICKS_PER_SYMBOL',
     )

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/_source/symbol.py

@@ -35,7 +35,7 @@ class SymbolType:
         | :ref:`api/misc/symbol_param:Symbol Parameters Objects`
         """
 
-        self._name = _SymbolParamColumn("_SYMBOL_NAME", str)
+        self.__name = _SymbolParamColumn("_SYMBOL_NAME", str)
 
     @property
     def name(self):
@@ -61,7 +61,7 @@ class SymbolType:
         4 2003-12-01 00:00:00.002  3          S1
         5 2003-12-01 00:00:00.002 -1          S2
         """
-        return self._name
+        return self.__name
 
     def get(self, name, dtype, default=None):
         """
@@ -131,6 +131,9 @@ class SymbolType:
         -------
         _SymbolParamColumn
         """
+        if item == '__objclass__':
+            # fix for PY-1399 (some inspect functions try to access this special attribute)
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{item}'")
         if not item.startswith('_') and item != 'pytest_mock_example_attribute_that_shouldnt_exist':
             warnings.warn("`__getattr__` method is deprecated. Please, use `__getitem__` method instead.",
                           FutureWarning, stacklevel=2)

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,
         )