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

onetick/py/misc.py

@@ -3,19 +3,6 @@ from onetick.py.core.column_operations.base import _Operation
 from onetick.py.types import value2str, string
 
 
-class _BitAndOperator(_Operation):
-    def __init__(self, value1, value2):
-        super().__init__(dtype=int)
-
-        def _repr(_value1, _value2):
-            return f'BIT_AND({str(_value1)}, {str(_value2)})'
-
-        self._repr = _repr(value1, value2)
-
-    def __str__(self):
-        return self._repr
-
-
 def bit_and(value1, value2):
     """
     Performs the logical AND operation on each pair of corresponding bits of the parameters.
@@ -55,20 +42,10 @@ def bit_and(value1, value2):
             Time  A  AND
     0 2003-12-01  1    2
     """
-    return _BitAndOperator(value1, value2)
-
-
-class _BitOrOperator(_Operation):
-    def __init__(self, value1, value2):
-        super().__init__(dtype=int)
-
-        def _repr(_value1, _value2):
-            return f'BIT_OR({str(_value1)}, {str(_value2)})'
-
-        self._repr = _repr(value1, value2)
-
-    def __str__(self):
-        return self._repr
+    return _Operation(
+        op_func=lambda v1, v2: (f'BIT_AND({value2str(v1)}, {value2str(v2)})', int),
+        op_params=[value1, value2],
+    )
 
 
 def bit_or(value1, value2):
@@ -110,7 +87,10 @@ def bit_or(value1, value2):
             Time  A  OR
     0 2003-12-01  1   3
     """
-    return _BitOrOperator(value1, value2)
+    return _Operation(
+        op_func=lambda v1, v2: (f'BIT_OR({value2str(v1)}, {value2str(v2)})', int),
+        op_params=[value1, value2],
+    )
 
 
 def bit_xor(value1, value2):
@@ -152,7 +132,10 @@ def bit_xor(value1, value2):
             Time  A  XOR
     0 2003-12-01  1    1
     """
-    return _Operation(dtype=int, op_str=f'BIT_XOR({str(value1)}, {str(value2)})')
+    return _Operation(
+        op_func=lambda v1, v2: (f'BIT_XOR({value2str(v1)}, {value2str(v2)})', int),
+        op_params=[value1, value2],
+    )
 
 
 def bit_not(value):
@@ -193,7 +176,10 @@ def bit_not(value):
             Time  A  NOT
     0 2003-12-01  1   -3
     """
-    return _Operation(dtype=int, op_str=f'BIT_NOT({str(value)})')
+    return _Operation(
+        op_func=lambda v: (f'BIT_NOT({value2str(v)})', int),
+        op_params=[value],
+    )
 
 
 def bit_at(value, index):
@@ -235,7 +221,10 @@ def bit_at(value, index):
             Time  A  AT
     0 2003-12-01  1   0
     """
-    return _Operation(dtype=int, op_str=f'BIT_AT({str(value)}, {str(index)})')
+    return _Operation(
+        op_func=lambda v, i: (f'BIT_AT({value2str(v)}, {value2str(i)})', int),
+        op_params=[value, index],
+    )
 
 
 class _HashCodeOperator(_Operation):
@@ -262,18 +251,14 @@ class _HashCodeOperator(_Operation):
 
         dtype = self.HASH_TYPES[hash_type]
 
-        super().__init__(dtype=dtype)
-
         def _repr(_value, _hash_type):
             _value = value2str(_value)
             _hash_type = value2str(_hash_type.upper())
 
-            return f'COMPUTE_HASH_CODE_STR({_value}, {_hash_type})'
-
-        self._repr = _repr(value, hash_type)
+            return f'COMPUTE_HASH_CODE_STR({_value}, {_hash_type})', dtype
 
-    def __str__(self):
-        return self._repr
+        super().__init__(op_func=_repr,
+                         op_params=[value, hash_type])
 
 
 def hash_code(value, hash_type):
@@ -436,3 +421,50 @@ def get_symbology_mapping(dest_symbology, src_symbology=None, symbol=None, times
         op_params=[dest_symbology, src_symbology, symbol, timestamp],
         dtype=str,
     )
+
+
+def get_onetick_version():
+    """
+    Returns the string with the build name of OneTick.
+    Build string may have different format depending on OneTick version.
+
+    Note
+    ----
+    The version is returned from the server where the query executes.
+    Usually it's the same server where the database specified in :func:`otp.run <onetick.py.run>` resides.
+
+    Returns
+    -------
+    :py:class:`~onetick.py.Operation`
+
+    Examples
+    --------
+    >>> data = otp.Tick(VERSION=otp.get_onetick_version())
+    >>> otp.run(data, symbols='US_COMP::')  # doctest: +SKIP
+            Time                                      VERSION
+    0 2003-12-01  BUILD_rel_20250727_update2 (20250727120000)
+    """
+    return _Operation(
+        op_func=lambda: ('FORMATMESSAGE("%1% (%2%)", GET_ONETICK_RELEASE(), GET_ONETICK_VERSION())', str),
+    )
+
+
+def get_username():
+    """
+    Returns the string with the name of the user executing the query
+    and authenticated login name of the user.
+
+    Returns
+    -------
+    :py:class:`~onetick.py.Operation`
+
+    Examples
+    --------
+    >>> data = otp.Tick(USER=otp.get_username())
+    >>> otp.run(data)  # doctest: +SKIP
+            Time               USER
+    0 2003-12-01  onetick (onetick)
+    """
+    return _Operation(
+        op_func=lambda: ('FORMATMESSAGE("%1% (%2%)", GETUSER(), GET_AUTHENTICATED_USERNAME())', str),
+    )

onetick/py/otq.py

@@ -160,18 +160,24 @@ elif otp.__webapi__:
         if 'https_proxy' not in kwargs:
             kwargs['https_proxy'] = config.https_proxy
 
-        is_trusted_certificates_supported = 'trusted_certificates_file' in inspect.signature(otq.run).parameters
-
-        if (
-            ('trusted_certificates_file' in kwargs or config.trusted_certificates_file is not None) and
-            not is_trusted_certificates_supported
-        ):
-            raise ValueError(
-                'Parameter `trusted_certificates_file` was set, however current version of OneTick doesn\'t support it.'
-            )
-
-        if 'trusted_certificates_file' not in kwargs and is_trusted_certificates_supported:
-            kwargs['trusted_certificates_file'] = config.trusted_certificates_file
+        webapi_run_parameters = inspect.signature(__original_run).parameters
+
+        trusted_certificate_file_arg = kwargs.pop('trusted_certificates_file',
+                                                  kwargs.pop('trusted_certificate_file', None))
+        trusted_certificate_file_value = (
+            trusted_certificate_file_arg if trusted_certificate_file_arg is not None
+            else config.trusted_certificates_file
+        )
+        if trusted_certificate_file_value is not None:
+            trusted_certificates_supported = set(webapi_run_parameters).intersection({'trusted_certificates_file',
+                                                                                      'trusted_certificate_file'})
+            if not trusted_certificates_supported:
+                raise ValueError(
+                    "Parameter `trusted_certificates_file` was set,"
+                    " however current version of OneTick doesn't support it."
+                )
+            trusted_certificates_supported_param = list(trusted_certificates_supported)[0]
+            kwargs[trusted_certificates_supported_param] = trusted_certificate_file_value
 
         if 'callback' in kwargs and kwargs['callback'] is not None:
             kwargs['output_mode'] = otq.QueryOutputMode.callback

onetick/py/run.py

@@ -1,4 +1,4 @@
-
+import asyncio
 import inspect
 import datetime
 import warnings
@@ -76,10 +76,11 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
         ``query`` can also be a function that has a symbol object as the first parameter.
         This object can be used to get symbol name and symbol parameters.
         Function must return a :py:class:`Source <onetick.py.Source>`.
-    symbols: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, pd.DataFrame, optional
-        Symbol(s) to run the query for passed as a string, a list of strings, a pd.DataFrame with the ``SYMBOL_NAME``
-        column, or as a "symbols" query which results include the ``SYMBOL_NAME`` column. The start/end times for the
-        symbols query will taken from the params below.
+    symbols: str, list of str, list of otq.Symbol, :py:class:`onetick.py.Source`, :pandas:`pandas.DataFrame`, optional
+        Symbol(s) to run the query for passed as a string, a list of strings,
+        a :pandas:`pandas.DataFrame` with the ``SYMBOL_NAME`` column,
+        or as a "symbols" query which results include the ``SYMBOL_NAME`` column.
+        The start/end times for the symbols query will taken from the params below.
         See :ref:`symbols <static/concepts/symbols:Symbols: bound and unbound>` for more details.
     start: :py:class:`datetime.datetime`, :py:class:`otp.datetime <onetick.py.datetime>`,\
             :py:class:`pyomd.timeval_t`, optional
@@ -610,6 +611,75 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
                                require_dict=require_dict, node_names=node_names)
 
 
+async def run_async(*args, **kwargs):
+    """
+    Asynchronous alternative to :func:`otp.run <onetick.py.run>`.
+
+    All parameters are the same.
+
+    This function can be used via built-in python ``await`` syntax
+    and standard `asyncio <https://docs.python.org/3/library/asyncio.html>`_ library.
+
+    Note
+    ----
+    Internally this function is implemented as :func:`otp.run <onetick.py.run>` running in a separate thread.
+
+    Threads in python are generally not interruptable,
+    so some `asyncio` functionality may not work as expected.
+
+    For example, canceling :func:`otp.run_async <onetick.py.run_async>` task by
+    `timeout <https://docs.python.org/3/library/asyncio-task.html#timeouts>`_
+    may block the waiting function
+    or exiting the python process will block until the task is finished,
+    depending on python and `asyncio` back-end implementation.
+
+    Examples
+    --------
+
+    >>> data = otp.Ticks(A=[1, 2, 3])
+
+    Calling :func:`otp.run_async <onetick.py.run_async>` will create a "coroutine" object:
+
+    >>> otp.run_async(data) # doctest: +SKIP
+    <coroutine object run_async at ...>
+
+    Use `asyncio.run <https://docs.python.org/3/library/asyncio-runner.html#asyncio.run>`_
+    to run this coroutine and wait for it to finish:
+
+    >>> asyncio.run(otp.run_async(data))
+                         Time  A
+    0 2003-12-01 00:00:00.000  1
+    1 2003-12-01 00:00:00.001  2
+    2 2003-12-01 00:00:00.002  3
+
+    You can use standard `asyncio <https://docs.python.org/3/library/asyncio.html>`_
+    library functions to create and schedule tasks.
+
+    In the example below two tasks are executed in parallel,
+    so total execution time will be around 3 seconds instead of 6:
+
+    >>> import asyncio
+    >>> import time
+    >>> async def parallel_tasks():
+    ...     # pause 1 second on each tick (thus 3 seconds for 3 ticks)
+    ...     task_otp = asyncio.create_task(otp.run_async(data.pause(1000)))
+    ...     # just sleep for 3 seconds
+    ...     task_other = asyncio.create_task(asyncio.sleep(3))
+    ...     otp_result = await task_otp
+    ...     await task_other
+    ...     print(otp_result)
+    >>> start_time = time.time()
+    >>> asyncio.run(parallel_tasks())
+                         Time  A
+    0 2003-12-01 00:00:00.000  1
+    1 2003-12-01 00:00:00.001  2
+    2 2003-12-01 00:00:00.002  3
+    >>> print('Finished in', time.time() - start_time, 'seconds') # doctest: +SKIP
+    Finished in 3.0108885765075684 seconds
+    """
+    return await asyncio.to_thread(run, *args, **kwargs)
+
+
 def _filter_returned_map_by_node(result, _node_names):
     """
     Here, result has the following format: {symbol: {node_name: data}}

onetick/py/sources/data_source.py

@@ -977,14 +977,7 @@ class DataSource(Source):
         src = self._table_schema(src)
         return src
 
-    def _base_ep_for_cross_symbol(
-        self, db, symbol, tick_type, identify_input_ts,
-        back_to_first_tick=0, keep_first_tick_timestamp=None,
-        presort=utils.adaptive, batch_size=None, concurrency=utils.default,
-        max_back_ticks_to_prepend=1,
-        where_clause_for_back_ticks=None,
-        symbol_date=None,
-    ):
+    def _cross_symbol_convert(self, symbol, symbol_date=None):
         tmp_otq = TmpOtq()
 
         if isinstance(symbol, _QueryEvalWrapper):
@@ -996,6 +989,18 @@ class DataSource(Source):
         elif isinstance(symbol, (Source, otq.GraphQuery)):
             symbol = Source._convert_symbol_to_string(symbol, tmp_otq, symbol_date=symbol_date)
 
+        return symbol, tmp_otq
+
+    def _base_ep_for_cross_symbol(
+        self, db, symbol, tick_type, identify_input_ts,
+        back_to_first_tick=0, keep_first_tick_timestamp=None,
+        presort=utils.adaptive, batch_size=None, concurrency=utils.default,
+        max_back_ticks_to_prepend=1,
+        where_clause_for_back_ticks=None,
+        symbol_date=None,
+    ):
+        symbol, tmp_otq = self._cross_symbol_convert(symbol, symbol_date)
+
         self.logger.info(f'symbol={symbol}')
 
         tick_type = convert_tick_type_to_str(tick_type, db)
@@ -1030,6 +1035,7 @@ class DataSource(Source):
             src.sink(
                 otq.Merge(identify_input_ts=identify_input_ts).symbols(symbol).tick_type(tick_type)
             )
+
         src._tmp_otq.merge(tmp_otq)
 
         src = self._table_schema(src)

onetick/py/sources/order_book.py

@@ -15,6 +15,7 @@ from ..aggregations.order_book import (
 from ..aggregations.functions import (
     ob_snapshot, ob_snapshot_wide, ob_snapshot_flat, ob_summary, ob_size, ob_vwap, ob_num_levels,
 )
+from .. import utils
 
 from .data_source import DataSource, DATA_SOURCE_DOC_PARAMS
 
@@ -24,17 +25,43 @@ class _ObSource(DataSource):
     OB_AGG_PARAMS: Iterable
     _PROPERTIES = DataSource._PROPERTIES + ['_ob_agg']
 
-    def __init__(self, *args, schema=None, **kwargs):
-        if self._try_default_constructor(*args, schema=schema, **kwargs):
+    def __init__(self, db=None, schema=None, **kwargs):
+        if self._try_default_constructor(schema=schema, **kwargs):
             return
 
         ob_agg_params = {
             param.name: kwargs.pop(param.name, param.default)
             for _, param in self.OB_AGG_PARAMS
         }
+
+        symbol_param = kwargs.get('symbol')
+        symbols_param = kwargs.get('symbols')
+
+        if symbol_param and symbols_param:
+            raise ValueError(
+                'You have set the `symbol` and `symbols` parameters together, it is not allowed. '
+                'Please, clarify parameters'
+            )
+
+        symbols = symbol_param if symbol_param else symbols_param
+        tmp_otq = None
+
+        # Use bound symbols only in case, if db not passed
+        use_bound_symbols = not db and symbols and symbols is not utils.adaptive
+        if use_bound_symbols:
+            symbols, tmp_otq = self._cross_symbol_convert(symbols, kwargs.get('symbol_date'))
+
+            if symbols_param:
+                del kwargs['symbols']
+
+            kwargs['symbol'] = None
+
         self._ob_agg = self.__class__.OB_AGG_FUNC(**ob_agg_params)
 
-        super().__init__(*args, schema=schema, **kwargs)
+        if use_bound_symbols:
+            self._ob_agg.set_bound_symbols(symbols)
+
+        super().__init__(db=db, schema=schema, **kwargs)
 
         ob_agg_output_schema = self._ob_agg._get_output_schema(otp.Empty())
 
@@ -43,6 +70,9 @@ class _ObSource(DataSource):
         else:
             self.schema.set(**ob_agg_output_schema)
 
+        if tmp_otq:
+            self._tmp_otq.merge(tmp_otq)
+
     def base_ep(self, *args, **kwargs):
         src = super().base_ep(*args, **kwargs)
         return self._ob_agg.apply(src)

onetick/py/sources/symbols.py

@@ -5,6 +5,8 @@ from onetick.py.otq import otq
 
 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 .. import types as ott
 from .. import utils
@@ -20,7 +22,7 @@ class Symbols(Source):
 
     Parameters
     ----------
-    db: str
+    db: str, :py:func:`eval query <onetick.py.eval>`
         Name of the database where to search symbols.
         By default the database used by :py:func:`otp.run <onetick.py.run>` will be inherited.
     keep_db: bool
@@ -276,9 +278,13 @@ class Symbols(Source):
             end = date.end
 
         _symbol = utils.adaptive
+        _tmp_otq = None
         if db:
             if isinstance(db, list):
                 _symbol = [f"{str(_db).split(':')[0]}::" for _db in db] # noqa
+            elif isinstance(db, _QueryEvalWrapper):
+                _tmp_otq = TmpOtq()
+                _symbol = db.to_eval_string(tmp_otq=_tmp_otq)
             else:
                 _symbol = f"{str(db).split(':')[0]}::"  # noqa
 
@@ -336,6 +342,9 @@ class Symbols(Source):
         if _find_params['symbology'] and _find_params['show_original_symbols']:
             self.schema['ORIGINAL_SYMBOL_NAME'] = str
 
+        if _tmp_otq:
+            self._tmp_otq.merge(_tmp_otq)
+
     def base_ep(self, ep_tick_type, keep_db, **params):
         src = Source(otq.FindDbSymbols(**params))
 

onetick/py/sources/ticks.py

@@ -369,7 +369,7 @@ def Ticks(data=None,  # NOSONAR
 
     Parameters
     ----------
-    data: dict, list or pandas.DataFrame, optional
+    data: dict, list or :pandas:`pandas.DataFrame`, optional
         Ticks values
 
         * ``dict`` -- <field_name>: <values>

onetick/py/state.py

@@ -75,7 +75,7 @@ def tick_list(default_value=None, scope='query', schema=None) -> TickList:
 
     Parameters
     ----------
-    default_value: :py:func:`eval query <onetick.py.eval>`
+    default_value: :class:`otp.Source <onetick.py.Source>`, :py:func:`eval query <onetick.py.eval>`
         Evaluated query to initialize tick list from.
     scope: str
         Scope for the state variable.
@@ -85,14 +85,12 @@ def tick_list(default_value=None, scope='query', schema=None) -> TickList:
         if ``default_value`` is not passed as well, schema will contain fields of the main Source object.
 
         If schema is passed as a list, it will select only these fields from the schema of ``default_value``
-        or main Source object.
+        or main :class:`Source <onetick.py.Source>` object.
 
     Examples
     --------
-    >>> def fsq():
-    ...     return otp.Ticks(B=[1, 2, 3])
     >>> data = otp.Tick(A=1)
-    >>> data.state_vars['LIST'] = otp.state.tick_list(otp.eval(fsq))
+    >>> data.state_vars['LIST'] = otp.state.tick_list(otp.Ticks(B=[1, 2, 3]))
     >>> data = data.state_vars['LIST'].dump()
     >>> otp.run(data)[['B']]
        B
@@ -115,7 +113,7 @@ def tick_set(insertion_policy, key_fields, default_value=None, scope='query', sc
         'latest' makes the last inserted tick overwrite the one with the same keys (if existing).
     key_fields: str, list of str
         The values of the specified fields will be used as keys.
-    default_value: :py:func:`eval query <onetick.py.eval>`
+    default_value: :class:`otp.Source <onetick.py.Source>`, :py:func:`eval query <onetick.py.eval>`
         Evaluated query to initialize tick set from.
     scope: str
         Scope for the state variable.
@@ -125,14 +123,12 @@ def tick_set(insertion_policy, key_fields, default_value=None, scope='query', sc
         if ``default_value`` is not passed as well, schema will contain fields of the main Source object.
 
         If schema is passed as a list, it will select only these fields from the schema of ``default_value``
-        or main Source object.
+        or main :class:`Source <onetick.py.Source>` object.
 
     Examples
     --------
-    >>> def fsq():
-    ...     return otp.Ticks(B=[1, 1, 2, 2, 3, 3])
     >>> data = otp.Tick(A=1)
-    >>> data.state_vars['SET'] = otp.state.tick_set('oldest', 'B', otp.eval(fsq))
+    >>> data.state_vars['SET'] = otp.state.tick_set('oldest', 'B', otp.Ticks(B=[1, 1, 2, 2, 3, 3]))
     >>> data = data.state_vars['SET'].dump()
     >>> otp.run(data)[['B']]
        B
@@ -175,7 +171,7 @@ def tick_set_unordered(insertion_policy,
             may be considerably worse than that of normal tick set.
             In particular, **default value of -1 will lead to bad performance and should be avoided**
 
-    default_value: :py:func:`eval query <onetick.py.eval>`
+    default_value: :class:`otp.Source <onetick.py.Source>`, :py:func:`eval query <onetick.py.eval>`
         Evaluated query to initialize unordered tick set from.
     scope: str,
         Scope for the state variable.
@@ -186,14 +182,14 @@ def tick_set_unordered(insertion_policy,
         if ``default_value`` is not passed as well, schema will contain fields of the main Source object.
 
         If schema is passed as a list, it will select only these fields from the schema of ``default_value``
-        or main Source object.
+        or main :class:`Source <onetick.py.Source>` object.
 
     Examples
     --------
-    >>> def fsq():
-    ...     return otp.Ticks(B=[1, 1, 2, 2, 3, 3])
     >>> data = otp.Tick(A=1)
-    >>> data.state_vars['SET'] = otp.state.tick_set_unordered('oldest', 'B', otp.eval(fsq), max_distinct_keys=5)
+    >>> data.state_vars['SET'] = otp.state.tick_set_unordered('oldest', 'B',
+    ...                                                       otp.Ticks(B=[1, 1, 2, 2, 3, 3]),
+    ...                                                       max_distinct_keys=5)
     >>> data = data.state_vars['SET'].dump()
     >>> otp.run(data)[['B']]
        B
@@ -218,7 +214,7 @@ def tick_deque(default_value=None, scope='query', schema=None) -> TickDeque:
 
     Parameters
     ----------
-    default_value: :py:func:`eval query <onetick.py.eval>`
+    default_value: :class:`otp.Source <onetick.py.Source>`, :py:func:`eval query <onetick.py.eval>`
         Evaluated query to initialize tick deque from.
     scope: str
         Scope for the state variable.
@@ -228,14 +224,12 @@ def tick_deque(default_value=None, scope='query', schema=None) -> TickDeque:
         if ``default_value`` is not passed as well, schema will contain fields of the main Source object.
 
         If schema is passed as a list, it will select only these fields from the schema of ``default_value``
-        or main Source object.
+        or main :class:`Source <onetick.py.Source>` object.
 
     Examples
     --------
-    >>> def fsq():
-    ...     return otp.Ticks(B=[1, 2, 3])
     >>> data = otp.Tick(A=1)
-    >>> data.state_vars['DEQUE'] = otp.state.tick_deque(otp.eval(fsq))
+    >>> data.state_vars['DEQUE'] = otp.state.tick_deque(otp.Ticks(B=[1, 2, 3]))
     >>> data = data.state_vars['DEQUE'].dump()
     >>> otp.run(data)[['B']]
        B

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

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