onetick-py 1.182.0__tar.gz → 1.184.0__tar.gz

{onetick_py-1.182.0/src/onetick_py.egg-info → onetick_py-1.184.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onetick-py
-Version: 1.182.0
+Version: 1.184.0
 Summary: Python package that allows you to work with OneTick
 Author-email: solutions <solutions@onetick.com>
 License-Expression: MIT
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Environment :: Console
 Requires-Python: >=3.9

{onetick_py-1.182.0 → onetick_py-1.184.0}/pyproject.toml

@@ -28,9 +28,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
-    # OneTick server and onetick.query-webapi do not support it yet
-    # mantis [onetick 0037046]: Add support of python 3.14
-    # "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.14",
     "Operating System :: OS Independent",
     "Environment :: Console",
 ]

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/locator_parser/locator.py

@@ -135,6 +135,11 @@ def parse_locator(reader, writer, action=DoNothing(), recursively=False):
         cep_tick_servers_p(reader, writer, action)
         includes_p(reader, writer, action)
 
+        # force reset not full conditions match after processing root tags
+        if 0 < list(action.conditions.values()).count(True) < len(action.conditions):
+            for k in action.conditions:
+                action.conditions[k] = False
+
 
 # ----------------------------------------- #
 # set parent

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/_version.py

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

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/aggregations/__init__.py

@@ -3,7 +3,7 @@ from .functions import (compute, max, min, high_tick, low_tick, high_time, low_t
                         ob_num_levels, ob_size, ob_snapshot, ob_snapshot_wide, ob_snapshot_flat, ob_summary, ob_vwap,
                         generic, correlation, option_price, ranking, variance, percentile, find_value_for_percentile,
                         exp_w_average, exp_tw_average, standardized_moment, portfolio_price, multi_portfolio_price,
-                        return_ep, implied_vol, linear_regression)
+                        return_ep, implied_vol, linear_regression, partition_evenly_into_groups)
 
 try:
     from .num_distinct import num_distinct

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/aggregations/_docs.py

@@ -858,6 +858,44 @@ _expiration_date_field_doc = param_doc(
     annotation=Union[str, Column],
     default='',
 )
+_dependent_variable_field_name_doc = param_doc(
+    name='dependent_variable_field_name',
+    desc='''
+    Specifies the attribute used as the dependent variable in the calculation of the slope and intercept.
+    The ticks in the input time series must contain this attribute.
+    ''',
+    annotation=Union[str, Column],
+)
+_independent_variable_field_name_doc = param_doc(
+    name='independent_variable_field_name',
+    desc='''
+    Specifies the attribute used as the independent variable in the calculation of the slope and intercept.
+    The ticks in the input time series must contain this attribute.
+    ''',
+    annotation=Union[str, Column],
+)
+_field_to_partition_doc = param_doc(
+    name='field_to_partition',
+    desc='''
+    Specifies the tick field that will be partitioned.
+    ''',
+    annotation=Union[str, Column],
+)
+_weight_field_doc = param_doc(
+    name='weight_field',
+    desc='''
+    Specifies the tick field, the values of which are evaluated as weight; and then, the partitioning is be applied,
+    so that the total weight of the groups are as close as possible.
+    ''',
+    annotation=Union[str, Column],
+)
+_number_of_groups_doc = param_doc(
+    name='number_of_groups',
+    desc='''
+    Specifies the target number of partitions to which the tick should be divided.
+    ''',
+    annotation=int,
+)
 
 
 class DocMetaclass(type):

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/aggregations/functions.py

@@ -9,7 +9,7 @@ from .other import (First, Last, FirstTime, LastTime, Count, Vwap, FirstTick,
                     Median, Correlation, OptionPrice, Ranking, Variance,
                     Percentile, FindValueForPercentile, ExpWAverage, ExpTwAverage,
                     StandardizedMoment, PortfolioPrice, MultiPortfolioPrice, Return, ImpliedVol,
-                    LinearRegression)
+                    LinearRegression, PartitionEvenlyIntoGroups)
 from .order_book import (ObSnapshot, OB_SNAPSHOT_DOC_PARAMS,
                          ObSnapshotWide, OB_SNAPSHOT_WIDE_DOC_PARAMS,
                          ObSnapshotFlat, OB_SNAPSHOT_FLAT_DOC_PARAMS,
@@ -64,7 +64,13 @@ from ._docs import (_column_doc,
                     _strike_price_field_doc,
                     _days_in_year_doc,
                     _days_till_expiration_field_doc,
-                    _expiration_date_field_doc)
+                    _expiration_date_field_doc,
+                    _dependent_variable_field_name_doc,
+                    _independent_variable_field_name_doc,
+                    _field_to_partition_doc,
+                    _weight_field_doc,
+                    _number_of_groups_doc)
+
 from onetick.py.docs.utils import docstring, param_doc
 
 # This module mostly focused on providing annotations and documentation for end user
