onetick-py 1.162.2__py3-none-any.whl → 1.164.0__py3-none-any.whl

onetick/py/core/_source/source_methods/fields.py

@@ -127,11 +127,12 @@ def table(self: 'Source', inplace=False, strict: bool = True, **schema) -> Optio
 
 
 def __add_field_parse_value(value):
-    if type(value) is tuple:
+    if isinstance(value, tuple):
         value, dtype = value
     else:
         dtype = ott.get_object_type(value)
 
+        # pylint: disable-next=unidiomatic-typecheck
         if type(value) is str and len(value) > ott.string.DEFAULT_LENGTH:
             dtype = ott.string[len(value)]
 
@@ -213,6 +214,7 @@ def _replace_positive_lag_operator_with_tmp_column(value):
                 )
             name = f"__{name}_{operation.index}_NEW__"
             return _Column(name, column.dtype, column.obj_ref, precision=getattr(column, "_precision", None))
+        return None
 
     op, replace_tuples = value._replace_parameters(fun, return_replace_tuples=True)
     return op, {str(new): old for old, new in replace_tuples}
@@ -228,7 +230,7 @@ def _update_field(self: 'Source', field, value):
     if names_mapping:
         self.add_fields(names_mapping, inplace=True)
 
-    if type(value) is tuple:
+    if isinstance(value, tuple):
         # support to be compatible with adding fields to get rid of some strange problems
         # but really we do not use passed type, because update field does not support it
         value, _ = value
@@ -327,9 +329,7 @@ def _validate_before_setting(key, value):
         value = value.item()
     if not (
         ott.is_type_supported(ott.get_object_type(value))
-        or isinstance(value, _Operation)
-        or type(value) is tuple
-        or isinstance(value, _ColumnAggregation)
+        or isinstance(value, (_Operation, tuple, _ColumnAggregation))
     ):
         raise TypeError(f'It is not allowed to set objects of "{type(value)}" type')
     return value

onetick/py/core/_source/source_methods/filters.py

@@ -161,16 +161,16 @@ def where_clause(
         condition = condition._make_python_way_bool_expression()
     if isinstance(condition, _QueryEvalWrapper):
         condition = condition.to_eval_string(self._tmp_otq)
-    where = self.copy(
+    where_branch = self.copy(
         ep=otq.WhereClause(
             where=str(condition), discard_on_match=discard_on_match, stop_on_first_mismatch=stop_on_first_mismatch
         )
     )
 
-    if_source = where.copy()
+    if_source = where_branch.copy()
     if_source.node().out_pin("IF")
 
-    else_source = where.copy()
+    else_source = where_branch.copy()
     else_source.node().out_pin("ELSE")
     # TODO: add ability to remove then this ep, because it is required only for right output
     else_source.sink(otq.Passthrough())
@@ -263,6 +263,7 @@ def _get_integer_slice(self: 'Source', item: slice) -> Optional['Source']:
         raise ValueError("step value can't be negative or zero")
     if stop is not None and stop == 0:
         raise ValueError("stop value can't be zero")
+    # pylint: disable=chained-comparison
     if start and stop and start > 0 and stop > 0 and start >= stop:
         raise ValueError("stop value can't be less than start")
     if start and start < 0 and stop and stop > 0:

onetick/py/core/_source/source_methods/joins.py

@@ -201,14 +201,14 @@ def _fill_time_param_for_jwq(join_params, start_time, end_time, timezone):
 
 
 def _fill_aux_params_for_joins(
-    join_params, caching, end_time, prefix, start_time, symbol_name, timezone, join_with_collection=False
+    join_params, caching, end_time, prefix, start_time, symbol_name, timezone, for_join_with_collection=False
 ):
-    if symbol_name and not join_with_collection:
+    if symbol_name and not for_join_with_collection:
         join_params["symbol_name"] = symbol_name
     if prefix is not None:
         join_params["prefix_for_output_ticks"] = str(prefix)
     if caching:
-        if join_with_collection:
+        if for_join_with_collection:
             supported = ("per_symbol",)
         else:
             supported = ("cross_symbol", "per_symbol")
@@ -217,7 +217,7 @@ def _fill_aux_params_for_joins(
         else:
             raise ValueError(f"Unknown value for caching param, please use None or any of {supported}.")
     _fill_time_param_for_jwq(join_params, start_time, end_time, timezone)
-    if join_with_collection:
+    if for_join_with_collection:
         del join_params['timezone']
 
 
@@ -510,7 +510,7 @@ def join_with_collection(
     )
 
     _fill_aux_params_for_joins(
-        join_params, caching, end, prefix, start, symbol_name=None, timezone=None, join_with_collection=True
+        join_params, caching, end, prefix, start, symbol_name=None, timezone=None, for_join_with_collection=True
     )
     res.sink(otq.JoinWithCollectionSummary(**join_params))
     res._add_table()
@@ -909,7 +909,7 @@ def join_with_query(
         process_query_asynchronously=process_query_async,
     )
     if concurrency is not None:
-        if type(concurrency) is not int or concurrency <= 0:
+        if not isinstance(concurrency, int) or concurrency <= 0:
             raise ValueError('Wrong value of concurrency parameter passed! concurrency should be a positive integer')
         join_params['shared_thread_count'] = concurrency
 

onetick/py/core/_source/source_methods/misc.py

@@ -29,6 +29,7 @@ def inplace_operation(method):
         kwargs['inplace'] = inplace
         if inplace:
             method(self, *args, **kwargs)
+            return None
         else:
             obj = self.copy()
             return method(obj, *args, **kwargs)
@@ -279,6 +280,89 @@ def insert_tick(
     return self
 
 
+@inplace_operation
+def insert_at_end(
+    self: 'Source',
+    *,
+    propagate_ticks: bool = True,
+    delimiter_name: str = 'AT_END',
+    inplace: bool = False,
+) -> Optional['Source']:
+    """
+    This function adds a field ``delimiter_name``,
+    which is set to zero for all inbound ticks
+    and set to 1 for an additional tick that is generated when the data ends.
+
+    The timestamp of the additional tick is set to the query end time.
+    The values of all fields from the input schema of additional tick are set to default values for each type.
+
+    Parameters
+    ----------
+    propagate_ticks: bool
+        If True (default) this function returns all input ticks and an additionally generated tick,
+        otherwise it returns only the last generated tick.
+    delimiter_name: str
+        The name of the delimiter field to add.
+    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.
+
+    See also
+    --------
+    **INSERT_AT_END** OneTick event processor
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    Examples
+    --------
+    Insert tick at the end of the stream:
+
+    >>> data = otp.Ticks(A=[1, 2, 3])
+    >>> data = data.insert_at_end()
+    >>> otp.run(data)
+                         Time  A  AT_END
+    0 2003-12-01 00:00:00.000  1       0
+    1 2003-12-01 00:00:00.001  2       0
+    2 2003-12-01 00:00:00.002  3       0
+    3 2003-12-04 00:00:00.000  0       1
+
+    The name of the added field can be changed:
+
+    >>> data = otp.Ticks(A=[1, 2, 3])
+    >>> data = data.insert_at_end(delimiter_name='LAST_TICK')
+    >>> otp.run(data)
+                         Time  A  LAST_TICK
+    0 2003-12-01 00:00:00.000  1          0
+    1 2003-12-01 00:00:00.001  2          0
+    2 2003-12-01 00:00:00.002  3          0
+    3 2003-12-04 00:00:00.000  0          1
+
+    If parameter ``propagate_ticks`` is set to False, then only the last tick is returned:
+
+    >>> data = otp.Ticks(A=[1, 2, 3])
+    >>> data = data.insert_at_end(propagate_ticks=False)
+    >>> otp.run(data)
+            Time  A  AT_END
+    0 2003-12-04  0       1
+    """
+    if not hasattr(otq, 'InsertAtEnd'):
+        raise RuntimeError("Function insert_at_end() is not available on this OneTick API version")
+    if delimiter_name in self.schema:
+        raise ValueError(f"Field '{delimiter_name}' is already in schema")
+
+    self.sink(
+        otq.InsertAtEnd(
+            propagate_ticks=propagate_ticks,
+            delimiter_name=delimiter_name,
+        )
+    )
+    self.schema.update(**{delimiter_name: int})
+    return self
+
+
 @inplace_operation
 def transpose(
     self: 'Source',

onetick/py/core/_source/source_methods/renames.py

@@ -71,7 +71,7 @@ def _is_excluded(s: str, not_to_rename: List[str]) -> bool:
     return False
 
 
-def _get_columns_names_renaming(schema, rename: Dict[str, str], not_to_rename: List[str]) -> Dict[str, str]:
+def _get_columns_names_renaming(schema, rename_dict: Dict[str, str], not_to_rename: List[str]) -> Dict[str, str]:
     """
     We can't be sure python Source has consistent columns cache, because sinking complex event processors
     can change columns unpredictable, so if user will specify regex as a param, we will pass regex
@@ -79,7 +79,7 @@ def _get_columns_names_renaming(schema, rename: Dict[str, str], not_to_rename: L
 
     Parameters
     ----------
-    rename:
+    rename_dict:
         Dict old_name -> new_name. Some of the dictionary's items use regex.
 
     Returns
@@ -88,7 +88,7 @@ def _get_columns_names_renaming(schema, rename: Dict[str, str], not_to_rename: L
         Dict old_name -> new_name used for renaming columns in Source. None of this dictionary's items use regex.
     """
     output_dict = {}
-    for old_name, new_name in rename.items():
+    for old_name, new_name in rename_dict.items():
         matching_columns = [col for col in schema if re.match(old_name, col) and not _is_excluded(col, not_to_rename)]
         for col in matching_columns:
             output_dict[col] = re.sub(old_name, new_name, col)

onetick/py/core/_source/source_methods/switches.py

@@ -72,20 +72,20 @@ def split(self: 'Source', expr, cases, default=False) -> Tuple['Source', ...]:
     if default:
         params["default_output"] = "DEF_OUT"
 
-    switch = self.copy(ep=otq.SwitchEp(**params))
+    switch_branch = self.copy(ep=otq.SwitchEp(**params))
 
     # construct results
     result = []
 
     for inx in range(output_num):
-        res = switch.copy()
+        res = switch_branch.copy()
         res.node().out_pin(f"OUT{inx}")
         res.sink(otq.Passthrough())
 
         result.append(res)
 
     if default:
-        res = switch.copy()
+        res = switch_branch.copy()
         res.node().out_pin("DEF_OUT")
         res.sink(otq.Passthrough())
 

onetick/py/core/_source/source_methods/writes.py

@@ -1,5 +1,5 @@
 import warnings
-from datetime import date
+import datetime
 from typing import TYPE_CHECKING, Optional, Set, Type, Union
 from onetick.py.backports import Literal
 
@@ -22,9 +22,9 @@ def write(
     db: Union[str, 'otp.DB'],
     symbol: Union[str, 'otp.Column', None] = None,
     tick_type: Union[str, 'otp.Column', None] = None,
-    date: Union[date, Type[adaptive], None] = adaptive,
-    start: Optional[date] = None,
-    end: Optional[date] = None,
+    date: Union[datetime.date, Type[adaptive], None] = adaptive,
+    start: Optional[datetime.date] = None,
+    end: Optional[datetime.date] = None,
     append: bool = False,
     keep_symbol_and_tick_type: Union[bool, Type[adaptive]] = adaptive,
     propagate: bool = True,
@@ -292,10 +292,6 @@ def write(
             ' Possible values are: "ignore", "exception"'
         )
 
-    branches = []
-    if propagate:
-        branches = [self]
-
     kwargs = dict(
         **kwargs,
         database=str(db),
@@ -308,13 +304,18 @@ def write(
     )
 
     if start and end:
-        days = (end - start).days + 1
+        days = (end - start).days
+        if days < 0:
+            raise ValueError("Parameter 'start' must be less than parameter 'end'")
+        if days == 0:
+            raise ValueError("Parameters 'start' and 'end' must specify different dates")
+        branches = []
         for i in range(days):
             branch = self.copy()
             branch.sink(
                 otq.WriteToOnetickDb(
                     date=(start + otp.Day(i)).strftime('%Y%m%d'),
-                    propagate_ticks=False,
+                    propagate_ticks=propagate,
                     out_of_range_tick_action='IGNORE',
                     **kwargs,
                 )
@@ -700,3 +701,271 @@ def save_snapshot(
     )
 
     return self
+
+
+@inplace_operation
+def write_text(
+    self: 'Source',
+    *,
+    propagate_ticks=True,
+    output_headers=True,
+    output_types_in_headers=False,
+    order=None,
+    prepend_symbol_name=True,
+    prepended_symbol_name_size=0,
+    prepend_timestamp=True,
+    separator=',',
+    formats_of_fields=None,
+    double_format='%f',
+    output_dir=None,
+    output_file=None,
+    error_file=None,
+    warning_file=None,
+    data_quality_file=None,
+    treat_input_as_binary=False,
+    flush=True,
+    append=False,
+    allow_concurrent_write=False,
+    inplace=False,
+):
+    r"""
+    Writes the input tick series to a text file or standard output.
+
+    Parameters
+    ----------
+    propagate_ticks: bool
+        If True (default) then ticks will be propagated after this method, otherwise this method won't return ticks.
+    output_headers: bool
+        Switches the output of the headers.
+        If True (default), a tick descriptor line appears in the output before the very first tick for that query.
+        If the structure of the output tick changes, another tick descriptor line appears before the first changed tick.
+        The header line starts with **#**.
+        The field names are ordered as mandated by the ``order`` parameter or,
+        if it is empty, in the order of appearance in the tick descriptor.
+        Fields that are not specified in the ``order`` parameter
+        will appear after specified ones in the order of their appearance in the tick descriptor.
+    output_types_in_headers: bool
+        Switches the output of field types in the header lines.
+        ``output_types_in_headers`` can be set only when ``output_headers`` is set too.
+    order: list
+        The field appearance order in the output.
+        If all or some fields are not specified,
+        those fields will be written in the order of their appearance in the tick descriptor.
+
+        Field **SYMBOL_NAME** may be specified if parameter ``prepend_symbol_name`` is set.
+
+        Field **TIMESTAMP** may be specified if parameter ``prepend_timestamp`` is set.
+    prepend_symbol_name: bool
+        If True (default), prepends symbol name before other fields as a new field named **SYMBOL_NAME** in the header
+        (if ``output_headers`` is set).
+    prepended_symbol_name_size: int
+        When ``prepend_symbol_name`` is set, symbol will be adjusted to this size.
+        If set to 0 (default), no adjustment will be done.
+    prepend_timestamp: bool
+        If set (default), tick timestamps, formatted as *YYYYMMDDhhmmss.qqqqqq* in the GMT time zone,
+        will be prepended to the output lines.
+        Header lines, if present, will have **TIMESTAMP** as the first field name.
+        The default output format for tick timestamps can be specified in the ``formats_of_fields`` parameter.
+    separator: str
+        The delimiter string. This doesn't have to be a single character.
+        Escape sequences are allowed for **\\t** (tab), **\\\\** (\\ character) and **\\xHH** (hex codes).
+        By default "," (comma) will be used.
+    formats_of_fields: dict
+        The dictionary of field names and their formatting specifications.
+        The formatting specification is the same as in the standard C
+        `printf <https://pubs.opengroup.org/onlinepubs/009695399/functions/printf.html>`_ function.
+
+        For float and decimal fields **%f** and **%.[<precision>]f** formats are only supported,
+        first one being the default an outputting 6 decimal digits.
+
+        Also if the field format starts with **%|**,
+        it means that this is a timestamp field and should be in the format **%|tz|time_format_spec**,
+        where the *tz* is the time zone name (if not specified GMT will be used),
+        and *time_format_spec* is a custom time format specification,
+        which is the same as the one used by the
+        `strftime <https://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html>`_ function.
+
+        In addition, you can also use **%q** , **%Q** , **%k** and **%J** placeholders,
+        which will be replaced by 3 and 2 sign milliseconds, 6 sign microseconds and 9 sign nanoseconds, respectively.
+
+        **%#**, **%-**, **%U**, **%N** placeholders will be replaced by Unix timestamp, Unix timestamp in milliseconds,
+        microseconds and nanoseconds, respectively.
+
+        **%+** and **%~** placeholders will be replaced by milliseconds and nanoseconds passed since midnight.
+    double_format: str
+        This format will be used for fields that are holding double values
+        if they are not specified in ``formats_of_fields``.
+    output_dir: str
+        If specified, all output (output, warning, error, and data quality) files will be redirected to it.
+        If this directory does not exist, it will get created.
+        By default, the current directory is used.
+    output_file: str
+        The output file name for generated text data.
+        If not set, the standard output will be used.
+        It is also possible to add symbol name, database name, tick type,
+        date of tick and query start time to the file name.
+        For this special placeholders should be used, which will be replaced with the appropriate values:
+
+            * **%SYMBOL%** - will be replaced with symbol name,
+            * **%DBNAME%** - with database name,
+            * **%TICKTYPE%** - with tick type,
+            * **%DATE%** - with date of tick,
+            * **%STARTTIME%** - with start time of the query.
+
+        .. note::
+            In case of using placeholders the output of the data may be split into different files.
+            For example when querying several days of data and using **%DATE%** placeholder,
+            the file will be created for every day of the interval.
+
+        This format is also available for ``error_file``, ``warning_file`` and ``data_quality_file`` input parameters.
+    error_file: str
+        The file name where all error messages are directed.
+        If not set the standard error will be used.
+    warning_file: str
+        The file name where all warning messages are directed.
+        If not set the standard error will be used.
+    data_quality_file: str
+        The file name where all data quality messages are directed.
+        If not set the standard error will be used.
+    treat_input_as_binary: bool
+        Opens output file in binary mode to not modify content of ticks when printing them to the file.
+        Also in this mode method prints no new line to the file after every tick write.
+    flush: bool
+        If True (default) then the output will be flushed to disk after every tick.
+
+        .. note::
+            Notice that while this setting makes results of the query recorded into a file without delay,
+            making them immediately available to applications that read this file,
+            it may slow down the query significantly.
+
+    append: bool
+        If set to True, will try to append data to files (output, error, warning, data_quality), instead of overwriting.
+    allow_concurrent_write: bool
+        Allows different queries running on the same server to write concurrently to the same files
+        (output, error, warning, data_quality).
+    inplace: bool
+        A flag controls whether operation should be applied inplace.
+        If ``inplace=True``, then it returns nothing. Otherwise method
+        returns a new modified object.
+
+    See also
+    --------
+    | **WRITE_TEXT** OneTick event processor
+    | :py:meth:`onetick.py.Source.dump`
+
+    Examples
+    --------
+
+    By default the text is written to the standard output:
+
+    >>> data = otp.Ticks(A=[1, 2, 3])
+    >>> write = data.write_text()
+    >>> _ = otp.run(write)  # doctest: +SKIP
+    #SYMBOL_NAME,TIMESTAMP,A
+    AAPL,20031201050000.000000,1
+    AAPL,20031201050000.001000,2
+    AAPL,20031201050000.002000,3
+
+    Output file can also be specified:
+
+    >>> write = data.write_text(output_file='result.csv')
+    >>> _ = otp.run(write)  # doctest: +SKIP
+    >>> with open('result.csv') as f:  # doctest: +SKIP
+    ...     print(f.read())  # doctest: +SKIP
+    #SYMBOL_NAME,TIMESTAMP,A
+    AAPL,20031201050000.000000,1
+    AAPL,20031201050000.001000,2
+    AAPL,20031201050000.002000,3
+
+    Symbol name, timestamp of the tick and can be removed from the output:
+
+    >>> write = data.write_text(prepend_timestamp=False,
+    ...                         prepend_symbol_name=False)
+    >>> _ = otp.run(write)  # doctest: +SKIP
+    #A
+    1
+    2
+    3
+
+    The header can also be removed from the output:
+
+    >>> write = data.write_text(output_headers=False)
+    >>> _ = otp.run(write)  # doctest: +SKIP
+    AAPL,20031201050000.000000,1
+    AAPL,20031201050000.001000,2
+    AAPL,20031201050000.002000,3
+
+    The order of fields and separator character can be specified:
+
+    >>> write = data.write_text(order=['A', 'TIMESTAMP'],
+    ...                         separator='\t',
+    ...                         prepend_symbol_name=False)
+    >>> _ = otp.run(write)  # doctest: +SKIP
+    #A  TIMESTAMP
+    1   20031201050000.000000
+    2   20031201050000.001000
+    3   20031201050000.002000
+
+    The formatting can be specified for each field:
+
+    >>> write = data.write_text(formats_of_fields={
+    ...     'TIMESTAMP': '%|GMT|%Y-%m-%d %H:%M:%S.%q',
+    ...     'A': '%3d'
+    ... })
+    >>> _ = otp.run(write)  # doctest: +SKIP
+    #SYMBOL_NAME,TIMESTAMP,A
+    AAPL,2003-12-01 05:00:00.000,  1
+    AAPL,2003-12-01 05:00:00.001,  2
+    AAPL,2003-12-01 05:00:00.002,  3
+    """
+    if output_types_in_headers and not output_headers:
+        raise ValueError("Parameter 'output_types_in_headers' can only be set together with 'output_headers'")
+
+    order = order or []
+    formats_of_fields = formats_of_fields or {}
+    for field in list(order) + list(formats_of_fields):
+        if prepend_symbol_name and field == 'SYMBOL_NAME':
+            continue
+        if not prepend_symbol_name and field == 'SYMBOL_NAME' and field not in self.schema:
+            raise ValueError(
+                "Field 'SYMBOL_NAME' can't be specified in 'order' parameter if 'prepend_symbol_name' is not set"
+            )
+        if not prepend_timestamp and field == 'TIMESTAMP':
+            raise ValueError(
+                "Field 'TIMESTAMP' can't be specified in 'order' parameter if 'prepend_timestamp' is not set"
+            )
+        if field not in self.schema:
+            raise ValueError(f"Field '{field}' is not in schema")
+
+    kwargs = dict(
+        propagate_ticks=propagate_ticks,
+        output_headers=output_headers,
+        output_types_in_headers=output_types_in_headers,
+        order='|'.join(order),
+        prepend_symbol_name=prepend_symbol_name,
+        prepended_symbol_name_size=prepended_symbol_name_size,
+        prepend_timestamp=prepend_timestamp,
+        # OneTick uses \ as an escape character,
+        # so replacing a single \ character with two \\ characters to escape it in OneTick
+        separator=separator.replace('\\', r'\\'),
+        formats_of_fields='\n'.join(f'{k}={v}' for k, v in formats_of_fields.items()),
+        double_format=double_format,
+        output_dir=output_dir,
+        output_file=output_file,
+        error_file=error_file,
+        warning_file=warning_file,
+        data_quality_file=data_quality_file,
+        treat_input_as_binary=treat_input_as_binary,
+        flush=flush,
+        append=append,
+        allow_concurrent_write=allow_concurrent_write,
+    )
+    for k, v in kwargs.items():
+        if v is None:
+            # None values may not be supported by onetick.query
+            kwargs[k] = ''
+
+    self.sink(otq.WriteText(**kwargs))
+    if not propagate_ticks:
+        self.schema.set(**{})
+    return self

onetick/py/core/_source/tmp_otq.py

@@ -21,7 +21,7 @@ def is_millisecond_precision(dt):
     """
     if (dt.microsecond % 1000) != 0:
         return False
-    if isinstance(dt, pd_Timestamp) or isinstance(dt, otp_datetime):
+    if isinstance(dt, (pd_Timestamp, otp_datetime)):
         if dt.nanosecond != 0:
             return False
     return True

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

@@ -15,7 +15,7 @@ def _wrap_object(o):
 
 
 def _type_error_for_op(op, types):
-    raise TypeError(f"Unsupported operand type(s) for {op} operation: {types}")
+    return TypeError(f"Unsupported operand type(s) for {op} operation: {types}")
 
 
 def _init_binary_op(prev_op, other):

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

@@ -70,6 +70,7 @@ def _return_dateadd_command(prev_op, other, left, right, left_t, right_t, op_sig
         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)
+    return None
 
 
 def _form_method_result_for_dateadd(op_str, dtype, op_sign, datepart):
@@ -102,7 +103,7 @@ def _plus(prev_op, other, left, right, left_t, right_t):
     if dtype:
         return MethodResult(op_str, dtype)
     else:
-        _type_error_for_op("+", f"'{left_t}' and '{right_t}'")
+        raise _type_error_for_op("+", f"'{left_t}' and '{right_t}'")
 
 
 def _minus(prev_op, other, left, right, left_t, right_t):  # noqa # NOSONAR
@@ -122,7 +123,7 @@ def _minus(prev_op, other, left, right, left_t, right_t):  # noqa # NOSONAR
     if dtype:
         return MethodResult(op_str, dtype)
     else:
-        _type_error_for_op("-", f"'{left_t}' and '{right_t}'")
+        raise _type_error_for_op("-", f"'{left_t}' and '{right_t}'")
 
 
 def _get_dtype_for_plus_or_minus(left_t, right_t):
@@ -165,13 +166,13 @@ def mul(prev_op, other):
     if dtype and op_str:
         return MethodResult(op_str, dtype)
     else:
-        _type_error_for_op("*", f"'{left_t}' and '{right_t}'")
+        raise _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}'")
+        raise _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)
@@ -180,7 +181,7 @@ def div(prev_op, other):
 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}'")
+        raise _type_error_for_op("mod", f"'{left_t}' and '{right_t}'")
     dtype = int
     op_str = f"mod({left}, {right})"
     return MethodResult(op_str, dtype)
@@ -264,7 +265,7 @@ def _compare(prev_op, other, op_sign, op_sign_python_level=None):
         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}'")
+        raise _type_error_for_op(f"{op_sign_python_level or op_sign}", f"'{left_t}' and '{right_t}'")
 
 
 def and_(prev_op, other):
@@ -281,7 +282,7 @@ def _and_or(prev_op, other, op_sign):
         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}'")
+        raise _type_error_for_op(f"{op_sign}", f"'{left_t}' and '{right_t}'")
 
 
 def is_arithmetical(op):

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

@@ -148,3 +148,4 @@ def _get_wideclass(left, right):
         return left
     if issubclass(right, left):
         return right
+    return None