onetick-py 1.177.0__tar.gz → 1.179.0__tar.gz

{onetick_py-1.177.0/src/onetick_py.egg-info → onetick_py-1.179.0}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: onetick-py
-Version: 1.177.0
+Version: 1.179.0
 Summary: Python package that allows you to work with OneTick
 Author-email: solutions <solutions@onetick.com>
 License-Expression: MIT
 Project-URL: Documentation, https://docs.pip.distribution.sol.onetick.com
 Project-URL: OneTick, https://onetick.com
 Project-URL: GitHub, https://github.com/onemarketdata/onetick-py
+Project-URL: Issues, https://github.com/onemarketdata/onetick-py/issues
 Classifier: Topic :: Database :: Front-Ends
 Classifier: Topic :: Scientific/Engineering
 Classifier: Programming Language :: Python :: 3.9

{onetick_py-1.177.0 → onetick_py-1.179.0}/pyproject.toml

@@ -39,6 +39,7 @@ classifiers = [
 Documentation = "https://docs.pip.distribution.sol.onetick.com"
 OneTick = "https://onetick.com"
 GitHub = "https://github.com/onemarketdata/onetick-py"
+Issues = "https://github.com/onemarketdata/onetick-py/issues"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{onetick_py-1.177.0 → onetick_py-1.179.0}/setup.py

@@ -31,6 +31,7 @@ setup(name='onetick-py',
       },
       entry_points={
           'console_scripts': [
+              'onetick-render = onetick.py.utils.render_cli:main',
               'jupyter-onetick_snippets = onetick.doc_utilities.snippets:main',
           ],
       })

{onetick_py-1.177.0 → onetick_py-1.179.0}/src/onetick/py/__init__.py

@@ -192,7 +192,7 @@ from onetick.py.sources import (Tick, TTicks, Ticks, Orders, Trades, NBBO, Quote
                                 Custom, query, Symbols, Empty, DataSource, LocalCSVTicks, SymbologyMapping,
                                 ObSnapshot, ObSnapshotWide, ObSnapshotFlat, ObSummary, ObSize, ObVwap, ObNumLevels,
                                 by_symbol, ODBC, SplitQueryOutputBySymbol, DataFile, PointInTime,
-                                ReadSnapshot, ShowSnapshotList, FindSnapshotSymbols)
+                                ReadSnapshot, ShowSnapshotList, FindSnapshotSymbols, ReadFromDataFrame)
 from onetick.py.utils import adaptive, range, perf
 from onetick.py.session import Session, TestSession, Config, Locator, HTTPSession
 from onetick.py.servers import RemoteTS, LoadBalancing, FaultTolerance

{onetick_py-1.177.0 → onetick_py-1.179.0}/src/onetick/py/_version.py

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

{onetick_py-1.177.0 → onetick_py-1.179.0}/src/onetick/py/compatibility.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass, astuple
 from datetime import datetime
 from typing import Optional
 
+import pandas as pd
 from packaging.version import parse as parse_version
 
 import onetick.py as otp
@@ -103,6 +104,36 @@ def _parse_release_string(release_string: str, build_number: int) -> OnetickVers
     raise ValueError(f"Unknown release type '{release_type}' in release string '{release_string}'")
 
 