@@ -2183,7 +2189,8 @@ def implied_vol(*args, **kwargs):
     return ImpliedVol(*args, **kwargs)
 
 
-@docstring(parameters=[_running_doc, _all_fields_doc, _bucket_interval_doc, _bucket_time_doc,
+@docstring(parameters=[_dependent_variable_field_name_doc, _independent_variable_field_name_doc,
+                       _running_doc, _all_fields_doc, _bucket_interval_doc, _bucket_time_doc,
                        _bucket_units_doc, _bucket_end_condition_doc, _end_condition_per_group_doc,
                        _boundary_tick_bucket_doc,
                        ])
@@ -2214,3 +2221,38 @@ def linear_regression(*args, **kwargs):
     0 2003-12-04   -0.3        6.7
     """
     return LinearRegression(*args, **kwargs)
+
+
+@docstring(parameters=[_field_to_partition_doc, _weight_field_doc, _number_of_groups_doc,
+                       _running_doc, _bucket_interval_doc, _bucket_time_doc,
+                       _bucket_units_doc, _bucket_end_condition_doc, _boundary_tick_bucket_doc,
+                       ])
+def partition_evenly_into_groups(*args, **kwargs):
+    """
+    ``PARTITION_EVENLY_INTO_GROUPS`` aggregation.
+
+     For each bucket, this EP breaks ticks into the specified number of groups (``number_of_groups``)
+     by the specified field (``field_to_partition``) in a way that the sums
+     of the specified weight fields (``weight_field``) in each group are as close as possible.
+
+    See also
+    --------
+    **PARTITION_EVENLY_INTO_GROUPS** OneTick event processor
+
+    Examples
+    --------
+
+    >>> data = otp.Ticks(X=['A', 'B', 'A', 'C', 'D'], SIZE=[10, 30, 20, 15, 14])
+    >>> data = data.partition_evenly_into_groups(
+    ...     field_to_partition=data['X'],
+    ...     weight_field=data['SIZE'],
+    ...     number_of_groups=3,
+    ... )
+    >>> otp.run(data)
+            Time FIELD_TO_PARTITION  GROUP_ID
+    0 2003-12-04                  A         0
+    1 2003-12-04                  B         1
+    2 2003-12-04                  C         2
+    3 2003-12-04                  D         2
+    """
+    return PartitionEvenlyIntoGroups(*args, **kwargs)

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/aggregations/other.py

@@ -1012,3 +1012,56 @@ class LinearRegression(_Aggregation, _MultiColumnAggregation):
             'SLOPE': float,
             'INTERCEPT': float,
         }
+
+
+class PartitionEvenlyIntoGroups(_Aggregation, _MultiColumnAggregation):
+    NAME = 'PARTITION_EVENLY_INTO_GROUPS'
+    EP = otq.PartitionEvenlyIntoGroups
+
+    FIELDS_MAPPING = deepcopy(_Aggregation.FIELDS_MAPPING)
+    FIELDS_MAPPING['field_to_partition'] = 'FIELD_TO_PARTITION'
+    FIELDS_MAPPING['weight_field'] = 'WEIGHT_FIELD'
+    FIELDS_MAPPING['number_of_groups'] = 'NUMBER_OF_GROUPS'
+
+    FIELDS_TO_SKIP = ['column_name', 'output_field_name']
+
+    def __init__(
+        self,
+        field_to_partition: Union[_Column, str, OnetickParameter],
+        weight_field: Union[_Column, str, OnetickParameter],
+        number_of_groups: Union[int, OnetickParameter],
+        *args, **kwargs,
+    ):
+        if isinstance(field_to_partition, _Column):
+            field_to_partition = str(field_to_partition)
+        if isinstance(weight_field, _Column):
+            weight_field = str(weight_field)
+
+        if number_of_groups <= 0:
+            raise ValueError('Parameter `number_of_groups` value should be greater than zero')
+
+        self.field_to_partition = field_to_partition
+        self.weight_field = weight_field
+        self.number_of_groups = number_of_groups
+
+        super().__init__(_Column('TIMESTAMP'), *args, **kwargs)
+
+    def validate_input_columns(self, src: 'Source'):
+        super().validate_input_columns(src)
+
+        for column in [self.field_to_partition, self.weight_field]:
+            if isinstance(column, OnetickParameter):
+                continue
+
+            if column not in src.schema:
+                raise TypeError(f"Aggregation `{self.NAME}` uses column `{column}` as input, which doesn't exist")
+
+        for out_field in ['FIELD_TO_PARTITION', 'GROUP_ID']:
+            if out_field in src.schema:
+                raise TypeError(f"Field `{out_field}`, which is `{self.NAME}` aggregation output column, is in schema.")
+
+    def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
+        return {
+            'FIELD_TO_PARTITION': str,
+            'GROUP_ID': int,
+        }

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/compatibility.py

@@ -1,14 +1,13 @@
 import os
 import warnings
 from dataclasses import dataclass, astuple
-from datetime import datetime
+from datetime import datetime, timezone as dt_timezone
 from typing import Optional
 
-import pandas as pd
 from packaging.version import parse as parse_version
 
 import onetick.py as otp
-from onetick.py.otq import otq, otli
+from onetick.py.otq import otq, otli, pyomd
 from onetick.py.backports import cache
 
 
@@ -104,34 +103,57 @@ 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):
+def _get_locator_intervals(db_name, context) -> list[tuple[datetime, datetime]]:
     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}::'
+
+    # setting this is important so we don't get access error
+    qp = pyomd.QueryProperties()
+    qp.set_property_value('IGNORE_TICKS_IN_UNENTITLED_TIME_RANGE', 'TRUE')
+
     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',
+                     # timezone is irrelevant, because times are returned as epoch numbers
+                     timezone='UTC',
+                     query_properties=qp,
                      context=context)
     data = result.output(symbols).data
-    first_date = data['START_DATE'][0]
-    return datetime.fromtimestamp(first_date / 1000)
+    if not data:
+        raise RuntimeError(f"Database '{db_name}' doesn't have locations")
+    return [
+        (
+            datetime.fromtimestamp(data['START_DATE'][i] / 1000, dt_timezone.utc).replace(tzinfo=None),
+            datetime.fromtimestamp(data['END_DATE'][i] / 1000, dt_timezone.utc).replace(tzinfo=None),
+        )
+        for i in range(len(data['START_DATE']))
+    ]
 
 
-def _get_onetick_version(symbols, context, start, end):
+def _get_onetick_version(db_name, context, start, end) -> dict:
     node = otq.TickGenerator(bucket_interval=0,
                              fields='BUILD=GET_ONETICK_VERSION(), RELEASE=GET_ONETICK_RELEASE()')
     graph = otq.GraphQuery(node.tick_type('DUMMY'))
+    symbols = f'{db_name}::'
+
+    # setting this is important so we don't get access error
+    qp = pyomd.QueryProperties()
+    qp.set_property_value('IGNORE_TICKS_IN_UNENTITLED_TIME_RANGE', 'TRUE')
+
     result = otq.run(graph,
                      symbols=symbols,
                      start=start,
                      end=end,
                      context=context,
+                     query_properties=qp,
                      timezone='UTC')
-    return result
+    data = result.output(symbols).data
+    if not data:
+        raise RuntimeError(f"Can't get OneTick version from database '{db_name}'")
+    return data
 
 
 @cache
@@ -166,28 +188,33 @@ def get_onetick_version(db=None, context=None) -> OnetickVersionFromServer:
 
     # 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')
-    symbols = f'{db}::'
+    db_name = db or otp.config.get('default_db', 'LOCAL')
     context = context or otp.config.context
 
     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':
+        if db_name == 'LOCAL':
+            # for LOCAL db any date will do
+            start = end = datetime(2003, 12, 1)
+            result_data = _get_onetick_version(db_name, context, start, end)
+        else:
             # 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
+            locator_intervals = _get_locator_intervals(db_name, context)
+            for i, (start, end) in enumerate(locator_intervals):
+                try:
+                    result_data = _get_onetick_version(db_name, context, start, end)
+                    break
+                except Exception as e:
+                    if i < len(locator_intervals) - 1:
+                        continue
+                    else:
+                        raise e
     finally:
         if s:
             s.close()
 
-    build_number = result[symbols]["BUILD"][0]
-    release_string = result[symbols]["RELEASE"][0]
+    build_number = result_data["BUILD"][0]
+    release_string = result_data["RELEASE"][0]
 
     try:
         onetick_version = _parse_release_string(release_string, build_number=build_number)

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/core/_csv_inspector.py

@@ -44,7 +44,7 @@ def inspect_by_pandas(path_to_csv, first_line_is_title=True, names=None, field_d
         first_column = "COLUMN_0"
         if names:
             first_column = names[0]
-        if len(df) > 0 and len(df.columns) > 0 and df.dtypes[first_column] == np.dtype("O"):
+        if len(df) > 0 and len(df.columns) > 0 and pd.api.types.is_string_dtype(df.dtypes[first_column]):
             if df[first_column][0].startswith("#"):
                 raise ValueError(
                     "If first line of CSV starts with #, you must set first_line_is_title=True, "

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/core/_source/source_methods/aggregations.py

@@ -615,6 +615,12 @@ def linear_regression(self: 'Source', *args, **kwargs):
     pass
 
 
+@copy_method(aggregations.functions.partition_evenly_into_groups)
+def partition_evenly_into_groups(self: 'Source', *args, **kwargs):
+    # method implementation is copied by decorator
+    pass
+
+
 @inplace_operation
 def process_by_group(
     self: 'Source', process_source_func, group_by=None, source_name=None, num_threads=None, inplace=False

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/core/_source/source_methods/debugs.py

@@ -103,7 +103,9 @@ def throw(
     >>> t = otp.Ticks(A=[1, 2, 3, 4])
     >>> t = t.throw(message='warning A=1', scope='symbol', error_code=2, where=(t['A']==1))
     >>> t = t.throw(message='error A=3', scope='symbol', error_code=1502, where=(t['A']==3))
-    >>> otp.run(t)
+    >>> otp.run(t)  # doctest: +SKIP
+    UserWarning: Symbol error: [2] warning A=1
+    UserWarning: Symbol error: [1502] error A=3
                          Time  A
     0 2003-12-01 00:00:00.000  1
     1 2003-12-01 00:00:00.001  2
@@ -246,7 +248,17 @@ def dump(
 
     # print <no data> in case there are 0 ticks
     if hasattr(otq, 'InsertAtEnd'):
-        self_c.sink(otq.InsertAtEnd(delimiter_name='AT_END'))
+        ep_kwargs = {}
+        if {'propagate_ticks', 'insert_if_input_is_empty', 'fields_of_added_tick'}.issubset(
+            otq.InsertAtEnd.Parameters.list_parameters()
+        ):
+            # if supported, fix PY-1433
+            ep_kwargs = dict(
+                propagate_ticks=True,
+                insert_if_input_is_empty=True,
+                fields_of_added_tick='AT_END=1'
+            )
+        self_c.sink(otq.InsertAtEnd(delimiter_name='AT_END', **ep_kwargs))
         self_c.schema['AT_END'] = int
         self_c.state_vars['COUNT'] = otp.state.var(0, scope='branch')
         self_c.state_vars['COUNT'] += 1

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/core/source.py

@@ -5,7 +5,7 @@ import warnings
 from collections import defaultdict
 from datetime import datetime, date
 import pandas as pd
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Union
 
 from onetick.py.otq import otq
 
@@ -979,6 +979,8 @@ class Source:
         render_debug_info: bool = False,
         debug: bool = False,
         graphviz_compat_mode: bool = False,
+        font_family: Optional[str] = None,
+        font_size: Optional[Union[int, float]] = None,
         **kwargs,
     ):
         """
@@ -1011,6 +1013,12 @@ class Source:
         graphviz_compat_mode: bool
             Change internal parameters of result graph for better compatibility with old `Graphviz` versions.
             Could produce larger and less readable graphs.
+        font_family: str, optional
+            Font name
+
+            Default: **Monospace**
+        font_size: int, float, str, optional
+            Font size
         kwargs:
             Additional arguments to be passed to :py:meth:`onetick.py.Source.to_otq` method (except
             ``file_name``, ``file_suffix`` and ``query_name`` parameters)
@@ -1043,7 +1051,7 @@ class Source:
         otq_path = self.to_otq(**kwargs)
         return render_otq(
             otq_path, image_path, output_format, load_external_otqs, view, line_limit, parse_eval_from_params,
-            render_debug_info, debug, graphviz_compat_mode,
+            render_debug_info, debug, graphviz_compat_mode, font_family, font_size,
         )
 
     def copy(self, ep=None, columns=None, deep=False) -> 'Source':
@@ -1652,7 +1660,7 @@ class Source:
         ranking, percentile, find_value_for_percentile,
         exp_w_average, exp_tw_average, standardized_moment,
         portfolio_price, multi_portfolio_price, return_ep, implied_vol,
-        linear_regression,
+        linear_regression, partition_evenly_into_groups,
         process_by_group,
     )
     from ._source.source_methods.joins import (  # type: ignore[misc]

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/db/_inspection.py

@@ -165,7 +165,9 @@ class DB:
                      # 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)
+                     context=self.context,
+                     # don't print symbol error from onetick about start/end time adjusted due to entitlement checks
+                     print_symbol_errors=False)
         if not df.empty:
             df = df.drop(columns='Time')
         if deep_scan:

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/license.py

@@ -114,7 +114,7 @@ class Server(_LicenseBase):
         if file is None:
             file = utils.TmpFile()
         else:
-            if isinstance(reload, pd.tseries.offsets.Tick):
+            if isinstance(reload, pd.offsets.Tick):
                 modify = datetime.fromtimestamp(os.path.getmtime(file))
                 current = datetime.now()
                 diff_ms = (current - modify).total_seconds() * 1000000

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/run.py

@@ -60,7 +60,8 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
         max_expected_ticks_per_symbol: Optional[int] = None,
         log_symbol: Union[bool, Type[utils.default]] = utils.default,
         encoding: Optional[str] = None,
-        manual_dataframe_callback: bool = False):
+        manual_dataframe_callback: bool = False,
+        print_symbol_errors: bool = True):
     """
     Executes a query and returns its result.
 
@@ -214,6 +215,9 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
         Create dataframe manually with ``callback`` mode.
         Only works if ``output_structure='df'`` is specified and parameter ``callback`` is not.
         May improve performance in some cases.
+    print_symbol_errors_from_onetick: bool
+        Applicable only when ``output_structure`` is set to *df*.
+        Print symbol errors from OneTick as python warnings.
 
     Returns
     -------
@@ -614,7 +618,8 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
         _process_empty_results(result, query_schema, output_structure)
 
     return _format_call_output(result, output_structure=output_structure,
-                               require_dict=require_dict, node_names=node_names)
+                               require_dict=require_dict, node_names=node_names,
+                               print_symbol_errors=print_symbol_errors)
 
 
 async def run_async(*args, **kwargs):
@@ -698,7 +703,7 @@ def _filter_returned_map_by_node(result, _node_names):
 
 def _filter_returned_list_by_node(result, node_names):
     """
