onetick-py 1.177.0__py3-none-any.whl

onetick/py/core/_source/symbol.py

@@ -0,0 +1,205 @@
+import warnings
+
+import onetick.py.types as ott
+from onetick.py.core._source._symbol_param import _SymbolParamColumn
+
+
+globals().setdefault("__warningregistry__", {})  # otherwise doctests fails
+
+
+class SymbolType:
+    def __init__(self):
+        """
+        You can get symbol name and symbol parameters with this class.
+
+        Examples
+        --------
+        >>> symbols = otp.Symbols('SOME_DB')
+        >>> symbols['PARAM'] = 'PAM'
+        >>> ticks = otp.DataSource('SOME_DB', tick_type='TT')
+        >>> ticks['SYMBOL_PARAM'] = ticks.Symbol['PARAM', str]
+        >>> ticks['SYMBOL_NAME'] = ticks.Symbol.name
+        >>> ticks = otp.merge([ticks], symbols=symbols)
+        >>> otp.run(ticks)
+                             Time  X SYMBOL_PARAM SYMBOL_NAME
+        0 2003-12-01 00:00:00.000  1          PAM          S1
+        1 2003-12-01 00:00:00.000 -3          PAM          S2
+        2 2003-12-01 00:00:00.001  2          PAM          S1
+        3 2003-12-01 00:00:00.001 -2          PAM          S2
+        4 2003-12-01 00:00:00.002  3          PAM          S1
+        5 2003-12-01 00:00:00.002 -1          PAM          S2
+
+        See also
+        --------
+        | :ref:`Databases, symbols, and tick types <symbols_concept>`
+        | :ref:`api/misc/symbol_param:Symbol Parameters Objects`
+        """
+
+        self.__name = _SymbolParamColumn("_SYMBOL_NAME", str)
+
+    @property
+    def name(self):
+        """
+        Get symbol name.
+
+        Returns
+        -------
+        _SymbolParamColumn
+
+        Examples
+        --------
+        >>> symbols = otp.Symbols('SOME_DB')
+        >>> ticks = otp.DataSource('SOME_DB', tick_type='TT')
+        >>> ticks['SYMBOL_NAME'] = ticks.Symbol.name
+        >>> ticks = otp.merge([ticks], symbols=symbols)
+        >>> otp.run(ticks)
+                             Time  X SYMBOL_NAME
+        0 2003-12-01 00:00:00.000  1          S1
+        1 2003-12-01 00:00:00.000 -3          S2
+        2 2003-12-01 00:00:00.001  2          S1
+        3 2003-12-01 00:00:00.001 -2          S2
+        4 2003-12-01 00:00:00.002  3          S1
+        5 2003-12-01 00:00:00.002 -1          S2
+        """
+        return self.__name
+
+    def get(self, name, dtype, default=None):
+        """
+        Get symbol parameter by name.
+
+        Parameters
+        ----------
+        name: str
+            The name of the symbol parameter to retrieve.
+        dtype: type
+            The expected data type of the symbol parameter value.
+        default: Any, optional
+            The default value to return if the symbol parameter is not found.
+            Default is ``None``, which means that default value of dtype will be used.
+
+        Returns
+        -------
+        Operation
+
+        Examples
+        --------
+        >>> symbols = otp.Symbols('SOME_DB')
+        >>> symbols['PARAM'] = 'PAM'
+        >>> ticks = otp.DataSource('SOME_DB', tick_type='TT')
+        >>> ticks['SYMBOL_PARAM'] = ticks.Symbol.get(name='PARAM', dtype=str, default='default')
+        >>> ticks = otp.merge([ticks], symbols=symbols)
+        >>> otp.run(ticks)
+                             Time  X SYMBOL_PARAM
+        0 2003-12-01 00:00:00.000  1          PAM
+        1 2003-12-01 00:00:00.000 -3          PAM
+        2 2003-12-01 00:00:00.001  2          PAM
+        3 2003-12-01 00:00:00.001 -2          PAM
+        4 2003-12-01 00:00:00.002  3          PAM
+        5 2003-12-01 00:00:00.002 -1          PAM
+
+        >>> symbol1 = otq.Symbol('SOME_DB::S1', params={'PARAM': 1})
+        >>> symbol2 = otq.Symbol('SOME_DB::S2')
+        >>> data = otp.DataSource(tick_type='TT')
+        >>> data['P'] = data.Symbol.get(name='PARAM', dtype=int, default=10)
+        >>> data = otp.merge([data], symbols=[symbol1, symbol2], identify_input_ts=True)
+        >>> otp.run(data)
+                             Time   P  X  SYMBOL_NAME TICK_TYPE
+        0 2003-12-01 00:00:00.000   1  1  SOME_DB::S1        TT
+        1 2003-12-01 00:00:00.000  10 -3  SOME_DB::S2        TT
+        2 2003-12-01 00:00:00.001   1  2  SOME_DB::S1        TT
+        3 2003-12-01 00:00:00.001  10 -2  SOME_DB::S2        TT
+        4 2003-12-01 00:00:00.002   1  3  SOME_DB::S1        TT
+        5 2003-12-01 00:00:00.002  10 -1  SOME_DB::S2        TT
+
+        """
+        if default is None:
+            default = ott.default_by_type(dtype)
+        return self._get(item=name, dtype=dtype, default=default)
+
+    @staticmethod
+    def _get(item, dtype=str, default=None):
+        return _SymbolParamColumn(item, dtype, default=default)
+
+    def __getattr__(self, item):
+        """
+        Get symbol parameter by name. Notice, that symbol parameter type will be string.
+
+        .. deprecated:: 1.74.0
+           Please, use :py:meth:`~onetick.py.core._source.symbol.__getitem__` method.
+
+        Returns
+        -------
+        _SymbolParamColumn
+        """
+        if item == '__objclass__':
+            # fix for PY-1399 (some inspect functions try to access this special attribute)
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{item}'")
+        if not item.startswith('_') and item != 'pytest_mock_example_attribute_that_shouldnt_exist':
+            warnings.warn("`__getattr__` method is deprecated. Please, use `__getitem__` method instead.",
+                          FutureWarning, stacklevel=2)
+        return self._get(item)
+
+    def __getitem__(self, item):
+        """
+        Get symbol parameter by name.
+
+        Parameters
+        ----------
+        item: tuple
+            The first parameter is string - symbol parameter name. The second one is symbol parameter type.
+
+        Returns
+        -------
+        _SymbolParamColumn
+
+        Examples
+        --------
+        The second parameter is symbol parameter's type.
+
+        >>> symbols = otp.Symbols('SOME_DB')
+        >>> symbols['PARAM'] = 5
+        >>> ticks = otp.DataSource('SOME_DB', tick_type='TT')
+        >>> ticks['SYMBOL_PARAM'] = ticks.Symbol['PARAM', int] + 1
+        >>> ticks['SYMBOL_PARAM'].dtype
+        <class 'int'>
+        >>> ticks = otp.merge([ticks], symbols=symbols)
+        >>> otp.run(ticks)
+                             Time  X  SYMBOL_PARAM
+        0 2003-12-01 00:00:00.000  1             6
+        1 2003-12-01 00:00:00.000 -3             6
+        2 2003-12-01 00:00:00.001  2             6
+        3 2003-12-01 00:00:00.001 -2             6
+        4 2003-12-01 00:00:00.002  3             6
+        5 2003-12-01 00:00:00.002 -1             6
+
+        It also works with :py:class:`~onetick.py.msectime` and :py:class:`~onetick.py.nsectime` types:
+
+        >>> symbols = otp.Symbols('SOME_DB')
+        >>> symbols['NSECTIME_PARAM'] = symbols['Time'] + otp.Nano(100)
+        >>> symbols['MSECTIME_PARAM'] = symbols['Time'] + otp.Milli(1)
+        >>> ticks = otp.DataSource('SOME_DB', tick_type='TT')
+        >>> ticks['NSECTIME_PARAM'] = ticks.Symbol['NSECTIME_PARAM', otp.nsectime] + otp.Nano(1)
+        >>> ticks['MSECTIME_PARAM'] = ticks.Symbol['MSECTIME_PARAM', otp.msectime] + otp.Milli(1)
+        >>> ticks['NSECTIME_PARAM'].dtype
+        <class 'onetick.py.types.nsectime'>
+        >>> ticks['MSECTIME_PARAM'].dtype
+        <class 'onetick.py.types.msectime'>
+        >>> ticks = otp.merge([ticks], symbols=symbols)
+        >>> otp.run(ticks)
+                             Time  X                NSECTIME_PARAM          MSECTIME_PARAM
+        0 2003-12-01 00:00:00.000  1 2003-12-01 00:00:00.000000101 2003-12-01 00:00:00.002
+        1 2003-12-01 00:00:00.000 -3 2003-12-01 00:00:00.000000101 2003-12-01 00:00:00.002
+        2 2003-12-01 00:00:00.001  2 2003-12-01 00:00:00.000000101 2003-12-01 00:00:00.002
+        3 2003-12-01 00:00:00.001 -2 2003-12-01 00:00:00.000000101 2003-12-01 00:00:00.002
+        4 2003-12-01 00:00:00.002  3 2003-12-01 00:00:00.000000101 2003-12-01 00:00:00.002
+        5 2003-12-01 00:00:00.002 -1 2003-12-01 00:00:00.000000101 2003-12-01 00:00:00.002
+        """
+        if not isinstance(item, tuple):
+            raise ValueError(f"tuple should be passed, but {type(item)} was passed")
+        if len(item) != 2:
+            raise ValueError(f"tuple's length should be 2 but it is {len(item)}")
+        item, dtype = item
+        return self._get(item, dtype)
+
+
+Symbol = SymbolType()  # noqa mypy fix