+def _get_locator_min_date(db_name, context):
+    graph = otq.GraphQuery(otq.DbShowConfiguredTimeRanges(db_name=db_name).tick_type('ANY')
+                           >> otq.Table(fields='long START_DATE, long END_DATE'))
+    symbols = f'{db_name}::'
+    result = otq.run(graph,
+                     symbols=symbols,
+                     # start and end times don't matter for this query, use some constants
+                     start=datetime(2003, 12, 1),
+                     end=datetime(2003, 12, 1),
+                     # GMT, because start/end timestamp in locator are in GMT
+                     timezone='GMT',
+                     context=context)
+    data = result.output(symbols).data
+    first_date = data['START_DATE'][0]
+    return datetime.fromtimestamp(first_date / 1000)
+
+
+def _get_onetick_version(symbols, context, start, end):
+    node = otq.TickGenerator(bucket_interval=0,
+                             fields='BUILD=GET_ONETICK_VERSION(), RELEASE=GET_ONETICK_RELEASE()')
+    graph = otq.GraphQuery(node.tick_type('DUMMY'))
+    result = otq.run(graph,
+                     symbols=symbols,
+                     start=start,
+                     end=end,
+                     context=context,
+                     timezone='UTC')
+    return result
+
+
 @cache
 def get_onetick_version(db=None, context=None) -> OnetickVersionFromServer:
     """
@@ -132,27 +163,31 @@ def get_onetick_version(db=None, context=None) -> OnetickVersionFromServer:
         s = otp.Session()
     else:
         _ = otli.OneTickLib()
-    p = otq.TickGenerator(bucket_interval=0,
-                          fields='BUILD=GET_ONETICK_VERSION(), RELEASE=GET_ONETICK_RELEASE()')
-    graph = otq.GraphQuery(p.tick_type('DUMMY'))
 
     # if otp.config.default_db is set, then we use it to check compatibility
     # otherwise we use LOCAL database available everywhere
     db = db or otp.config.get('default_db', 'LOCAL')
-    dummy_symbol = f'{db}::'
+    symbols = f'{db}::'
     context = context or otp.config.context
 
-    result = otq.run(graph,
-                     symbols=dummy_symbol,
-                     start=datetime(2003, 12, 1),
-                     end=datetime(2003, 12, 2),
-                     context=context,
-                     timezone='UTC')
-    if s:
-        s.close()
+    try:
+        # let's try some default time range first
+        start = end = datetime(2003, 12, 1)
+        result = _get_onetick_version(symbols, context, start, end)
+    except Exception:
+        if db != 'LOCAL':
+            # for real db we need to set time range correctly
+            # otherwise we may get error "Database locator has a gap"
+            start = end = _get_locator_min_date(db, context)
+            result = _get_onetick_version(symbols, context, start, end)
+        else:
+            raise
+    finally:
+        if s:
+            s.close()
 
-    build_number = result[dummy_symbol]["BUILD"][0]
-    release_string = result[dummy_symbol]["RELEASE"][0]
+    build_number = result[symbols]["BUILD"][0]
+    release_string = result[symbols]["RELEASE"][0]
 
     try:
         onetick_version = _parse_release_string(release_string, build_number=build_number)
@@ -667,7 +702,22 @@ def is_percentile_bug_fixed():
 
 
 def is_limit_ep_supported():
-    return hasattr(otq, 'Limit')
+    # Implemented 0034293: LIMIT ep
+    return (
+        hasattr(otq, 'Limit') and
+        _is_min_build_or_version(1.25, 20241229055942,
+                                 20241018120000, min_update_number=1)
+    )
+
+
+def is_limit_tick_offset_supported():
+    # Implemented OTDEV-37257: LIMIT EP should support TICK_OFFSET parameter
+    return (
+        is_limit_ep_supported() and
+        'tick_offset' in otq.Limit.Parameters.list_parameters() and
+        _is_min_build_or_version(None, None,
+                                 20251010120000, min_update_number=2)
+    )
 
 
 def is_prefer_speed_over_accuracy_supported(**kwargs):
@@ -733,8 +783,11 @@ def is_multi_column_generic_aggregations_supported():
 
 
 def is_max_concurrency_with_webapi_supported():
+    # 0036758: in onetick.query_webapi: max_concurrency is not being saved in otq file when set on otq.Query
+    # 0036759: in onetick.query_webapi:
+    # it's not possible to pass max_concurrency 0 in method otq.run when using otq file
     return _is_min_build_or_version(None, None,
-                                    20250227120000, min_update_number=2)
+                                    20250727120000, min_update_number=3)
 
 
 def is_nanoseconds_fixed_in_run():
@@ -783,12 +836,16 @@ def is_show_db_list_show_description_supported():
 
 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')
+    return hasattr(otq.FindDbSymbols.Parameters, 'prepend_db_name') and _is_min_build_or_version(
+        None, None, 20251010120000,
+    )
 
 
 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')
+    return hasattr(otq.Diff.Parameters, 'show_all_ticks') and _is_min_build_or_version(
+        None, None, 20251010120000,
+    )
 
 
 def is_max_spread_supported():
@@ -796,3 +853,9 @@ def is_max_spread_supported():
     # should also support parameter MAX_SPREAD
     return _is_min_build_or_version(None, None,
                                     20251010120000)
+
+
+def is_not_fixed_bds_484():
+    # BDS-484: seems like timezone is ignored in otq.run in some cases
+    return _is_min_build_or_version(None, None,
+                                    20251010120000, min_update_number=2)

{onetick_py-1.177.0 → onetick_py-1.179.0}/src/onetick/py/core/_source/source_methods/misc.py

@@ -1,9 +1,10 @@
 import functools
 import re
+import warnings
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
-from onetick.py.backports import Literal
 
 import onetick.py as otp
+from onetick.py.backports import Literal
 from onetick.py import types as ott
 from onetick.py import utils
 from onetick.py.core.column import _Column
@@ -1109,16 +1110,26 @@ def book_diff(self: 'Source', include_initial_book: bool = False, inplace=False)
 
 
 @inplace_operation
-def limit(self: 'Source', tick_limit: int, inplace=False) -> Optional['Source']:
+def limit(self: 'Source',
+          tick_limit: int,
+          tick_offset: Optional[int] = None,
+          inplace=False) -> Optional['Source']:
     """
