onetick-py 1.162.2__py3-none-any.whl

onetick/py/core/column_operations/_methods/conversions.py

@@ -0,0 +1,215 @@
+from collections import UserDict
+from functools import partial
+
+from onetick.py import types as ott
+from onetick.py.core.column_operations._methods._internal import MethodResult
+from onetick.py.core.column_operations._methods.op_types import are_ints_not_time
+
+NSECTIME_TO_STR_FORMAT = "%Y-%m-%d %H:%M:%S.%J"
+NSECTIME_TO_STR_FORMAT_2 = "%Y/%m/%d %H:%M:%S.%J"
+MSECTIME_TO_STR_FORMAT = "%Y-%m-%d %H:%M:%S.%q"
+
+
+def float_to_int(prev_op, dtype=int):
+    # CASE should be uppercased because it can be used in per-tick script
+    op_str = f"CASE({str(prev_op)} > 0, 1, floor({str(prev_op)}), ceil({str(prev_op)}))"
+    return MethodResult(op_str, dtype)
+
+
+def float_to_str(prev_op, dtype=str):
+    precision = getattr(prev_op, "_precision", 7)
+
+    op_str = f"tostring({str(prev_op)}, 10, {precision})"
+
+    if precision == 0:
+        # otherwise 1.7 would be 1, but should be 1.0, because it is still float TODO: forbid it?
+        op_str = f"({op_str} + '.0')"
+    # if
+
+    # we need it to remove trailing zeros
+    op_str = fr'regex_replace({op_str}, "(\.\d+?)0+\b", "\1")'
+    return MethodResult(op_str, dtype)
+
+
+def float_to_decimal(prev_op):
+    return MethodResult(f'decimal({str(prev_op)})', ott.decimal)
+
+
+def decimal_to_str(prev_op, dtype=str):
+    precision = getattr(prev_op, "_precision", 8)
+    op_str = f"decimal_to_string({str(prev_op)}, {precision})"
+    return MethodResult(op_str, dtype)
+
+
+def decimal_to_float(prev_op):
+    return MethodResult(f'{str(prev_op)}', float)
+
+
+def nsectime_to_str(prev_op, dtype=str):
+    op_str = f"nsectime_format('{NSECTIME_TO_STR_FORMAT}', {str(prev_op)}, _TIMEZONE)"
+    return MethodResult(op_str, dtype)
+
+
+def msectime_to_str(prev_op, dtype=str):
+    op_str = f"time_format('{MSECTIME_TO_STR_FORMAT}', {str(prev_op)}, _TIMEZONE)"
+    return MethodResult(op_str, dtype)
+
+
+def nsectime_to_int(prev_op, dtype=int):
+    op_str = f"nsectime_to_long({str(prev_op)})"
+    return MethodResult(op_str, dtype)
+
+
+def msectime_to_int(prev_op, dtype=int):
+    op_str = str(prev_op)
+    return MethodResult(op_str, dtype)
+
+
+def nsectime_to_msectime(prev_op):
+    op_str = f"nsectime({str(prev_op)})"
+    return MethodResult(op_str, ott.msectime)
+
+
+def msectime_to_nsectime(prev_op):
+    op_str = f"nsectime({str(prev_op)})"
+    return MethodResult(op_str, ott.nsectime)
+
+
+def int_to_str(prev_op, dtype=str):
+    op_str = f"tostring({str(prev_op)})"
+    return MethodResult(op_str, dtype)
+
+
+def int_to_float(prev_op):
+    op_str = f"{str(prev_op)} * 1.0"
+    return MethodResult(op_str, float)
+
+
+def int_to_nsectime(prev_op):
+    op_str = f"nsectime({str(prev_op)})"
+    return MethodResult(op_str, ott.nsectime)
+
+
+def int_to_msectime(prev_op):
+    op_str = str(prev_op)
+    return MethodResult(op_str, ott.msectime)
+
+
+def str_to_float(prev_op):
+    op_str = f"atof({str(prev_op)})"
+    return MethodResult(op_str, float)
+
+
+def str_to_decimal(prev_op):
+    op_str = f"string_to_decimal({str(prev_op)})"
+    return MethodResult(op_str, ott.decimal)
+
+
+def str_to_int(prev_op, dtype=int):
+    op_str = f"atol({str(prev_op)})"
+    return MethodResult(op_str, dtype)
+
+
+def str_to_nsectime(prev_op):
+    op_str = _str_to_time(prev_op)
+    return MethodResult(op_str, ott.nsectime)
+
+
+def str_to_msectime(prev_op):
+    op_str = _str_to_time(prev_op)
+    return MethodResult(op_str, ott.msectime)
+
+
+def _str_to_time(prev_op):
+    result = str(prev_op)
+
+    first_option = f"parse_nsectime('{NSECTIME_TO_STR_FORMAT}', {result}, _TIMEZONE)"
+    second_option = f"parse_nsectime('{NSECTIME_TO_STR_FORMAT_2}', {result}, _TIMEZONE)"
+
+    # CASE should be uppercased because it can be used in per-tick script
+    return f"CASE(position('-', {result}) > 0, 1, {first_option}, {second_option})"
+
+
+def bool_to_int(prev_op, dtype=int):
+    op_str = f"CASE({str(prev_op)}, true, 1, 0)"
+    return MethodResult(op_str, dtype)
+
+
+def bool_to_float(prev_op):
+    op_str = f"CASE({str(prev_op)}, true, 1.0, 0.0)"
+    return MethodResult(op_str, float)
+
+
+def _same_to_same(prev_op, dtype=None):
+    if dtype is None:
+        dtype = prev_op.dtype
+    return MethodResult(str(prev_op), dtype)
+
+
+class _ConversionsDict(UserDict):
+    def __init__(self, conversions):
+        self.data = conversions
+
+    def __getitem__(self, key):
+        if not (isinstance(key, tuple) and len(key) == 2):
+            raise ValueError("wrong usage of _ConversionsDict")
+
+        from_, to = key
+        if from_ == to:
+            return _same_to_same
+
+        try:
+            return super().__getitem__(key)
+        except KeyError:
+            pass
+
+        new_from, new_to = None, None
+
+        # int subclasses are converted by the same method
+        if are_ints_not_time(from_):
+            new_from = int
+        if are_ints_not_time(to):
+            new_to = int
+
+        # otp.string and str are converted by the same methods
+        if from_ is not str and issubclass(from_, str):
+            new_from = str
+        if to is not str and issubclass(to, str):
+            new_to = str
+
+        if new_from is not None or new_to is not None:
+            new_key = (new_from or from_, new_to or to)
+            if new_key[0] == new_key[1]:
+                method = _same_to_same
+            else:
+                method = super().__getitem__(new_key)
+            if issubclass(to, str) or are_ints_not_time(to):
+                method = partial(method, dtype=to)
+            return method
+
+        raise TypeError(f"can not convert {from_} to {to}")
+
+
+CONVERSIONS = _ConversionsDict({(float, int): float_to_int,
+                                (float, str): float_to_str,
+                                (float, ott.decimal): float_to_decimal,
+                                (ott.decimal, int): float_to_int,
+                                (ott.decimal, str): decimal_to_str,
+                                (ott.decimal, float): decimal_to_float,
+                                (ott.nsectime, str): nsectime_to_str,
+                                (ott.msectime, str): msectime_to_str,
+                                (ott.nsectime, int): nsectime_to_int,
+                                (ott.msectime, int): msectime_to_int,
+                                (ott.nsectime, ott.msectime): nsectime_to_msectime,
+                                (ott.msectime, ott.nsectime): msectime_to_nsectime,
+                                (int, str): int_to_str,
+                                (int, float): int_to_float,
+                                (int, ott.nsectime): int_to_nsectime,
+                                (int, ott.msectime): int_to_msectime,
+                                (str, float): str_to_float,
+                                (str, ott.decimal): str_to_decimal,
+                                (str, int): str_to_int,
+                                (str, ott.nsectime): str_to_nsectime,
+                                (str, ott.msectime): str_to_msectime,
+                                (bool, int): bool_to_int,
+                                (bool, float): bool_to_float})

onetick/py/core/column_operations/_methods/methods.py

@@ -0,0 +1,294 @@
+import warnings
+
+from onetick.py import types as ott
+from onetick.py.types import value2str
+from ._internal import MethodResult, _wrap_object, _type_error_for_op, _init_binary_op
+from .op_types import (
+    are_numerics, are_strings, are_bools, are_time, are_ints_not_time, _get_widest_type,
+    are_floats, are_ints_or_time
+)
+
+
+class DatetimeSubtractionWarning(FutureWarning):
+    pass
+
+
+def round(prev_op, precision):
+    if precision is not None:
+        return MethodResult(f'round_double({str(prev_op)},{str(precision)})', float)
+    else:
+        return MethodResult(f'round({str(prev_op)})', int)
+
+
+def isin(prev_op, items):
+    if not items:
+        raise ValueError("Method isin() can't be used without values")
+    op_str = f'IN({str(prev_op)}, {",".join(value2str(i) for i in items)})'
+    return MethodResult(op_str, bool)
+
+
+def _map(prev_op, items, values_type, default=None):
+    default_str = '' if default is None else f', {value2str(default)}'
+    op_str = (f'CASE({str(prev_op)}, {",".join(value2str(k) + "," + value2str(v) for k, v in items.items())}'
+              f'{default_str})')
+    return MethodResult(op_str, values_type)
+
+
+def fillna(prev_op, value=0):
+    result = str(prev_op)
+
+    if not issubclass(prev_op.dtype, float):
+        raise TypeError(f"It is allowed to apply .fillna() is only columns that have 'float' type, "
+                        f"but it is applied on a column with the {prev_op.dtype.__name__} type")
+    dtype = ott.get_object_type(value)
+    if not are_numerics(dtype):
+        raise TypeError(f"fillna expects numeric type, but got value of type '{type(value)}'")
+    op_str = f'replace_nan({result},{value2str(value)})'
+    return MethodResult(op_str, float)
+
+
+def add(prev_op, other):
+    left, right, left_t, right_t, _, _ = _init_binary_op(prev_op, other)
+    result = _return_dateadd_command(prev_op, other, left, right, left_t, right_t, "")
+    # if it is DATEADD command return it, else try to form + operation
+    if result:
+        return result
+    return _plus(prev_op, other, left, right, left_t, right_t)
+
+
+def sub(prev_op, other):
+    left, right, left_t, right_t, _, _ = _init_binary_op(prev_op, other)
+    result = _return_dateadd_command(prev_op, other, left, right, left_t, right_t, "-")
+    # if it is DATEADD command return it, else try to form - operation
+    if result:
+        return result
+    return _minus(prev_op, other, left, right, left_t, right_t)
+
+
+def _return_dateadd_command(prev_op, other, left, right, left_t, right_t, op_sign):
+    if issubclass(left_t, ott.OTPBaseTimeOffset) and are_time(right_t):
+        return _form_method_result_for_dateadd(right, right_t, op_sign, prev_op)
+    elif issubclass(right_t, ott.OTPBaseTimeOffset) and are_time(left_t):
+        return _form_method_result_for_dateadd(left, left_t, op_sign, other)
+
+
+def _form_method_result_for_dateadd(op_str, dtype, op_sign, datepart):
+    op_str = f"DATEADD({datepart.datepart}, {op_sign}({str(datepart.n)}), {op_str}, _TIMEZONE)"
+    return MethodResult(op_str, dtype)
+
+
+def _plus(prev_op, other, left, right, left_t, right_t):
+    def get_str_len(op_or_str_const, dtype):
+        if not isinstance(op_or_str_const, str):
+            if dtype is str:
+                return ott.string.DEFAULT_LENGTH
+            else:
+                return dtype.length
+        elif isinstance(op_or_str_const, ott.varstring):
+            return Ellipsis
+        else:
+            return len(op_or_str_const)  # ott.string as well as builtin strings have len operand
+
+    op_str = f"{left} + {right}"
+    if are_strings(left_t, right_t):  # strings support concatenation
+        left_length, right_length = get_str_len(prev_op, left_t), get_str_len(other, right_t)
+        if left_length is Ellipsis or right_length is Ellipsis:
+            dtype = ott.varstring
+        else:
+            length = max(left_length, right_length)
+            dtype = str if length <= ott.string.DEFAULT_LENGTH else ott.string[length]
+    else:
+        dtype = _get_dtype_for_plus_or_minus(left_t, right_t)
+    if dtype:
+        return MethodResult(op_str, dtype)
+    else:
+        _type_error_for_op("+", f"'{left_t}' and '{right_t}'")
+
+
+def _minus(prev_op, other, left, right, left_t, right_t):  # noqa # NOSONAR
+    op_str = f"{left} - {right}"
+    # Between datetime (msectime and nsectime) types, only the - operator is allowed.
+    if are_time(left_t, right_t):
+        warnings.warn("Subtracting datetimes without specifying resulted time unit is deprecated. "
+                      "Specify resulted time unit explicitly, ex: otp.Hour(a - b) or otp.Nano(a - b). "
+                      "Difference in milliseconds will be returned now, but in future it will throw error. ",
+                      DatetimeSubtractionWarning)
+        dtype = int
+        # TODO uncomment if we will decide to use nanosecond as default time unit
+        # op_str = f"DATEDIFF('nanosecond', {right}, {left}, _TIMEZONE)"
+        # return MethodResult(op_str, dtype)
+    else:
+        dtype = _get_dtype_for_plus_or_minus(left_t, right_t)
+    if dtype:
+        return MethodResult(op_str, dtype)
+    else:
+        _type_error_for_op("-", f"'{left_t}' and '{right_t}'")
+
+
+def _get_dtype_for_plus_or_minus(left_t, right_t):
+    dtype = None
+    if are_numerics(left_t, right_t):
+        dtype = _get_widest_type(left_t, right_t)
+    # It is possible to add an integral value to datetime or subtract an integer from it,
+    # in this case the type is not changed
+    elif (are_ints_not_time(left_t) and issubclass(right_t, ott.nsectime)
+          or are_ints_not_time(right_t) and issubclass(left_t, ott.nsectime)):
+        dtype = ott.nsectime
+    elif (are_ints_not_time(left_t) and issubclass(right_t, ott.msectime)
+          or are_ints_not_time(right_t) and issubclass(left_t, ott.msectime)):
+        dtype = ott.msectime
+    # Any operation between floating-point and datetime types are not allowed in tick script,
+    # but supported in EP, so we also allow such operation, but generate warning.
+    elif (are_floats(left_t) and issubclass(right_t, ott.nsectime)
+          or are_floats(right_t) and issubclass(left_t, ott.nsectime)):
+        dtype = ott.nsectime
+        warnings.warn("Onetick will shrink the fractional part")
+    elif (are_floats(left_t) and issubclass(right_t, ott.msectime)
+          or are_floats(right_t) and issubclass(left_t, ott.msectime)):
+        dtype = ott.msectime
+        warnings.warn("Onetick will shrink the fractional part")
+    return dtype
+
+
+def mul(prev_op, other):
+    left, right, left_t, right_t, op_str, dtype = _init_binary_op(prev_op, other)
+
+    if are_numerics(left_t, right_t):
+        dtype = _get_widest_type(left_t, right_t)
+        op_str = f"{left} * {right}"
+    elif issubclass(left_t, str) and are_ints_not_time(right_t):
+        op_str = f"repeat({left}, {right})"
+        dtype = left_t
+    elif issubclass(right_t, str) and are_ints_not_time(left_t):
+        op_str = f"repeat({right}, {left})"
+        dtype = right_t
+    if dtype and op_str:
+        return MethodResult(op_str, dtype)
+    else:
+        _type_error_for_op("*", f"'{left_t}' and '{right_t}'")
+
+
+def div(prev_op, other):
+    left, right, left_t, right_t, op_str, dtype = _init_binary_op(prev_op, other)
+    if not are_numerics(left_t, right_t):
+        _type_error_for_op("/", f"'{left_t}' and '{right_t}'")
+    dtype = _get_widest_type(_get_widest_type(left_t, right_t), float)
+    op_str = f"{left} / {right}"
+    return MethodResult(op_str, dtype)
+
+
+def mod(prev_op, other):
+    left, right, left_t, right_t, op_str, dtype = _init_binary_op(prev_op, other)
+    if not are_ints_not_time(left_t, right_t):
+        _type_error_for_op("mod", f"'{left_t}' and '{right_t}'")
+    dtype = int
+    op_str = f"mod({left}, {right})"
+    return MethodResult(op_str, dtype)
+
+
+def abs(prev_op):
+    dtype = ott.get_object_type(prev_op)
+    if not are_numerics(dtype):
+        raise TypeError(f"Operation is not supported for type '{dtype}'")
+    op_str = f"abs{_wrap_object(prev_op)}"
+    return MethodResult(op_str, dtype)
+
+
+def pos(prev_op):
+    dtype = ott.get_object_type(prev_op)
+    if not are_numerics(dtype):
+        raise TypeError(f"Operation is not supported for type '{dtype}'")
+    op_str = f"(+{_wrap_object(prev_op)})"
+    return MethodResult(op_str, dtype)
+
+
+def neg(prev_op):
+    dtype = ott.get_object_type(prev_op)
+    if not are_numerics(dtype):
+        raise TypeError(f"Operation is not supported for type '{dtype}'")
+    op_str = f"(-{_wrap_object(prev_op)})"
+    return MethodResult(op_str, dtype)
+
+
+def invert(prev_op):
+    dtype = ott.get_object_type(prev_op)
+    if not issubclass(dtype, bool):
+        raise TypeError(f"Operation is not supported for type '{dtype}'")
+    op_str = f"not({_wrap_object(prev_op)})"
+    return MethodResult(op_str, dtype)
+
+
+def eq(prev_op, other):
+    return _compare(prev_op, other, "=", "==")
+
+
+def ne(prev_op, other):
+    return _compare(prev_op, other, "!=")
+
+
+def lt(prev_op, other):
+    return _compare(prev_op, other, "<")
+
+
+def le(prev_op, other):
+    return _compare(prev_op, other, "<=")
+
+
+def gt(prev_op, other):
+    return _compare(prev_op, other, ">")
+
+
+def ge(prev_op, other):
+    return _compare(prev_op, other, ">=")
+
+
+def _compare(prev_op, other, op_sign, op_sign_python_level=None):
+    def one_boolean_operation_is_allowed(prev_op, other, left_t, right_t):
+        return (isinstance(prev_op, bool) and issubclass(left_t, bool) or
+                isinstance(other, bool) and issubclass(right_t, bool))
+
+    def the_same_type(left_t, right_t):
+        # Operands of compare operator are expected to be both numeric, both booleans, both matrices or both strings
+        return (
+            not are_bools(left_t) and not are_bools(right_t)
+            and (
+                are_numerics(left_t, right_t) or are_strings(left_t, right_t)
+                or are_ints_or_time(left_t, right_t)
+            )
+            or are_bools(left_t, right_t)
+        )
+
+    left, right, left_t, right_t, op_str, _ = _init_binary_op(prev_op, other)
+    if one_boolean_operation_is_allowed(prev_op, other, left_t, right_t) or the_same_type(left_t, right_t):
+        op_str = f"{left} {op_sign} {right}"
+        return MethodResult(op_str, bool)
+    else:
+        # replace = with == for comparisions
+        _type_error_for_op(f"{op_sign_python_level or op_sign}", f"'{left_t}' and '{right_t}'")
+
+
+def and_(prev_op, other):
+    return _and_or(prev_op, other, "AND")
+
+
+def or_(prev_op, other):
+    return _and_or(prev_op, other, "OR")
+
+
+def _and_or(prev_op, other, op_sign):
+    left, right, left_t, right_t, op_str, _ = _init_binary_op(prev_op, other)
+    if are_bools(left_t, right_t):
+        op_str = f"{left} {op_sign} {right}"
+        return MethodResult(op_str, prev_op.dtype)
+    else:
+        _type_error_for_op(f"{op_sign}", f"'{left_t}' and '{right_t}'")
+
+
+def is_arithmetical(op):
+    op = getattr(op, "_op_func", None)
+    return op in {neg, pos, abs, add, sub, mul, div, mod}
+
+
+def is_compare(op):
+    op = getattr(op, "_op_func", None)
+    return op in {invert, or_, and_, eq, ne, lt, le, gt, ge}

onetick/py/core/column_operations/_methods/op_types.py

@@ -0,0 +1,150 @@
+import datetime
+import inspect
+
+import pandas as pd
+import numpy as np
+
+from onetick.py import types as ott
+
+
+def are_numerics(*dtypes):
+    return all(inspect.isclass(dtype)
+               and (issubclass(dtype, (float, int)) or np.issubdtype(dtype, np.integer))
+               and not issubclass(dtype, (ott.nsectime, ott.msectime)) for dtype in dtypes)
+
+
+def are_ints_not_time(*dtypes):
+    return all(inspect.isclass(dtype)
+               and (issubclass(dtype, int) or np.issubdtype(dtype, np.integer))
+               and not issubclass(dtype, (ott.nsectime, ott.msectime)) for dtype in dtypes)
+
+
+def are_time(*dtypes):
+    return all(inspect.isclass(dtype) and issubclass(dtype, (ott.nsectime, ott.msectime)) for dtype in dtypes)
+
+
+def are_ints_or_time(*dtypes):
+    return all(inspect.isclass(dtype)
+               and (issubclass(dtype, (int, datetime.datetime, ott.datetime, pd.Timestamp))
+                    or np.issubdtype(dtype, np.integer))
+               for dtype in dtypes)
+
+
+def are_floats(*dtypes):
+    return all(inspect.isclass(dtype) and issubclass(dtype, (float, np.float64, np.double)) for dtype in dtypes)
+
+
+def are_strings(*dtypes):
+    return all(inspect.isclass(dtype) and issubclass(dtype, str) for dtype in dtypes)
+
+
+def are_bools(*dtypes):
+    return all(inspect.isclass(dtype) and issubclass(dtype, bool) for dtype in dtypes)
+
+
+def _get_widest_type(left, right):
+    """ return the widest type
+
+    If the left is subclass of right return left, if right is subclass of left return right,
+        returns None in all other cases. ott.nsectime, ott.msectime and bool won't be considered as int, only
+        custom classes.
+
+    Parameters
+    ----------
+    left: type
+        type of the first argument
+    right: type
+        type of the second argument
+
+    Returns
+    -------
+    result: type or None
+        widest type if it exist, or None in another case
+
+    Examples
+    --------
+
+    >>> class MyInt(int):   # OTdirective: skip-snippet:;
+    ...     pass
+    >>> class MyFloat(float):
+    ...     pass
+    >>> def test():
+    ...     print(_get_widest_type(int, MyInt))
+    ...     print(_get_widest_type(float, MyFloat))
+    ...     print(_get_widest_type(int, float))
+    ...     print(_get_widest_type(MyInt, MyFloat))
+    ...     print(_get_widest_type(bool, float))
+    ...     print(_get_widest_type(int, bool))
+    ...     print(_get_widest_type(MyInt, bool))
+    ...     print(_get_widest_type(bool, MyFloat))
+    >>> test()  # doctest: +ELLIPSIS
+    <class '...MyInt'>
+    <class '...MyFloat'>
+    <class 'float'>
+    <class '...MyFloat'>
+    <class 'float'>
+    <class 'int'>
+    <class '...MyInt'>
+    <class '...MyFloat'>
+
+    >>> from onetick.py import types as ott     # OTdirective: skip-snippet:;
+    >>> class MyString(str):
+    ...     pass
+    >>> (_get_widest_type(str, MyString),
+    ...  _get_widest_type(str, ott.string[15]),
+    ...  _get_widest_type(MyString, ott.string[15]))  # doctest: +ELLIPSIS
+    (<class 'onetick.py.core.column_operations._methods.op_types.MyString'>, string[15], None)
+
+    >>> from onetick.py import types as ott     # OTdirective: skip-snippet:;
+    >>> _get_widest_type(int, ott.msectime), _get_widest_type(int, ott.nsectime)
+    (None, None)
+
+    >>> from onetick.py import types as ott     # OTdirective: skip-snippet:;
+    >>> class MyTime(ott.OTPBaseTimeStamp):
+    ...     pass
+    >>> class MyNSec(ott.nsectime):
+    ...     pass
+    >>> (_get_widest_type(MyTime, ott.OTPBaseTimeStamp), _get_widest_type(MyTime, ott.nsectime),
+    ... _get_widest_type(MyNSec, ott.nsectime))  # doctest: +ELLIPSIS
+    (<class '...MyTime'>, None, <class '...MyNSec'>)
+    """
+
+    if issubclass(left, float) and issubclass(right, float):
+        # between np.float and float we choose base float
+        if left is not float and np.issubdtype(left, np.floating):
+            left = float
+        if right is not float and np.issubdtype(right, np.floating):
+            right = float
+
+    if issubclass(left, float):
+        if are_ints_not_time(right):
+            return left
+        else:
+            return _get_wideclass(left, right) if issubclass(right, float) else None
+    elif issubclass(right, float):
+        if are_ints_not_time(left):
+            return right
+        else:
+            return _get_wideclass(left, right) if issubclass(left, float) else None
+
+    if are_time(left) and are_ints_not_time(right) or are_time(right) and are_ints_not_time(left):
+        return None
+
+    if issubclass(right, int) and issubclass(left, bool):
+        return right
+    if issubclass(left, int) and issubclass(right, bool):
+        return left
+
+    if issubclass(right, int) and np.issubdtype(left, np.integer):
+        return right
+    if issubclass(left, int) and np.issubdtype(right, np.integer):
+        return left
+
+    return _get_wideclass(left, right)
+
+
+def _get_wideclass(left, right):
+    if issubclass(left, right):
+        return left
+    if issubclass(right, left):
+        return right

onetick/py/core/column_operations/accessors/_accessor.py

@@ -0,0 +1,30 @@
+import typing
+
+from onetick.py import Operation
+from onetick.py.core.column_operations.base import _Operation
+from onetick.py.types import value2str
+
+
+class _Accessor:
+
+    def __init__(self, base_column):
+        self._base_column = base_column
+
+    class Formatter(_Operation):
+
+        def __init__(self, base_column, dtype, formatter):
+            super().__init__(dtype=dtype, op_params=[base_column])
+            self._formatter = formatter
+
+        def __str__(self):
+            return self._formatter(str(self._op_params[0]))
+
+    def _preprocess_tz_and_format(self,
+                                  timezone: typing.Union[Operation, str, None],
+                                  format_str):  # it is common for str and dt accessors
+        if timezone is None or isinstance(timezone, str) and timezone == "_TIMEZONE":
+            timezone = "_TIMEZONE"
+        else:
+            timezone = value2str(timezone)
+        format_str = value2str(format_str)
+        return timezone, format_str