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

onetick/py/__init__.py

@@ -214,9 +214,15 @@ from onetick.py.core.per_tick_script import (
 )
 from onetick.py.callback import CallbackBase
 from onetick.py.sql import SqlQuery
-from onetick.py.run import run
+from onetick.py.run import run, run_async
 from onetick.py.math import rand, now
-from onetick.py.misc import bit_and, bit_or, bit_at, bit_xor, bit_not, hash_code, get_symbology_mapping
+from onetick.py.misc import (
+    bit_and, bit_or, bit_at, bit_xor, bit_not,
+    hash_code,
+    get_symbology_mapping,
+    get_onetick_version,
+    get_username,
+)
 from onetick.py.core.column import Column
 from onetick.py.core.column_operations.base import Operation, Expr as expr, Raw as raw, OnetickParameter as param
 from onetick.py.core.per_tick_script import remote, Once, once, logf, throw_exception

onetick/py/_version.py

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

onetick/py/cache.py

@@ -113,7 +113,7 @@ def create_cache(
         The cache will be cleared every X seconds, triggering new query executions when data is requested.
     tick_type: str
         Tick type.
-    symbol: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, pd.DataFrame, optional
+    symbol: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, :pandas:`pandas.DataFrame`, optional
         ``symbols`` parameter of ``otp.run()``.
     db: str
         Database.
@@ -259,7 +259,7 @@ def delete_cache(
         :func:`<onetick.py.create_cache>`.
     tick_type: str
         Tick type.
-    symbol: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, pd.DataFrame, optional
+    symbol: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, :pandas:`pandas.DataFrame`, optional
         ``symbols`` parameter of ``otp.run()``.
     db: str
         Database.
@@ -329,7 +329,7 @@ def modify_cache_config(
         New value of configuration parameter. Will be converted to string.
     tick_type: str
         Tick type.
-    symbol: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, pd.DataFrame, optional
+    symbol: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, :pandas:`pandas.DataFrame`, optional
         ``symbols`` parameter of ``otp.run()``.
     db: str
         Database.

onetick/py/callback/callbacks.py

@@ -18,7 +18,7 @@ class LogCallback(CallbackBase):
 
 class ManualDataframeCallback(CallbackBase):
     """
-    This callback class can be used to generate the same pandas.DataFrame result as in otp.run.
+    This callback class can be used to generate the same :pandas:`pandas.DataFrame` result as in otp.run.
     Unlike otp.run, here result is constructed manually, one tick at a time.
     This may lead to lower memory usage in some cases.
     See task PY-863 for details.

onetick/py/configuration.py

@@ -32,6 +32,28 @@ def parse_datetime(s):
     )
 
 
+def parse_bool(value) -> Optional[bool]:
+    str_value = str(value).lower()
+    if str_value in ('1', 'true', 'yes'):
+        return True
+    elif str_value in ('0', 'false', 'no'):
+        return False
+    else:
+        return None
+
+
+def parse_true(value) -> bool:
+    return parse_bool(value) is True
+
+
+def parse_bool_or_string(value) -> Union[bool, str]:
+    parsed_value = parse_bool(value)
+    if parsed_value is not None:
+        return parsed_value
+    else:
+        return str(value)
+
+
 def _env_func_concurrency(value: str) -> Optional[int]:
     if not value:
         return None
@@ -197,7 +219,7 @@ class OtpShowStackInfoProperty(OtpProperty):
     """
     @staticmethod
     def parser(value):
-        return str(value).lower() in ('1', 'true', 'yes')
+        return parse_true(value)
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -492,7 +514,7 @@ class Config:
         base_default=False,
         allowed_types=[bool],
         env_var_name='OTP_PRESORT_FORCE_DEFAULT_CONCURRENCY',
-        env_var_func=OtpShowStackInfoProperty.parser,
+        env_var_func=parse_true,
     )
 
     # default batch size is set to 0, so the number of symbols in batch is not limited
@@ -623,10 +645,14 @@ class Config:
     )
 
     trusted_certificates_file = OtpProperty(
-        description='Path to the file with list of trusted Certificate Authority certificates for WebAPI requests.',
+        description='Either a boolean, in which case it controls whether we verify the server TLS certificate '
+                    'or a string with the path to the file with list of '
+                    'trusted Certificate Authority certificates for WebAPI requests. '
+                    'Default behaviour implies verification is enabled.',
         base_default=None,
-        allowed_types=str,
+        allowed_types=(bool, str),
         env_var_name='OTP_SSL_CERT_FILE',
+        env_var_func=parse_bool_or_string,
     )
 
     max_expected_ticks_per_symbol = OtpProperty(
@@ -641,7 +667,7 @@ class Config:
         base_default=False,
         allowed_types=(str, bool, int),
         env_var_name='OTP_SHOW_STACK_INFO',
-        env_var_func=OtpShowStackInfoProperty.parser,
+        env_var_func=parse_true,
     )
 
     log_symbol = OtpProperty(
@@ -651,7 +677,7 @@ class Config:
         base_default=False,
         allowed_types=(str, bool, int),
         env_var_name='OTP_LOG_SYMBOL',
-        env_var_func=OtpShowStackInfoProperty.parser,
+        env_var_func=parse_true,
     )
 
     ignore_ticks_in_unentitled_time_range = OtpProperty(
@@ -659,7 +685,7 @@ class Config:
         base_default=False,
         env_var_name='OTP_IGNORE_TICKS_IN_UNENTITLED_TIME_RANGE',
         allowed_types=(str, bool, int),
-        env_var_func=OtpShowStackInfoProperty.parser,
+        env_var_func=parse_true,
     )
 
     main_query_generated_filename = OtpProperty(
@@ -685,7 +711,7 @@ class Config:
         base_default=False,
         env_var_name='OTP_OTQ_DEBUG_MODE',
         allowed_types=(str, bool, int),
-        env_var_func=OtpShowStackInfoProperty.parser,
+        env_var_func=parse_true,
     )
 
     allow_lowercase_in_saved_fields = OtpProperty(
@@ -702,7 +728,7 @@ class Config:
         base_default=True,
         env_var_name='OTP_CLEAN_UP_TMP_FILES',
         allowed_types=(str, bool, int),
-        env_var_func=OtpShowStackInfoProperty.parser,
+        env_var_func=parse_true,
     )
 
     default_schema_policy = OtpProperty(

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

@@ -514,7 +514,7 @@ def cache(
         the result data not found in the cache. Otherwise, the cache remains unchanged.
     tick_type: str
         Tick type.
-    symbol: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, pd.DataFrame, optional
+    symbol: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, :pandas:`pandas.DataFrame`, optional
         ``symbols`` parameter of ``otp.run()``.
     db: str
         Database.

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