-    Propagates ticks until the count limit is reached. Once the limit is reached,
+    Propagates ticks until the count limit is reached.
+
+    Once the limit is reached,
     hidden ticks will still continue to propagate until the next regular tick appears.
 
     Parameters
     ----------
     tick_limit: int
-        The number of regular ticks to propagate. Must be a non-negative integer or -1, which will mean no limit.
-    inplace : bool
+        The number of regular ticks to propagate.
+        Must be a non-negative integer or -1, which means no limit.
+    tick_offset: int
+        The number of regular ticks to skip before starting to propagate.
+        Must be a non-negative integer.
+        By default no ticks are skipped.
+    inplace: bool
         The flag controls whether operation should be applied inplace or not.
         If ``inplace=True``, then it returns nothing. Otherwise method returns a new modified
         object.
@@ -1134,14 +1145,15 @@ def limit(self: 'Source', tick_limit: int, inplace=False) -> Optional['Source']:
     Examples
     --------
 
-    Basic example
+    Simple example, get first 3 ticks:
 
     .. testcode::
        :skipif: not otp.compatibility.is_limit_ep_supported()
 
        data = otp.Ticks(X=[1, 2, 3, 4, 5, 6])
-       data = data.limit(tick_limit=3)
-       print(otp.run(data))
+       data = data.limit(3)
+       df = otp.run(data)
+       print(df)
 
     .. testoutput::
 
@@ -1150,14 +1162,15 @@ def limit(self: 'Source', tick_limit: int, inplace=False) -> Optional['Source']:
        1 2003-12-01 00:00:00.001  2
        2 2003-12-01 00:00:00.002  3
 
-    Disable limit
+    Disable limit by setting it to -1:
 
     .. testcode::
        :skipif: not otp.compatibility.is_limit_ep_supported()
 
        data = otp.Ticks(X=[1, 2, 3, 4, 5, 6])
-       data = data.limit(tick_limit=-1)
-       print(otp.run(data))
+       data = data.limit(-1)
+       df = otp.run(data)
+       print(df)
 
     .. testoutput::
 
@@ -1168,14 +1181,61 @@ def limit(self: 'Source', tick_limit: int, inplace=False) -> Optional['Source']:
        3 2003-12-01 00:00:00.003  4
        4 2003-12-01 00:00:00.004  5
        5 2003-12-01 00:00:00.005  6
+
+    Setting parameter ``tick_offset`` can be used to skip first ticks before propagating them.
+
+    For example, we can skip first 2 ticks and propagate all other:
+
+    .. testcode::
+       :skipif: not otp.compatibility.is_limit_tick_offset_supported()
+
+       data = otp.Ticks(X=[1, 2, 3, 4, 5, 6])
+       data = data.limit(-1, tick_offset=2)
+       df = otp.run(data)
+       print(df)
+
+    .. testoutput::
+
+                            Time  X
+       0 2003-12-01 00:00:00.002  3
+       1 2003-12-01 00:00:00.003  4
+       2 2003-12-01 00:00:00.004  5
+       3 2003-12-01 00:00:00.005  6
+
+    Or we can return ticks from the middle of the stream
+    by skipping first 2 ticks and then returning next 2 ticks like this:
+
+    .. testcode::
+       :skipif: not otp.compatibility.is_limit_tick_offset_supported()
+
+       data = otp.Ticks(X=[1, 2, 3, 4, 5, 6])
+       data = data.limit(2, tick_offset=2)
+       df = otp.run(data)
+       print(df)
+
+    .. testoutput::
+
+                            Time  X
+       0 2003-12-01 00:00:00.002  3
+       1 2003-12-01 00:00:00.003  4
     """
-    if not hasattr(otq, 'Limit'):
+    if not otp.compatibility.is_limit_ep_supported():
         raise RuntimeError('LIMIT EP isn\'t supported by the current OneTick version.')
 
     if tick_limit < 0 and tick_limit != -1:
         raise ValueError('Negative values, except -1, not allowed as `tick_limit` in `limit` method.')
 
-    self.sink(otq.Limit(tick_limit=tick_limit))
+    ep_kwargs = {}
+    if tick_offset is not None:
+        if not isinstance(tick_offset, int) or tick_offset < 0:
+            raise ValueError("Parameter 'tick_offset' must be non-negative.")
+
+        if not otp.compatibility.is_limit_tick_offset_supported():
+            warnings.warn("Parameter 'tick_offset' is set, but is not supported on this OneTick version")
+        else:
+            ep_kwargs = {'tick_offset': tick_offset}
+
+    self.sink(otq.Limit(tick_limit=tick_limit, **ep_kwargs))
     return self
 
 

{onetick_py-1.177.0 → onetick_py-1.179.0}/src/onetick/py/core/_source/tmp_otq.py

@@ -108,6 +108,14 @@ class TmpOtq:
         res.merge(self)
         return res
 
+    def _get_symbol_dates(self) -> list[str]:
+        # check if any of the saved queries have symbol date set and return them (as strings in %Y%m%d format)
+        return [
+            utils.symbol_date_to_str(query_params['symbol_date'])
+            for _, query_params in self.queries.values()
+            if 'symbol_date' in query_params
+        ]
+
     def save_to_file(self, query=None, query_name="main_query", file_path=None, file_suffix="",
                      start=None, end=None, start_time_expression=None, end_time_expression=None, timezone=None,
                      running_query_flag=None,

{onetick_py-1.177.0 → onetick_py-1.179.0}/src/onetick/py/core/source.py

@@ -432,7 +432,7 @@ class Source:
                end_time_expression=None,
                symbol_date=None):
         """
-        Save data source to .otq file and return path to the saved file.
+        Save :class:`otp.Source <onetick.py.Source>` object to .otq file and return path to the saved file.
 
         Parameters
         ----------
@@ -474,10 +474,17 @@ class Source:
 
         Returns
         -------
-
         result: str
             Relative (if ``file_name`` is relative) or absolute path to the created query
             in the format ``file_name::query_name``
+
+        Examples
+        --------
+        Create the .otq file from a :class:`otp.Source <onetick.py.Source>` object:
+
+        >>> t = otp.Tick(A=1)
+        >>> t.to_otq()  # doctest: +SKIP
+        '/tmp/test_user/run_20251202_181018_11054/impetuous-bullfrog.to_otq.otq::query'
         """
         if raw is not None:
             warnings.warn('The "raw" flag is deprecated and makes no effect', FutureWarning)
@@ -635,7 +642,22 @@ class Source:
                                                  timezone=timezone,
                                                  symbol_date=symbol_date)
 
-        return query_to_run, require_dict, node_name
+        # PY-1423: we should set symbol_date in otp.run always
+        symbol_date_to_run = None
+        if symbol_date is not None:
+            symbol_date_to_run = utils.symbol_date_to_str(symbol_date)
+        else:
+            symbol_dates_in_tmp_otq = obj._tmp_otq._get_symbol_dates()
+            if symbol_dates_in_tmp_otq:
+                symbol_date_to_run = symbol_dates_in_tmp_otq[0]
+                if len(set(symbol_dates_in_tmp_otq)) > 1:
+                    warnings.warn(
+                        f'There are different symbol dates in resulting .otq file: {set(symbol_dates_in_tmp_otq)}.'
+                        'But no symbol date were specified in otp.run.\n'
+                        f'In this case the first symbol_date ({symbol_date_to_run}) will be used automatically.'
+                    )
+
+        return query_to_run, require_dict, node_name, symbol_date_to_run
 
     def __call__(self, *args, **kwargs):
         """

{onetick_py-1.177.0 → onetick_py-1.179.0}/src/onetick/py/db/_inspection.py

@@ -1,7 +1,9 @@
 import itertools
 import warnings
-from typing import Union, Iterable, Tuple, Optional, Any, Literal
+from collections import defaultdict
+from typing import Union, Iterable, Tuple, Optional, Literal
 from datetime import date as dt_date, datetime, timedelta
+from functools import wraps
 
 import pandas as pd
 from dateutil.tz import gettz
@@ -19,6 +21,39 @@ def _datetime2date(dt: Union[dt_date, datetime]) -> dt_date:
     return dt_date(dt.year, dt.month, dt.day)
 
 
+def _method_cache(meth):
+    """
+    Cache the output of class method.
+    Cache is created inside of the self object (in self.__cache property)
+    and will be deleted when self object is destroyed.
+
+    This is a rewrite of functools.cache,
+    but it doesn't add self argument to cache key and thus doesn't keep reference to self forever.
+    """
+    @wraps(meth)
+    def wrapper(self, *args, **kwargs):
+
+        # cache key is a tuple of all arguments
+        key = args
+        for kw_tup in kwargs.items():
+            key += kw_tup
+        key = hash(key)
+
+        if not hasattr(self, '__cache'):
+            self.__cache = defaultdict(dict)
+
+        method_cache = self.__cache[meth.__name__]
+
+        miss = object()
+        result = method_cache.get(key, miss)
+        if result is miss:
+            result = meth(self, *args, **kwargs)
+            method_cache[key] = result
+        return result
+
+    return wrapper
+
+
 class DB:
 
     """
@@ -37,7 +72,11 @@ class DB:
         self._locator_date_ranges = None
 
     def __eq__(self, obj):
-        return str(self) == str(obj)
+        return all((
+            self.name == obj.name,
+            self.description == obj.description,
+            self.context == obj.context,
+        ))
 
     def __lt__(self, obj):
         return str(self) < str(obj)
@@ -45,6 +84,7 @@ class DB:
     def __str__(self):
         return self.name
 
+    @_method_cache
     def access_info(self, deep_scan=False, username=None) -> Union[pd.DataFrame, dict]:
         """
         Get access info for this database and ``username``.
@@ -111,13 +151,19 @@ class DB:
             >> otq.WhereClause(where=f'DB_NAME = "{name}"')
         )
         graph = otq.GraphQuery(node)
+
+        self._set_intervals()
+        # start and end times don't matter, but need to fit in the configured time ranges
+        start, end = self._locator_date_ranges[-1]
+
         df = otp.run(graph,
-                     symbols='LOCAL::',
-                     # start and end times don't matter
-                     start=db_constants.DEFAULT_START_DATE,
-                     end=db_constants.DEFAULT_END_DATE,
+                     symbols=f'{self.name}::',
+                     start=start,
+                     end=end,
                      # and timezone is GMT, because timestamp parameters in ACL are in GMT
                      timezone='GMT',
+                     # ACCESS_INFO can return ACL violation error if we use database name as symbol
+                     query_properties={'IGNORE_TICKS_IN_UNENTITLED_TIME_RANGE': 'TRUE'},
                      username=username,
                      context=self.context)
         if not df.empty:
@@ -255,6 +301,20 @@ class DB:
         end = start + otp.Day(1)
         return self._fit_time_interval_in_acl(start, end, timezone)
 
+    @_method_cache
+    def _show_configured_time_ranges(self):
+        graph = otq.GraphQuery(otq.DbShowConfiguredTimeRanges(db_name=self.name).tick_type("ANY")
+                               >> otq.Table(fields='long START_DATE, long END_DATE'))
+        result = otp.run(graph,
+                         symbols=f'{self.name}::',
+                         # start and end times don't matter for this query, use some constants
+                         start=db_constants.DEFAULT_START_DATE,
+                         end=db_constants.DEFAULT_END_DATE,
+                         # GMT, because start/end timestamp in locator are in GMT
+                         timezone='GMT',
+                         context=self.context)
+        return result
+
     def _set_intervals(self):
         """
         Finds all date ranges from locators.
@@ -264,18 +324,7 @@ class DB:
         """
 
         if self._locator_date_ranges is None:
-            graph = otq.GraphQuery(otq.DbShowConfiguredTimeRanges(db_name=self.name).tick_type("ANY")
-                                   >> otq.Table(fields='long START_DATE, long END_DATE'))
-
-            result = otp.run(graph,
-                             symbols=f'{self.name}::',
-                             # start and end times don't matter for this query, use some constants
-                             start=db_constants.DEFAULT_START_DATE,
-                             end=db_constants.DEFAULT_END_DATE,
-                             # GMT, because start/end timestamp in locator are in GMT
-                             timezone='GMT',
-                             context=self.context)
-
+            result = self._show_configured_time_ranges()
             date_ranges = []
 
             tz_gmt = gettz('GMT')
@@ -316,10 +365,20 @@ class DB:
 
     def _show_loaded_time_ranges(self, start, end, only_last=False, prefer_speed_over_accuracy=False):
         kwargs = {}
+        # PY-1421: we aim to make this query as fast as possible
+        # There are two problems with this EP:
+        #   1. executing this query without using cache
+        #      and/or without setting prefer_speed_over_accuracy parameter
+        #      may be very slow for big time range
+        #   2. using cache sometimes returns not precise results
+        # So in case prefer_speed_over_accuracy parameter is available we are disabling cache.
         if prefer_speed_over_accuracy:
-            kwargs['prefer_speed_over_accuracy'] = prefer_speed_over_accuracy
+            kwargs['prefer_speed_over_accuracy'] = True
+            kwargs['use_cache'] = False
+        else:
+            kwargs['use_cache'] = True
 
-        eps = otq.DbShowLoadedTimeRanges(use_cache=True, **kwargs).tick_type('ANY')
+        eps = otq.DbShowLoadedTimeRanges(**kwargs).tick_type('ANY')
         eps = eps >> otq.WhereClause(where='NUM_LOADED_PARTITIONS > 0')
         if only_last:
             eps = eps >> otq.LastTick()