onetick/py/core/_source/tmp_otq.py

@@ -0,0 +1,222 @@
+import os
+
+from onetick.py.otq import otq, _tmp_otq_path, otli, pyomd
+from pandas import Timestamp as pd_Timestamp
+from onetick.py.types import datetime as otp_datetime, datetime2expr
+from datetime import datetime, date
+from onetick.py import utils
+from onetick.py.configuration import config
+from onetick.py.log import get_debug_logger
+
+
+def is_datetime_type(dt):
+    # TODO: move to types, add docs
+    return isinstance(dt, (datetime, date, pd_Timestamp, otp_datetime, pyomd.timeval_t))
+
+
+def is_millisecond_precision(dt):
+    """
+    dt can be a datetime object, a pd.Datetime object or an otp.dt object.
+    We check if it has only millisecond precision or not.
+    """
+    if (dt.microsecond % 1000) != 0:
+        return False
+    if isinstance(dt, (pd_Timestamp, otp_datetime)):
+        if dt.nanosecond != 0:
+            return False
+    return True
+
+
+class TmpOtq:
+    """
+    Class that represents a storage of temporary queries
+    """
+
+    class __iter_str:
+        """
+        Class that produces unique strings
+        """
+        DEFAULT_LENGTH = 6
+        FIRST_CODE = 97  # 'a'
+        LAST_CODE = 122  # 'z'
+
+        def __init__(self, length=None):
+            if length is None:
+                length = self.DEFAULT_LENGTH
+            self.__length = length
+            self.__n = 0
+
+        def __num_to_str(self):
+            s = ""
+            r = self.LAST_CODE - self.FIRST_CODE + 1
+            for i in range(0, self.__length):
+                s = chr(self.FIRST_CODE + (self.__n // r ** i) % r) + s
+            return s
+
+        def get_str(self):
+            s = self.__num_to_str()
+            self.__n += 1
+            return s
+
+    name_generator = __iter_str()
+
+    def __init__(self):
+        self.queries = {}
+
+    def add_query(self, query, suffix="", name=None, params=None):
+        """
+        Adds query with a unique generated name to the storage.
+
+        Parameters
+        ----------
+        query: otq.GraphQuery
+            GraphQuery object that is being stored
+        suffix: str
+            Suffix that is added to the autogenerated string to form name of the query.
+        name: str, optional
+            If specified, this ``name`` will be used to save query
+            and ``suffix`` parameter will be ignored.
+        params: dict, optional
+            Can specify additional parameters with which this query will be saved to file.
+            Currently, only "running_query_flag" and "symbol_date" are supported
+
+        Returns
+        -------
+            result: str , name of the query in the file (without THIS:: prefix).
+        """
+        name = name or self.name_generator.get_str() + suffix
+        if name in self.queries:
+            raise ValueError(f"There is already a query with name '{name}' in {self.__class__.__name__} storage")
+        if params is None:
+            params = {}
+        self.queries[name] = (query, params)
+        return name
+
+    def merge(self, tmp_otq):
+        """
+        Adds queries from the tmp_otq storage to the current storage.
+        As query names are guaranteed to be unique session-wide, no check for collision is necessary.
+        Queries with same names will always be the same.
+        """
+        self.queries.update(tmp_otq.queries)
+
+    def copy(self):
+        """
+        Creates a copy of the storage
+        """
+        res = TmpOtq()
+        res.merge(self)
+        return res
+
+    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,
+                     symbol_date=None):
+        """
+        Saves all queries from the query dict and one more query (if passed);
+        returns absolute path to passed query in file (if passed) or path of resulted file
+
+        Parameters
+        ----------
+        query: otq.GraphQuery or None
+            Additional query that is saved with all the queries from the storage. Usually, this will be the main query
+            of the Source object that uses this storage
+        query_name: str
+            Name with which additional query will be saved. As additional query is not stored in any TmpOtq object,
+            it can be saved with a name that is specified completely and not generated to be unique
+        file_path: str or None
+            Path to the file where all queries will be saved. If None, a TmpFile will be created
+        file_suffix: str
+            Only used if file_path is None. A suffix that is added to the name of a generated file.
+        start: :py:class:`otp.datetime <onetick.py.datetime>`
+            start time for the resulting .otq file
+        end: :py:class:`otp.datetime <onetick.py.datetime>`
+            end time for the resulting .otq file
+        start_time_expression: str or None
+            start time expression for the resulting .otq file
+        end_time_expression: str or None
+            end time expression for the resulting .otq file
+        timezone: str
+            timezone for the resulting .otq file
+        symbol_date: :py:class:`otp.datetime <onetick.py.datetime>` or :py:class:`datetime.datetime` or int
+            Symbol date for the query or integer in the YYYYMMDD format.
+            Will be applied only to the query specified in the ``query`` parameter.
+
+        Returns
+        -------
+            result: str , contains path to the resulting file with the name of the additional query
+            (if "query" parameter is not None) or path to the resulting file otherwise
+
+        """
+        if file_path is None:
+            base_dir = None
+            if os.getenv('OTP_WEBAPI_TEST_MODE'):
+                base_dir = _tmp_otq_path()
+            kwargs = {}
+            if config.otq_debug_mode:
+                kwargs['clean_up'] = False
+            tmp_file = utils.TmpFile(suffix=file_suffix,
+                                     base_dir=base_dir,
+                                     **kwargs)
+            file_path = tmp_file.path
+
+        queries_dict = dict(self.queries)
+
+        if query is not None:
+            if query_name in self.queries.keys():
+                query_name = self.name_generator.get_str() + "_" + query_name
+            query_params = {}
+            if running_query_flag:
+                query_params['running_query_flag'] = running_query_flag
+            if symbol_date is not None:
+                query_params['symbol_date'] = symbol_date
+            queries_dict[query_name] = (query, query_params)
+
+        # defining file-wise start/end times and time expressions
+
+        # timezone definitions
+        # in onetick and in dateutil can differ (e.g. "GMT-10" is +10:00 offset in onetick and -10:00 offset
+        # in dateutil), therefore we always use time expressions to force onetick to make time conversions by itself
+        # TODO: create a BDS ticket for the onetick team to fix it somehow
+        if is_datetime_type(start):
+            if not start_time_expression:
+                start_time_expression = datetime2expr(start)
+            start = None
+        if is_datetime_type(end):
+            if not end_time_expression:
+                end_time_expression = datetime2expr(end)
+            end = None
+
+        # constructing a list of otq.Query objects, which will hold graphs, names, start/end times etc.
+        query_list = []
+        for stored_query_name in queries_dict.keys():   # noqa
+            stored_query = otq.Query(queries_dict[stored_query_name][0])
+            stored_query_params = queries_dict[stored_query_name][1]
+            if timezone:
+                stored_query.set_timezone(timezone)
+            stored_query.set_symbols(queries_dict[stored_query_name][0].symbols())
+            stored_query.set_query_name(stored_query_name)
+            stored_query.set_start_time(start)
+            stored_query.set_end_time(end)
+            if 'running_query_flag' in stored_query_params.keys():
+                stored_query.set_running_query_flag(stored_query_params['running_query_flag'])
+            if start_time_expression:
+                stored_query.set_start_time_expression(start_time_expression)
+            if end_time_expression:
+                stored_query.set_end_time_expression(end_time_expression)
+            if 'symbol_date' in stored_query_params.keys():
+                stored_symbol_date = stored_query_params['symbol_date']
+                if stored_symbol_date is not None:
+                    stored_symbol_date = int(utils.symbol_date_to_str(stored_symbol_date))
+                    stored_query.set_symbol_date(stored_symbol_date)
+            query_list.append(stored_query)
+
+        _ = otli.OneTickLib()
+        otq_file = otq.OtqFile(query_list)
+        otq_file.save_to_file(file_path)
+        get_debug_logger().debug(f'otq file saved to: {file_path}')
+
+        if query is not None:
+            return file_path + "::" + query_name
+        else:
+            return file_path

onetick/py/core/column.py

@@ -0,0 +1,209 @@
+import inspect
+import string
+
+from .column_operations.base import _Operation
+from .. import types as ott
+
+
+_allowed_field_name_chars = set(string.ascii_letters) | set(string.digits) | {'_', '.'}
+
+
+def validate_onetick_field_name(field_name):
+    if len(field_name) < 1 or len(field_name) > 127:
+        return False
+    chars = set(char for char in field_name)
+
+    return chars.issubset(_allowed_field_name_chars)
+
+
+def field_name_contains_lowercase(field_name):
+    for char in field_name:
+        if char.islower():
+            return True
+    return False
+
+
+class Column(_Operation):
+    """
+    :py:class:`~onetick.py.Source` column container.
+
+    This is the object you get when using :py:meth:`~onetick.py.Source.__getitem__`.
+    You can use this object everywhere where :py:class:`~onetick.py.Operation` object can be used.
+
+    Examples
+    --------
+    >>> t = otp.Tick(A=1)
+    >>> t['A']
+    Column(A, <class 'int'>)
+    """
+
+    @staticmethod
+    def _check_name(name):
+        if not validate_onetick_field_name(name):
+            raise ValueError(f"Field name '{name}' is not a valid field name. "
+                             "Onetick field names can contain upper and lower English letters, digits, "
+                             "symbols '.' and '_'. Also, Onetick field names cannot be longer than 127 characters.")
+
+    def __init__(self, name, dtype=float, obj_ref=None, precision=None):
+        if not dtype or not inspect.isclass(dtype) or not ott.is_type_supported(dtype):
+            raise TypeError(f'Column does not support "{dtype}" type')
+
+        # validating column name
+        if name != 'Time':  # this is a special value
+            self._check_name(name)
+
+        self.name = name
+        super().__init__(dtype=dtype, obj_ref=obj_ref, op_str=name)
+
+        # optional properties
+        if precision is not None:
+            if issubclass(dtype, float):
+                self._precision = precision
+            else:
+                raise ValueError("precision is supported only for columns with float or decimal dtypes")
+
+    def rename(self, new_name, update_parent_object=True):
+        self._check_name(new_name)
+        if self.obj_ref and update_parent_object:
+            self.obj_ref.rename({self.name: new_name}, inplace=True)
+
+        self.name = new_name
+
+    def __len__(self):
+        if issubclass(self.dtype, str):
+            if issubclass(self.dtype, ott.string):
+                return self.dtype.length
+            else:
+                return ott.string.DEFAULT_LENGTH
+        else:
+            raise TypeError(f'It is not applicable for the column with type {self.dtype}')  # TODO: test
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return f"Column({str(self)}, {self.dtype})"
+
+    def copy(self, obj_ref=None):
+        return _Column(self.name, self.dtype, obj_ref)
+
+    def __bool__(self):
+        if _Column.emulation_enabled:
+            if issubclass(self.dtype, int):
+                return (self != 0).__bool__()
+            if issubclass(self.dtype, float):
+                return (self != 0).__bool__()
+            if issubclass(self.dtype, str):
+                return (self != "").__bool__()
+
+        raise TypeError("It is not allowed to use columns in if-else and while clauses")
+
+    def __getitem__(self, item):
+
+        """
+        Provides an ability to get values from future or past ticks.
+
+        - Negative values refer to past ticks
+
+        - Zero to current tick
+
+        - Positive - future ticks
+
+        Boundary values will be defaulted. For instance for ``item=-1`` first tick value will be defaulted
+        (there is no tick before first tick)
+
+        Parameters
+        ----------
+        item: int
+            number of ticks to look back/forward
+
+        Returns
+        -------
+        Operation
+
+        Examples
+        --------
+        >>> data = otp.Ticks({'A': [1, 2, 3]})
+        >>> data['PAST1'] = data['A'][-1]
+        >>> data['PAST2'] = data['A'][-2]
+        >>> data['FUTURE1'] = data['A'][1]
+        >>> data['FUTURE2'] = data['A'][2]
+        >>> otp.run(data)
+                             Time  A  PAST1  PAST2  FUTURE1  FUTURE2
+        0 2003-12-01 00:00:00.000  1      0      0        2        3
+        1 2003-12-01 00:00:00.001  2      1      0        3        0
+        2 2003-12-01 00:00:00.002  3      2      1        0        0
+        """
+
+        if not isinstance(item, int):
+            raise TypeError(
+                f"Lag operation supports only integer const values, but passed value of type '{type(item)}'"
+            )
+        if item == 0:
+            return self
+
+        return _LagOperator(self, item)
+
+    def cumsum(self):
+        """
+        Cumulative sum of the column.
+
+        Can only be used when creating or updating column.
+
+        Examples
+        --------
+        >>> t = otp.Ticks({'A': [1, 2, 3]})
+        >>> t['X'] = t['A'].cumsum()
+        >>> otp.run(t)
+                             Time  A  X
+        0 2003-12-01 00:00:00.000  1  1
+        1 2003-12-01 00:00:00.001  2  3
+        2 2003-12-01 00:00:00.002  3  6
+        """
+        import onetick.py as otp
+
+        return _ColumnAggregation(
+            otp.agg.sum(self.name, running=True, all_fields=True, overwrite_output_field=True)
+        )
+
+    def __iter__(self):
+        raise TypeError("It is not allowed to use columns in for-clauses")
+
+
+class _LagOperator(_Operation):
+    """
+    Implements referencing to the prior tick
+    """
+
+    def __init__(self, base_column, inx):
+        self._inx = inx
+        op_str = f"{str(base_column)}[{self.index}]"
+        super().__init__(op_params=[base_column], dtype=base_column.dtype,
+                         op_str=op_str, obj_ref=base_column.obj_ref)
+
+    @property
+    def index(self):
+        return self._inx
+
+
+class _ColumnAggregation:
+    """
+    Object to specify how column will be aggregated.
+    """
+    def __init__(self, aggregation):
+        from ..aggregations._base import _Aggregation
+        if not isinstance(aggregation, _Aggregation):
+            raise ValueError(f'Expected aggregation object, got {type(aggregation)}')
+        if not aggregation.running or not aggregation.all_fields or not aggregation.overwrite_output_field:
+            raise ValueError("Column aggregations only support 'running' aggregations"
+                             " with 'all_fields' and 'overwrite_output_field' parameters set")
+        self.aggregation = aggregation
+
+    def apply(self, src, name):
+        return self.aggregation.apply(src, name=name, inplace=True)
+
+
+_Column = Column  # alias for backward compatibility

onetick/py/core/column_operations/_methods/__init__.py

@@ -0,0 +1,4 @@
+from .methods import fillna, isin, round, _map
+from .methods import add, sub, mul, mod, div, abs, neg, pos
+from .methods import eq, ne, and_, or_, gt, ge, lt, le, invert
+from .conversions import CONVERSIONS

onetick/py/core/column_operations/_methods/_internal.py

@@ -0,0 +1,28 @@
+from collections import namedtuple
+
+from onetick.py import types as ott
+from onetick.py.core.column_operations._methods.op_types import are_strings
+from onetick.py.types import value2str
+
+MethodResult = namedtuple("MethodResult", ("op_str", "dtype"))
+
+
+def _wrap_object(o):
+    if isinstance(o, str) or are_strings(getattr(o, "dtype", None)):
+        # In PER_TICK_SCRIPT: parenthesis are not allowed in string expressions.
+        return value2str(o)
+    return f"({value2str(o)})"
+
+
+def _type_error_for_op(op, types):
+    return TypeError(f"Unsupported operand type(s) for {op} operation: {types}")
+
+
+def _init_binary_op(prev_op, other):
+    left = _wrap_object(prev_op)
+    right = _wrap_object(other)
+    left_t = ott.get_object_type(prev_op)
+    right_t = ott.get_object_type(other)
+    dtype = None
+    op_str = None
+    return left, right, left_t, right_t, op_str, dtype