-    Here, result has the following format: [(symbol, data_1, data_2, node_name)]
+    Here, result has the following format: [(symbol, ticks_data, error_data, node_name)]
     We need to filter by correct node_names
     """
     if not node_names:
@@ -708,12 +713,12 @@ def _filter_returned_list_by_node(result, node_names):
 
     res = []
     empty_result = True
-    for symbol, data_1, data_2, node, *_ in result:
-        if len(data_1) > 0:
+    for symbol, ticks_data, error_data, node, *_ in result:
+        if len(ticks_data) > 0:
             empty_result = False
         if node in node_names:
             node_found = True
-            res.append((symbol, data_1, data_2, node))
+            res.append((symbol, ticks_data, error_data, node))
 
     if not empty_result and not node_found:
         # TODO: Do we even want to raise it?
@@ -721,19 +726,19 @@ def _filter_returned_list_by_node(result, node_names):
     return res
 
 
-def _form_dict_from_list(data_list, output_structure):
+def _form_dict_from_list(data_list, output_structure, print_symbol_errors):
     """
-    Here, data_list has the following format: [(symbol, data_1, data_2, node_name), ...]
+    Here, data_list has the following format: [(symbol, ticks_data, error_data, node_name), ...]
     We need to create the following result:
-    either {symbol: DataFrame(data_1)} if there is only one result per symbol
-    or {symbol: [DataFrame(data_1)]} if there are multiple results for symbol for a single node_name
-    or {symbol: {node_name: DataFrame(data_1)}} if there are single results for multiple node names for a symbol
-    or {symbol: {node_name: [DataFrame(data_1)]}} if there are multiple results for multiple node names for a symbol
+    either {symbol: DataFrame(ticks_data)} if there is only one result per symbol
+    or {symbol: [DataFrame(ticks_data)]} if there are multiple results for symbol for a single node_name
+    or {symbol: {node_name: DataFrame(ticks_data)}} if there are single results for multiple node names for a symbol
+    or {symbol: {node_name: [DataFrame(ticks_data)]}} if there are multiple results for multiple node names for a symbol
     """
 
     def form_node_name_dict(lst):
         """