@@ -528,32 +587,45 @@ class DB:
         ['QTE', 'TRD']
         """
         date = self.last_date if date is None else date
+
         if timezone is None:
             timezone = configuration.config.tz
-        time_params: dict[str, Any] = {}
 
-        if date is not None:
-            time_params['start'], time_params['end'] = self._fit_date_in_acl(date, timezone=timezone)
+        if date is None:
+            # in the usual case it would mean that there is no data in the database,
+            # but _show_loaded_time_ranges doesn't return dates for database views
+            # in this case let's just try to get the database schema with default time range
+            start = end = utils.adaptive
+            # also it seems that show_schema=True doesn't work for views either
+            show_schema = False
+        else:
+            start, end = self._fit_date_in_acl(date, timezone=timezone)  # type: ignore[assignment]
+            show_schema = True
 
         # PY-458: don't use cache, it can return different result in some cases
-        result = otp.run(otq.DbShowTickTypes(use_cache=False,
-                                             show_schema=False,
-                                             include_memdb=True),
-                         symbols=f'{self.name}::',
-                         **time_params,
-                         timezone=timezone,
-                         context=self.context)
-
+        result = self._get_schema(use_cache=False, start=start, end=end, timezone=timezone, show_schema=show_schema)
         if len(result) == 0:
             return []
 
-        return result['TICK_TYPE_NAME'].tolist()
+        return result['TICK_TYPE_NAME'].unique().tolist()
 
     def min_locator_date(self):
         self._set_intervals()
         min_date = min(obj[0] for obj in self._locator_date_ranges)
         return _datetime2date(min_date)
 
+    @_method_cache
+    def _get_schema(self, start, end, timezone, use_cache, show_schema):
+        ep = otq.DbShowTickTypes(use_cache=use_cache,
+                                 show_schema=show_schema,
+                                 include_memdb=True)
+        return otp.run(ep,
+                       symbols=f'{self.name}::',
+                       start=start,
+                       end=end,
+                       timezone=timezone,
+                       context=self.context)
+
     def schema(self, date=None, tick_type=None, timezone=None, check_index_file=utils.adaptive) -> dict[str, type]:
         """
         Gets the schema of the database.
@@ -615,25 +687,18 @@ class DB:
 
         start, end = self._fit_date_in_acl(date, timezone=timezone)
 
-        # TODO: refactor into global method, use in tick_types()
-        def get_schema(use_cache: bool = True):
-            return otp.run(otq.DbShowTickTypes(use_cache=use_cache,
-                                               show_schema=True,
-                                               include_memdb=True)
-                           >> otq.WhereClause(where=f'TICK_TYPE_NAME="{tick_type}"'),
-                           symbols=f'{self.name}::',
-                           start=start,
-                           end=end,
-                           timezone=timezone,
-                           context=self.context)
-
-        result = get_schema(use_cache=True)
+        kwargs = dict(
+            start=start, end=end, timezone=timezone, show_schema=True,
+        )
+        # PY-458, BEXRTS-1220, PY-1421
+        # the results of the query may vary depending on using use_cache parameter, so we are trying both
+        result = self._get_schema(use_cache=False, **kwargs)
         if result.empty:
-            # in case cache settings in database are bad (e.g. BEXRTS-1220)
-            result = get_schema(use_cache=False)
+            result = self._get_schema(use_cache=True, **kwargs)
 
-        fields: Iterable
+        fields: Iterable = []
         if len(result):
+            result = result[result['TICK_TYPE_NAME'] == tick_type]
             # filter schema by date
             date_to_filter = None
             if orig_date:
@@ -648,8 +713,6 @@ class DB:
             fields = zip(result['FIELD_NAME'].tolist(),
                          result['FIELD_TYPE_NAME'].tolist(),
                          result['FIELD_SIZE'].tolist())
-        else:
-            fields = []
 
         schema = {}