onetick-py 1.168.0__tar.gz → 1.170.0__tar.gz

{onetick_py-1.168.0 → onetick_py-1.170.0}/PKG-INFO

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

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/_version.py

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

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/aggregations/functions.py

@@ -956,7 +956,7 @@ def generic(*args, **kwargs):
 
     >>> data = otp.Ticks({'A': [1, 2, 1]})
     >>> def count_values(source, value):
-    ...     values, _ = source[source['A'] == value]
+    ...     values = source.where(source['A'] == value)
     ...     return values.agg({'count': otp.agg.count()})
     >>> data = otp.agg.generic(count_values).apply(data, value=1)
     >>> otp.run(data)

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/aggregations/order_book.py

@@ -146,6 +146,8 @@ class _OrderBookAggregation(_Aggregation, ABC):
         self.max_initialization_days = max_initialization_days
         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
+
         super().__init__(_Column('TIMESTAMP'), *args, **kwargs)
 
     def _param_validation(self):
@@ -170,6 +172,19 @@ class _OrderBookAggregation(_Aggregation, ABC):
             raise TypeError(f"Aggregation `{self.NAME}` need these columns: "
                             f"BUY_SELL_FLAG, PRICE, SIZE and (UPDATE_TIME or DELETED_TIME)")
 
+    def to_ep(self, *args, **kwargs):
+        ob_ep = super().to_ep(*args, **kwargs)
+        if self.bound_symbols:
+            ob_ep = ob_ep.symbols(self.bound_symbols)
+
+        return ob_ep
+
+    def set_bound_symbols(self, bound_symbols=None):
+        if isinstance(bound_symbols, str):
+            bound_symbols = [bound_symbols]
+
+        self.bound_symbols = bound_symbols
+
 
 class ObSnapshot(_OrderBookAggregation):
     NAME = 'OB_SNAPSHOT'

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/compatibility.py

@@ -767,3 +767,10 @@ def is_join_with_query_symbol_time_otq_supported():
     # to the equivalent value, except in YYYYMMDDhhmmss format
     return _is_min_build_or_version(None, None,
                                     20250227120000)
+
+
+def is_show_db_list_show_description_supported():
+    # 20240301: Implemented 0032320: 0032320: SHOW_DB_LIST should have a new EP parameter, SHOW_DESCRIPTION
+    # However on 20240330 builds it returns SHOW_DESCRIPTION column instead of DESCRIPTION
+    return _is_min_build_or_version(1.25, 20241229055942,
+                                    20240501000000)

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/configuration.py

@@ -537,6 +537,14 @@ class Config:
         allowed_types=str,
     )
 
+    default_username = OtpProperty(
+        description='Default username to call queries. '
+                    'By default the name of the owner of the current process is used.',
+        base_default=None,
+        allowed_types=str,
+        env_var_name='OTP_DEFAULT_USERNAME',
+    )
+
     default_auth_username = OtpProperty(
         description='Default username used for authentication.',
         base_default=None,

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/core/_internal/_state_objects.py

@@ -165,7 +165,7 @@ class _StateBase(ABC):
            data.state_vars['VAR'] = otp.state.tick_list()
            def fun(min_value):
                t = otp.Ticks(X=[123, 234])
-               t, _ = t[t['X'] > min_value]
+               t = t.where(t['X'] > min_value)
                return t
            data = data.state_vars['VAR'].modify_from_query(fun, params={'min_value': 200})
            data = data.state_vars['VAR'].dump()
@@ -344,8 +344,9 @@ class _TickSequence(_StateBase):
     def __init__(self, name, obj_ref, default_value, scope, schema=None, **kwargs):
         if kwargs:
             raise ValueError(f"Unknown parameters for '{self.__class__.__name__}': {list(kwargs)}")
-        if default_value is not None and not isinstance(default_value, _QueryEvalWrapper):
-            raise ValueError('only otp.eval can be used as initial value for tick sequences')
+        from onetick.py.core.source import Source
+        if default_value is not None and not isinstance(default_value, (_QueryEvalWrapper, Source)):
+            raise ValueError('only otp.eval and otp.Source objects can be used as initial value for tick sequences')
         if default_value is not None and schema is not None:
             # TODO: check that the two schemas align or possibly that they are exactly the same
             pass
@@ -396,9 +397,13 @@ class _TickSequence(_StateBase):
             self._schema = None
         if not self._schema:
             if self.default_value is not None:
-                # If tick sequence is initialized from eval,
-                # then we get schema from the Source in eval.
-                self._schema = self.default_value.query.schema.copy()
+                from onetick.py.core.source import Source
+                if isinstance(self.default_value, _QueryEvalWrapper):
+                    # If tick sequence is initialized from eval,
+                    # then we get schema from the Source in eval.
+                    self._schema = self.default_value.query.schema.copy()
+                elif isinstance(self.default_value, Source):
+                    self._schema = self.default_value.schema.copy()
             else:
                 # If tick sequence is initialized as empty,
                 # then it's schema will be derived from the schema of the parent object (e.g. source)

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/core/_internal/_state_vars.py

@@ -81,7 +81,13 @@ class StateVars:
             str_type = type2str(base_type)
 
         expression = f'{str_type} {name}'
+
+        import onetick.py as otp
         if value.default_value is not None:
-            # TODO: PY-952: use to_eval_string(self._owner._tmp_otq) here if otp.eval is passed
-            expression += f' = {value2str(value.default_value)}'
+            if isinstance(value.default_value, otp.Source):
+                value_expression = otp.eval(value.default_value).to_eval_string(self._owner._tmp_otq)
+            else:
+                # TODO: PY-952: use to_eval_string(self._owner._tmp_otq) here if otp.eval is passed
+                value_expression = value2str(value.default_value)
+            expression += f' = {value_expression}'
         self._owner.sink(otq.DeclareStateVariables(variables=expression, scope=value.scope))

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/core/_source/source_methods/joins.py

@@ -394,7 +394,7 @@ def join_with_collection(
     >>>
     >>> trd_qte = trd_qte.state_vars['LAST_QUOTE_PER_EXCHANGE'].update(where=trd_qte['TICK_TYPE'] == 'QTE',
     ...                                                                value_fields=['ASK_PRICE', 'BID_PRICE'])
-    >>> trd, _ = trd_qte[trd_qte['TICK_TYPE'] == 'TRD']
+    >>> trd = trd_qte.where(trd_qte['TICK_TYPE'] == 'TRD')
     >>> trd.drop(['ASK_PRICE', 'BID_PRICE', 'EXCHANGE'], inplace=True)
     >>> trd = trd.join_with_collection('LAST_QUOTE_PER_EXCHANGE')
     >>> otp.run(trd)[['PRICE', 'SIZE', 'EXCHANGE', 'ASK_PRICE', 'BID_PRICE']]

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/core/column_operations/accessors/str_accessor.py

@@ -227,7 +227,7 @@ class _StrAccessor(_Accessor):
 
         >>> q = otp.DataSource('US_COMP', tick_type='TRD', symbols=['SPY'])  # doctest: +SKIP
         >>> q = q[['PRICE', 'SIZE', 'COND', 'EXCHANGE']]  # doctest: +SKIP
-        >>> q, _ = q[q['COND'].str.match('^[^O6TUHILNRWZ47QMBCGPV]*$')]  # doctest: +SKIP
+        >>> q = q.where(q['COND'].str.match('^[^O6TUHILNRWZ47QMBCGPV]*$'))  # doctest: +SKIP
         >>> otp.run(q, start=otp.dt(2023, 5, 15, 9, 30), end=otp.dt(2023, 5, 15, 9, 30, 1))  # doctest: +SKIP
                                     Time    PRICE  SIZE  COND EXCHANGE
         0  2023-05-15 09:30:00.000776704  412.220   247              Z
@@ -1225,7 +1225,7 @@ class _StrAccessor(_Accessor):
         This function can be used to filter out ticks:
 
         >>> data = otp.Ticks(X=['a', 'ab', 'b_', 'b%'])
-        >>> data, _ = data[data['X'].str.like('a%')]
+        >>> data = data.where(data['X'].str.like('a%'))
         >>> otp.run(data)
                              Time   X
         0 2003-12-01 00:00:00.000   a
@@ -1335,7 +1335,7 @@ class _StrAccessor(_Accessor):
            :skipif: not is_ilike_supported()
 
            data = otp.Ticks(X=['a', 'ab', 'Ab', 'b_'])
-           data, _ = data[data['X'].str.ilike('a%')]
+           data = data.where(data['X'].str.ilike('a%'))
            df = otp.run(data)
            print(df)
 

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/core/column_operations/base.py

@@ -725,7 +725,7 @@ class Operation:
         Examples
         --------
         >>> t = otp.Ticks(A=range(4))
-        >>> t, _ = t[~(t['A'] > 1)]
+        >>> t = t.where(~(t['A'] > 1))
         >>> otp.run(t)[['A']]
            A
         0  0
@@ -741,7 +741,7 @@ class Operation:
         Examples
         --------
         >>> t = otp.Ticks(A=range(4))
-        >>> t, _ = t[(t['A'] == 1)]
+        >>> t = t.where((t['A'] == 1))
         >>> otp.run(t)[['A']]
            A
         0  1
@@ -756,7 +756,7 @@ class Operation:
         Examples
         --------
         >>> t = otp.Ticks(A=range(4))
-        >>> t, _ = t[(t['A'] != 1)]
+        >>> t = t.where((t['A'] != 1))
         >>> otp.run(t)[['A']]
            A
         0  0
@@ -773,7 +773,7 @@ class Operation:
         Examples
         --------
         >>> t = otp.Ticks(A=range(4))
-        >>> t, _ = t[(t['A'] == 1) | (t['A'] == 2)]
+        >>> t = t.where((t['A'] == 1) | (t['A'] == 2))
         >>> otp.run(t)[['A']]
            A
         0  1
@@ -789,7 +789,7 @@ class Operation:
         Examples
         --------
         >>> t = otp.Ticks(A=[1, 1], B=[1, 2])
-        >>> t, _ = t[(t['A'] == 1) & (t['B'] == 1)]
+        >>> t = t.where((t['A'] == 1) & (t['B'] == 1))
         >>> otp.run(t)[['A', 'B']]
            A  B
         0  1  1
@@ -804,7 +804,7 @@ class Operation:
         Examples
         --------
         >>> t = otp.Ticks(A=range(4))
-        >>> t, _ = t[t['A'] <= 2]
+        >>> t = t.where(t['A'] <= 2)
         >>> otp.run(t)[['A']]
            A
         0  0
@@ -821,7 +821,7 @@ class Operation:
         Examples
         --------
         >>> t = otp.Ticks(A=range(4))
-        >>> t, _ = t[t['A'] < 2]
+        >>> t = t.where(t['A'] < 2)
         >>> otp.run(t)[['A']]
            A
         0  0
@@ -837,7 +837,7 @@ class Operation:
         Examples
         --------
         >>> t = otp.Ticks(A=range(4))
-        >>> t, _ = t[t['A'] >= 2]
+        >>> t = t.where(t['A'] >= 2)
         >>> otp.run(t)[['A']]
            A
         0  2
@@ -853,7 +853,7 @@ class Operation:
         Examples
         --------
         >>> t = otp.Ticks(A=range(4))
-        >>> t, _ = t[t['A'] > 2]
+        >>> t = t.where(t['A'] > 2)
         >>> otp.run(t)[['A']]
            A
         0  3

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/core/eval_query.py

@@ -171,7 +171,7 @@ def eval(query, symbol=None, start=None, end=None,
     >>> data = otp.Ticks(X=[1, 2, 3])
     >>> # note that in this case column WHERE must be specified,
     >>> # because evaluated query returns tick with more than one field
-    >>> data, _ = data[otp.eval(get_filter, a=0, b=2)['WHERE']]
+    >>> data = data.where(otp.eval(get_filter, a=0, b=2)['WHERE'])
     >>> otp.run(data)
             Time  X
     0 2003-12-01  1
@@ -183,12 +183,12 @@ def eval(query, symbol=None, start=None, end=None,
     ...         'TICK_TYPE': ['TRD', 'QTE'],
     ...         'WHERE': ['PRICE>=1.4', 'ASK_PRICE>=1.4']
     ...     })
-    ...     res, _ = res[res['TICK_TYPE'] == tick_type]
+    ...     res = res.where(res['TICK_TYPE'] == tick_type)
     ...     return res.drop(['TICK_TYPE'])
     >>> t = otp.DataSource('US_COMP::TRD')
     >>> # note that in this case column WHERE do not need to be specified,
     >>> # because evaluated query returns tick with only one field
-    >>> t, _ = t[otp.eval(filter_by_tt, tick_type=t['_TICK_TYPE'])]
+    >>> t = t.where(otp.eval(filter_by_tt, tick_type=t['_TICK_TYPE']))
     >>> otp.run(t, start=otp.dt(2022, 3, 1), end=otp.dt(2022, 3, 2))
                          Time  PRICE  SIZE
     0 2022-03-01 00:00:00.001    1.4    10

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/db/_inspection.py

@@ -7,7 +7,7 @@ from dateutil.tz import gettz
 
 import onetick.py as otp
 from onetick.py import configuration, utils
-from onetick.py.compatibility import is_native_plus_zstd_supported
+from onetick.py.compatibility import is_native_plus_zstd_supported, is_show_db_list_show_description_supported
 from onetick.py.core import db_constants
 from onetick.py.otq import otq
 
@@ -25,8 +25,9 @@ class DB:
     dates with data, symbols, tick schema, etc.
     """
 
-    def __init__(self, name, context=utils.default):
+    def __init__(self, name, description='', context=utils.default):
         self.name = name
+        self.description = description
         if context is utils.default or context is None:
             self.context = otp.config.context
         else:
@@ -907,7 +908,9 @@ class DB:
         return df
 
 
-def databases(context=utils.default, derived=False, readable_only: bool = True) -> dict[str, DB]:
+def databases(
+    context=utils.default, derived: bool = False, readable_only: bool = True, fetch_description: bool = False,
+) -> dict[str, DB]:
     """
     Gets all available databases in the ``context``
 
@@ -925,6 +928,9 @@ def databases(context=utils.default, derived=False, readable_only: bool = True)
     readable_only: bool
         If set to True (default), then return only the databases with read-access for the current user.
         Otherwise return all databases visible from the current process.
+    fetch_description: bool
+        If set to True, retrieves descriptions for databases and puts them into ``description`` property of
+        :py:class:`~onetick.py.DB` objects in a returned dict.
 
     See also
     --------
@@ -938,17 +944,47 @@ def databases(context=utils.default, derived=False, readable_only: bool = True)
         Dict where keys are database names and values are :class:`DB <onetick.py.db._inspection.DB>` objects
         with ``context`` specified.
     """
+    if fetch_description and not is_show_db_list_show_description_supported():
+        fetch_description = False
+
     if readable_only:
         node = (
             otq.AccessInfo(info_type='DATABASES', show_for_all_users=False, deep_scan=True).tick_type('ANY')
             >> otq.Passthrough('DB_NAME,READ_ACCESS')
             >> otq.WhereClause(where='READ_ACCESS = 1')
         )
+
+        if fetch_description:
+            join = otq.Join(
+                left_source='LEFT', join_type='LEFT_OUTER', join_criteria='LEFT.DB_NAME = RIGHT.DATABASE_NAME'
+            )
+
+            _ = node.set_node_name('LEFT') >> join
+            _ = (
+                otq.ShowDbList(show_description=fetch_description).tick_type('ANY')
+                >> otq.Passthrough('DATABASE_NAME,DESCRIPTION').set_node_name('RIGHT')
+                >> join
+            )
+
+            node = (
+                join >> otq.Passthrough('LEFT.DB_NAME,RIGHT.DESCRIPTION')
+                >> otq.RenameFields("LEFT.DB_NAME=DB_NAME,RIGHT.DESCRIPTION=DESCRIPTION")
+            )
     else:
+        db_list_kwargs = {}
+        output_fields = ['DATABASE_NAME']
+        if fetch_description:
+            db_list_kwargs['show_description'] = fetch_description
+            output_fields.append('DESCRIPTION')
+
         node = (
-            otq.ShowDbList().tick_type('ANY')
-            >> otq.Passthrough('DATABASE_NAME')
+            otq.ShowDbList(**db_list_kwargs).tick_type('ANY')
+            >> otq.Passthrough(','.join(output_fields))
         )
+
+    if not fetch_description:
+        node = node >> otq.AddField('DESCRIPTION', '""')
+
     dbs = otp.run(node,
                   symbols='LOCAL::',
                   # start and end times don't matter for this query, use some constants
@@ -961,9 +997,14 @@ def databases(context=utils.default, derived=False, readable_only: bool = True)
         return {}
 
     db_list = list(dbs['DB_NAME'] if readable_only else dbs['DATABASE_NAME'])
-    db_dict = {db_name: DB(db_name, context=context) for db_name in db_list}
+    merged_db_list = list(zip(db_list, dbs['DESCRIPTION']))
+
+    db_dict = {
+        db_name: DB(db_name, description=db_description, context=context) for db_name, db_description in merged_db_list
+    }
+
     if derived:
-        kwargs = derived if isinstance(derived, dict) else {}
+        kwargs: dict = derived if isinstance(derived, dict) else {}
         kwargs.setdefault('context', context)
         db_dict.update(
             derived_databases(**kwargs)

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/onetick/py/run.py

@@ -84,14 +84,14 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
     start: :py:class:`datetime.datetime`, :py:class:`otp.datetime <onetick.py.datetime>`,\
             :py:class:`pyomd.timeval_t`, optional
         The start time of the query. Can be timezone-naive or timezone-aware. See also ``timezone`` argument.
-        onetick.py uses :py:attr:`default_start_time<onetick.py.configuration.Config.default_start_time>`
+        onetick.py uses :py:attr:`otp.config.default_start_time<onetick.py.configuration.Config.default_start_time>`
         as default value, if you don't want to specify start time, e.g. to use saved time of the query,
         then you should specify None value.
     end: :py:class:`datetime.datetime`, :py:class:`otp.datetime <onetick.py.datetime>`,\
           :py:class:`pyomd.timeval_t`, optional
         The end time of the query (note that it's non-inclusive).
         Can be timezone-naive or timezone-aware. See also ``timezone`` argument.
-        onetick.py uses :py:attr:`default_end_time<onetick.py.configuration.Config.default_end_time>`
+        onetick.py uses :py:attr:`otp.config.default_end_time<onetick.py.configuration.Config.default_end_time>`
         as default value, if you don't want to specify end time, e.g. to use saved time of the query,
         then you should specify None value.
     date: :py:class:`datetime.date`, :py:class:`otp.date <onetick.py.date>`, optional
@@ -109,28 +109,30 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
          The timezone of output timestamps.
          Also, when start and/or end arguments are timezone-naive, it will define their timezone.
          If parameter is omitted timestamps of ticks will be formatted
-         with the default :py:attr:`tz<onetick.py.configuration.Config.tz>`.
+         with the default :py:attr:`otp.config.tz<onetick.py.configuration.Config.tz>`.
     context: str, optional
         Allows specification of different contexts from OneTick configuration to connect to.
-        If not set then default :py:attr:`context<onetick.py.configuration.Config.context>` is used.
+        If not set then default :py:attr:`otp.config.context<onetick.py.configuration.Config.context>` is used.
         See :ref:`guide about switching contexts <switching contexts>` for examples.
     username
         The username to make the connection.
-        By default the user which executed the process is used.
+        By default the user which executed the process is used or the value specified in
+        :py:attr:`otp.config.default_username<onetick.py.configuration.Config.default_username>`.
     alternative_username: str
         The username used for authentication.
         Needs to be set only when the tick server is configured to use password-based authentication.
-        By default, :py:attr:`default_auth_username<onetick.py.configuration.Config.default_auth_username>` is used.
+        By default,
+        :py:attr:`otp.config.default_auth_username<onetick.py.configuration.Config.default_auth_username>` is used.
         Not supported for WebAPI mode.
     password: str, optional
         The password used for authentication.
         Needs to be set only when the tick server is configured to use password-based authentication.
         Note: not supported and ignored on older OneTick versions.
-        By default, :py:attr:`default_password<onetick.py.configuration.Config.default_password>` is used.
+        By default, :py:attr:`otp.config.default_password<onetick.py.configuration.Config.default_password>` is used.
     batch_size: int
         number of symbols to run in one batch.
         By default, the value from
-        :py:attr:`default_batch_size<onetick.py.configuration.Config.default_batch_size>` is used.
+        :py:attr:`otp.config.default_batch_size<onetick.py.configuration.Config.default_batch_size>` is used.
         Not supported for WebAPI mode.
     running: bool, optional
         Indicates whether a query is CEP or not. Default is `False`.
@@ -139,7 +141,7 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
     concurrency: int, optional
         The maximum number of CPU cores to use to process the query.
         By default, the value from
-        :py:attr:`default_concurrency<onetick.py.configuration.Config.default_concurrency>` is used.
+        :py:attr:`otp.config.default_concurrency<onetick.py.configuration.Config.default_concurrency>` is used.
     apply_times_daily: bool
         Runs the query for every day in the ``start``-``end`` time range,
         using the time components of ``start`` and ``end`` datetimes.
@@ -195,9 +197,8 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
         If set to True, result will be forced to be a dictionary even if it's returned for a single symbol
     max_expected_ticks_per_symbol: int
         Expected maximum number of ticks per symbol (used for performance optimizations).
-        By default,
-        :py:attr:`max_expected_ticks_per_symbol<onetick.py.configuration.Config.max_expected_ticks_per_symbol>`
-        is used.
+        By default, :py:attr:`otp.config.max_expected_ticks_per_symbol \
+            <onetick.py.configuration.Config.max_expected_ticks_per_symbol>` is used.
         Not supported for WebAPI mode.
     log_symbol: bool
         Log currently executed symbol.
@@ -547,6 +548,7 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
     start, end = _get_start_end(start, end, timezone)
 
     # authentication
+    username = username or otp.config.default_username
     alternative_username = alternative_username or otp.config.default_auth_username
     password = password or otp.config.default_password
     kwargs = {}

{onetick_py-1.168.0 → onetick_py-1.170.0}/src/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-1.168.0 → onetick_py-1.170.0}/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-1.168.0 → onetick_py-1.170.0}/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))