-        lst is a lit of (node, dataframe)
+        lst is a list of (node, dataframe)
         """
         d = defaultdict(list)
         for node, df in lst:
@@ -760,7 +765,12 @@ def _form_dict_from_list(data_list, output_structure):
             return polars.DataFrame()
 
     symbols_dict = defaultdict(list)
-    for symbol, data, _, node, *_ in data_list:
+    for symbol, data, error_data, node, *_ in data_list:
+
+        if print_symbol_errors:
+            for err_code, err_msg, *_ in error_data:
+                warnings.warn(f"Symbol error: [{err_code}] {err_msg}")
+
         df = get_dataframe(data)
 
         list_item = (node, df)
@@ -772,7 +782,7 @@ def _form_dict_from_list(data_list, output_structure):
     return dict(symbols_dict)
 
 
-def _format_call_output(result, output_structure, node_names, require_dict):
+def _format_call_output(result, output_structure, node_names, require_dict, print_symbol_errors):
     """Formats output of otq.run() according to passed parameters.
     See parameters' description for more information
 
@@ -795,6 +805,8 @@ def _format_call_output(result, output_structure, node_names, require_dict):
     require_dict: bool
         If True, forces output for output_structure='df' to always be a dictionary, even if only one symbol is returned
         Has no effect for other values of output_structure
+    print_symbol_errors: bool
+        Print OneTick symbol errors in when ``output_structure`` is set to 'df' or not.
 
     Returns
     ----------
@@ -811,7 +823,7 @@ def _format_call_output(result, output_structure, node_names, require_dict):
 
     # "df" output structure implies that raw results came as a list
     result_list = _filter_returned_list_by_node(result, node_names)
-    result_dict = _form_dict_from_list(result_list, output_structure)
+    result_dict = _form_dict_from_list(result_list, output_structure, print_symbol_errors)
 
     if len(result_dict) == 1 and not require_dict:
         return list(result_dict.values())[0]

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/sources/ticks.py

@@ -572,7 +572,7 @@ def Ticks(data=None,  # NOSONAR
         offset_values = []
         offset_parts = []
         for ofv in data['offset']:
-            if isinstance(ofv, ott.offsets.Tick):
+            if isinstance(ofv, pd.offsets.BaseOffset):
                 offset_values.append(ofv.n)
                 try:
                     str_repr = str(ofv.datepart)[1:-1]

{onetick_py-1.182.0 → onetick_py-1.184.0}/src/onetick/py/types.py

@@ -1211,7 +1211,12 @@ class datetime(AbstractTime):
             )
         if isinstance(first_arg, (datetime, date)):
             first_arg = first_arg.ts
-        result = pd.Timestamp(first_arg, tzinfo=tzinfo, tz=tz)
+        kwargs = {}
+        if tzinfo is not None:
+            kwargs['tzinfo'] = tzinfo
+        if tz is not None:
+            kwargs['tz'] = tz
+        result = pd.Timestamp(first_arg, **kwargs)
         return result
 
     @property
@@ -1876,10 +1881,14 @@ def np2type(t):
         return bool
     elif t.name.startswith('datetime64[ns'):
         return nsectime
+    elif t.name.startswith('datetime64[us'):
+        return nsectime
     elif t.name.startswith('datetime64[ms'):
         return msectime
     elif t.name == 'object':
         return str
+    elif t.name == 'str':
+        return str
     elif t.str.startswith('<U'):
         length = t.name[2:]
         if length: