onetick-py 1.177.0__py3-none-any.whl

onetick/py/core/_source/source_methods/data_quality.py

@@ -0,0 +1,301 @@
+import typing
+from typing import TYPE_CHECKING, Optional, Union
+
+from onetick.py.otq import otq
+from onetick.py.core.column_operations.base import _Operation
+from onetick.py.backports import Literal
+from .misc import inplace_operation
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source
+
+
+DATA_QUALITY_EVENTS = Literal[
+    'COLLECTOR_FAILURE',
+    'EMPTY',
+    'MISSING',
+    'MOUNT_BAD',
+    'OK',
+    'PATCHED',
+    'QUALITY_DELAY_STITCHING_WITH_RT',
+    'QUALITY_OK_STITCHING_WITH_RT',
+    'STALE',
+]
+
+
+@inplace_operation
+def show_data_quality(self: 'Source', inplace=False) -> Optional['Source']:
+    """
+    This method shows data quality events within the interval of the query.
+
+    Parameters
+    ----------
+    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
+    --------
+    | **SHOW_DATA_QUALITY** OneTick event processor
+    | :py:meth:`insert_data_quality_event`
+    | :py:meth:`intercept_data_quality`
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    Examples
+    --------
+
+    By default data quality events are not showed, use this method to see them:
+
+    >>> data = otp.Ticks({'A': [1, 2, 3]})
+    >>> data = data.insert_data_quality_event('OK')
+    >>> data = data.show_data_quality()
+    >>> otp.run(data)
+                         Time  DATA_QUALITY_TYPE DATA_QUALITY_NAME
+    0 2003-12-01 00:00:00.000                  0                OK
+    1 2003-12-01 00:00:00.001                  0                OK
+    2 2003-12-01 00:00:00.002                  0                OK
+    """
+
+    self.sink(
+        otq.ShowDataQuality()
+    )
+    self.schema.set(**{'DATA_QUALITY_TYPE': int, 'DATA_QUALITY_NAME': str})
+    return self
+
+
+@inplace_operation
+def insert_data_quality_event(
+    self: 'Source',
+    data_quality: DATA_QUALITY_EVENTS,
+    where: Optional[Union[str, _Operation]] = None,
+    insert_before: bool = True,
+    inplace=False,
+) -> Optional['Source']:
+    """
+    Insert data quality events into the data flow.
+
+    Parameters
+    ----------
+    data_quality: str
+        The type of data quality event.
+        Must be one of the supported data quality event types.
+    where: str or :class:`Operation`
+        Specifies a criterion for the selection of ticks whose arrival results in generation of a data quality event.
+        If this expression returns True, a data quality event will be inserted into a time series.
+        The expression can also be empty (default), in which case each input tick generates a data quality event.
+    insert_before: bool
+        If True (default),
+        generated data quality event tick will be inserted before the input tick that triggered its creation,
+        otherwise generated data quality event will be inserted after that input tick.
+    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_DATA_QUALITY_EVENT** OneTick event processor
+    | :py:meth:`show_data_quality`
+    | :py:meth:`intercept_data_quality`
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    Examples
+    --------
+    Insert OK data quality event before each tick:
+
+    >>> data = otp.Ticks({'A': [1, 2, 3]})
+    >>> data = data.insert_data_quality_event('OK')
+    >>> otp.run(data)
+                         Time  A
+    0 2003-12-01 00:00:00.000  1
+    1 2003-12-01 00:00:00.001  2
+    2 2003-12-01 00:00:00.002  3
+
+    By default data quality events are not showed,
+    use :py:meth:`show_data_quality` method to see them:
+
+    >>> data = otp.Ticks({'A': [1, 2, 3]})
+    >>> data = data.insert_data_quality_event('OK')
+    >>> data = data.show_data_quality()
+    >>> otp.run(data)
+                         Time  DATA_QUALITY_TYPE DATA_QUALITY_NAME
+    0 2003-12-01 00:00:00.000                  0                OK
+    1 2003-12-01 00:00:00.001                  0                OK
+    2 2003-12-01 00:00:00.002                  0                OK
+
+    Use ``where`` parameter to specify the condition when to insert ticks:
+
+    >>> data = otp.Ticks({'SIZE': [1, 200, 3]})
+    >>> data = data.insert_data_quality_event('MISSING', where=data['SIZE'] > 100)
+    >>> data = data.show_data_quality()
+    >>> otp.run(data)
+                         Time  DATA_QUALITY_TYPE DATA_QUALITY_NAME
+    0 2003-12-01 00:00:00.001                  2           MISSING
+    """
+    if data_quality not in typing.get_args(DATA_QUALITY_EVENTS):
+        raise ValueError(f"Parameter 'data_quality' doesn't support value: {data_quality}")
+
+    self.sink(
+        otq.InsertDataQualityEvent(
+            data_quality=data_quality,
+            where=str(where) if where is not None else '',
+            insert_before=insert_before,
+        )
+    )
+
+    return self
+
+
+@inplace_operation
+def intercept_data_quality(self: 'Source', inplace=False) -> Optional['Source']:
+    """
+    This method removes data quality messages, thus preventing them from delivery to the client application.
+
+    Parameters
+    ----------
+    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
+    --------
+    | **INTERCEPT_DATA_QUALITY** OneTick event processor
+    | :py:meth:`insert_data_quality_event`
+    | :py:meth:`show_data_quality`
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    Examples
+    --------
+
+    By default data quality events are not showed, use this method to see them:
+
+    >>> data = otp.Ticks({'A': [1, 2, 3]})
+    >>> data = data.insert_data_quality_event('OK')
+    >>> data = data.show_data_quality()
+    >>> otp.run(data)
+                         Time  DATA_QUALITY_TYPE DATA_QUALITY_NAME
+    0 2003-12-01 00:00:00.000                  0                OK
+    1 2003-12-01 00:00:00.001                  0                OK
+    2 2003-12-01 00:00:00.002                  0                OK
+
+    Intercepting data quality events will remove them from the data flow:
+
+    >>> data = otp.Ticks({'A': [1, 2, 3]})
+    >>> data = data.insert_data_quality_event('OK')
+    >>> data = data.intercept_data_quality()
+    >>> data = data.show_data_quality()
+    >>> otp.run(data)  # doctest: +ELLIPSIS
+    Empty DataFrame
+    ...
+    """
+    self.sink(
+        otq.InterceptDataQuality()
+    )
+    return self
+
+
+@inplace_operation
+def show_symbol_errors(self: 'Source', inplace=False) -> Optional['Source']:
+    """
+    This method propagates a tick representing per-symbol error.
+
+    Parameters
+    ----------
+    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
+    --------
+    | **SHOW_SYMBOL_ERRORS** OneTick event processor
+    | :py:meth:`intercept_symbol_errors`
+    | :py:meth:`onetick.py.Source.throw`
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    Examples
+    --------
+
+    By default symbol errors are not showed, use this method to see them:
+
+    >>> data = otp.Ticks({'A': [1, 2, 3]})
+    >>> data = data.throw('WRONG', scope='symbol')
+    >>> data = data.show_symbol_errors()
+    >>> otp.run(data)
+            Time  ERROR_CODE ERROR_MESSAGE
+    0 2003-12-01           1         WRONG
+    1 2003-12-01           1         WRONG
+    2 2003-12-01           1         WRONG
+    """
+
+    self.sink(
+        otq.ShowSymbolErrors()
+    )
+    self.schema.set(**{'ERROR_CODE': int, 'ERROR_MESSAGE': str})
+    return self
+
+
+@inplace_operation
+def intercept_symbol_errors(self: 'Source', inplace=False) -> Optional['Source']:
+    """
+    This method removes removes per-symbol errors, thus preventing them from delivery to the client application.
+
+    Parameters
+    ----------
+    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
+    --------
+    | **INTERCEPT_SYMBOL_ERRORS** OneTick event processor
+    | :py:meth:`show_symbol_errors`
+    | :py:meth:`onetick.py.Source.throw`
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    Examples
+    --------
+
+    By default data quality events are not showed, use this method to see them:
+
+    >>> data = otp.Ticks({'A': [1, 2, 3]})
+    >>> data = data.throw('WRONG', scope='symbol')
+    >>> data = data.show_symbol_errors()
+    >>> otp.run(data)
+            Time  ERROR_CODE ERROR_MESSAGE
+    0 2003-12-01           1         WRONG
+    1 2003-12-01           1         WRONG
+    2 2003-12-01           1         WRONG
+
+    Intercepting data quality events will remove them from the data flow:
+
+    >>> data = otp.Ticks({'A': [1, 2, 3]})
+    >>> data = data.throw('WRONG', scope='symbol')
+    >>> data = data.intercept_symbol_errors()
+    >>> data = data.show_symbol_errors()
+    >>> otp.run(data)  # doctest: +ELLIPSIS
+    Empty DataFrame
+    ...
+    """
+    self.sink(
+        otq.InterceptSymbolErrors()
+    )
+    return self

onetick/py/core/_source/source_methods/debugs.py

@@ -0,0 +1,272 @@
+from typing import TYPE_CHECKING, Callable, List, Optional, Tuple, Union
+
+from onetick import py as otp
+from onetick.py import configuration
+from onetick.py.otq import otq
+
+from .misc import inplace_operation
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source
+
+
+@inplace_operation
+def throw(
+    self: 'Source', message='', where=1, scope='query', error_code=1, throw_before_query_execution=False, inplace=False
+) -> Optional['Source']:
+    """
+    Propagates error or warning or throws an exception (depending on ``scope`` parameter)
+    when condition provided by ``where`` parameter evaluates to True.
+
+    Throwing an exception will abort query execution,
+    propagating error will stop tick propagation and
+    propagating warning will not change the data processing.
+
+    Parameters
+    ----------
+    message: str or Operation
+        Message that will be thrown in exception or returned in error message.
+    where: Operation
+        Logical expression that specifies condition when exception or error will be thrown.
+    scope: 'query' or 'symbol'
+        'query' will throw an exception and 'symbol' will propagate an error or warning
+        depending on ``error_code`` parameter.
+    error_code: int
+        When ``scope='symbol'``, values from interval ``[1, 500]`` indicate warnings
+        and values from interval ``[1500, 2000]`` indicate errors.
+        Note that tick propagation will not stop when warning is raised,
+        and will stop when error is raised.
+
+        This parameter is not used when ``scope='query'``.
+    throw_before_query_execution: bool
+        If set to ``True``, the exception will be thrown before the execution of the query.
+        This option is intended for supplying placeholder queries that must always throw.
+    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
+    --------
+    **THROW** OneTick event processor
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    Examples
+    --------
+
+    By default, this method will throw an exception on the first tick with empty message:
+
+    >>> t = otp.Tick(A=1)
+    >>> t = t.throw()
+    >>> otp.run(t)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+        ...
+    Exception: ...: In THROW: ...
+        ...
+
+    You can specify exception message and condition (note that exception now is raised on second tick):
+
+    >>> t = otp.Ticks(A=[1, 2])
+    >>> t = t.throw(message='A is ' + t['A'].apply(str), where=(t['A']==2))
+    >>> otp.run(t)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+        ...
+    Exception: ...: In THROW: A is 2. ...
+        ...
+
+    Note that exception will not be thrown if there are no ticks:
+
+    >>> t = otp.Empty()
+    >>> t = t.throw()
+    >>> otp.run(t)
+    Empty DataFrame
+    Columns: []
+    Index: []
+
+    If you need exception to be thrown always, you can use ``throw_before_query_execution`` parameter:
+
+    >>> t = otp.Empty()
+    >>> t = t.throw(throw_before_query_execution=True)
+    >>> otp.run(t)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+        ...
+    Exception: ...: In THROW: ...
+
+    You can throw OneTick errors and warnings instead of exceptions.
+    Raising error codes from 1 to 500 indicates warnings.
+    Raising error codes from 1500 to 2000 indicates errors.
+    Tick propagation stops only when error is raised.
+
+    >>> 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)
+                         Time  A
+    0 2003-12-01 00:00:00.000  1
+    1 2003-12-01 00:00:00.001  2
+
+    Right now the only supported interface to get errors and warnings
+    is via ``map`` output structure and its methods:
+
+    >>> otp.run(t, symbols='AAPL', output_structure='map').output('AAPL').error
+    [(2, 'warning A=1'), (1502, 'error A=3')]
+    """
+    if isinstance(message, str):
+        treat_message_as_per_tick_expr = False
+    else:
+        treat_message_as_per_tick_expr = True
+    if scope not in {'query', 'symbol'}:
+        raise ValueError("Parameter 'scope' can only be set to 'query' or 'symbol'")
+    if not (1 <= error_code <= 500 or 1500 <= error_code <= 2000):
+        raise ValueError(
+            "Parameter 'error_code' can only take values "
+            "from interval [1, 500] for warnings and from interval [1500, 2000] for errors"
+        )
+    self.sink(
+        otq.Throw(
+            message=str(message),
+            treat_message_as_per_tick_expr=treat_message_as_per_tick_expr,
+            where=str(where),
+            scope=scope.upper(),
+            error_code=error_code,
+            throw_before_query_execution=throw_before_query_execution,
+        )
+    )
+    return self
+
+
+@inplace_operation
+def logf(
+    self: 'Source', message: str, severity: str, *args, where: Optional['otp.Operation'] = None, inplace: bool = False
+) -> Optional['Source']:
+    """
+    Call built-in OneTick ``LOGF`` function.
+
+    Parameters
+    ----------
+    message: str
+        Log message/format string. The underlying formatting engine is the Boost Format Library:
+        https://www.boost.org/doc/libs/1_53_0/libs/format/doc/format.html
+
+    severity: str
+        Severity of message. Supported values: ``ERROR``, ``WARNING`` and ``INFO``.
+
+    where: Operation
+        A condition that allows to filter ticks to call ``LOGF`` on. ``None`` for no filtering.
+
+    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.
+
+    args: list
+        Parameters for format string (optional).
+
+    Returns
+    -------
+    :class:`Source`
+
+    Examples
+    --------
+    >>> data = otp.Ticks(PRICE=[97, 99, 103])
+    >>> data = data.logf("PRICE (%1%) is higher than 100", "WARNING", data["PRICE"], where=(data["PRICE"] > 100))
+    """
+
+    where_in_tick = where if where is not None else True
+
+    def per_tick_script(tick):
+        if where_in_tick:
+            otp.logf(message, severity, *args)
+
+    return self.script(per_tick_script, inplace=inplace)
+
+
+def dump(
+    self: 'Source',
+    label: Optional[str] = None,
+    where: Optional['otp.Operation'] = None,
+    columns: Union[str, Tuple[str], List[str], None] = None,
+    callback: Optional[Callable] = None,
+):
+    """
+    Dumps the ``columns`` from ticks into std::out in runtime if they fit the ``where`` condition.
+    Every dump has a corresponding header that always includes the TIMESTAMP field. Other fields
+    could be configured using the ``columns`` parameter. A header could be augmented with a ``label`` parameter;
+    this label is an addition column that helps to distinguish ticks
+    from multiple dumps with the same schema, because ticks from different dumps could be mixed.
+    It might happen because of the OneTick multithreading, and there is the operating system
+    buffer between the OneTick and the actual output.
+
+    This method is helpful for debugging.
+
+    Parameters
+    ----------
+    label: str
+        A label for a dump. It adds a special column **_OUT_LABEL_** for all ticks and set to the
+        specified value. It helps to distinguish ticks from multiple dumps, because actual
+        output could contain mixed ticks due the concurrency. ``None`` means no label.
+    where: Operation
+        A condition that allows to filter ticks to dump. ``None`` means no filtering.
+    columns: str, tupel or list
+        List of columns that should be in the output. ``None`` means dump all columns.
+    callback : callable
+        Callable, which preprocess source before printing.
+
+    See also
+    --------
+    **WRITE_TEXT** OneTick event processor
+
+    Examples
+    --------
+    >>> # OTdirective: skip-snippet:;
+    >>> data.dump(label='Debug point', where=data['PRICE'] > 99.3, columns=['PRICE', 'QTY'])    # doctest: +SKIP
+    >>> data.dump(columns="X", callback=lambda x: x.first(), label="first")     # doctest: +SKIP
+    """
+
+    self_c = self.copy()
+    if callback:
+        self_c = callback(self_c)
+    if where is not None:  # can't be simplified because the _Operation overrides __bool__
+        self_c, _ = self_c[(where)]
+    if columns:
+        self_c = self_c[columns if isinstance(columns, (list, tuple)) else [columns]]
+    if label:
+        self_c['_OUT_LABEL_'] = label
+
+    self_c.write_text(
+        formats_of_fields={'TIMESTAMP': f'%|{configuration.config.tz}|%d-%m-%Y %H:%M:%S.%J'},
+        prepend_timestamp=True,
+        prepend_symbol_name=False,
+        propagate_ticks=True,
+        inplace=True,
+    )
+
+    # print <no data> in case there are 0 ticks
+    if hasattr(otq, 'InsertAtEnd'):
+        self_c.sink(otq.InsertAtEnd(delimiter_name='AT_END'))
+        self_c.schema['AT_END'] = int
+        self_c.state_vars['COUNT'] = otp.state.var(0, scope='branch')
+        self_c.state_vars['COUNT'] += 1
+        self_c, _ = self_c[(self_c['AT_END'] == 1) & (self_c.state_vars['COUNT'] == 1)]
+        self_c['NO_DATA'] = '<no data>'
+        self_c = self_c[['NO_DATA']]
+        self_c.write_text(output_headers=False, prepend_timestamp=False, prepend_symbol_name=False,
+                          propagate_ticks=False, inplace=True)
+
+    # Do not propagate ticks then, because we want just to write them into
+    # the std::out. We have to do that, because otherwise these ticks would
+    # go to a query output, that would mess real output.
+    self_c, _ = self_c[self_c['Time'] != self_c['Time']]  # NOSONAR
+
+    # We have to merge the branch back to the main branch even that these
+    # branch does not generate ticks, because we do not introduce one more
+    # output point, because the OneTick would add it to the final output
+    # datastructure.
+    self.sink(otq.Merge(identify_input_ts=False))
+
+    self.source(self_c.node().copy_graph())  # NOSONAR
+    self.node().add_rules(self_c.node().copy_rules())
+    self._merge_tmp_otq(self_c)

onetick/py/core/_source/source_methods/drops.py

@@ -0,0 +1,120 @@
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from onetick.py.otq import otq
+
+from .misc import inplace_operation
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source
+
+
+@inplace_operation
+def drop(self: 'Source', columns: List[Any], inplace=False) -> Optional['Source']:
+    r"""
+    Remove a list of columns specified by names or regular expressions from the Source.
+
+    If a column with such name wasn't found the error will be raised,
+    if the regex was specified and there aren't any matched columns, do nothing.
+
+    Regex is any string containing any of characters ***+?\:[]{}()**,
+    dot is a valid symbol for OneTick identifier,
+    so **a.b** will be passed to OneTick as an identifier,
+    if you want specify such regex use parenthesis - **(a.b)**
+
+    If a string without special characters or :py:class:`~onetick.py.Column` object is specified in the list,
+    then it is assumed that this is a literal name of the column, not regular expression.
+
+    Parameters
+    ----------
+    columns : str, Column or list of them
+        Column(s) to remove. You could specify a regex or collection of regexes, in such case columns with
+        match names will be deleted.
+    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.
+
+    Returns
+    ----------
+    :class:`Source` or ``None``
+
+    See Also
+    --------
+    **PASSTHROUGH** OneTick event processor
+
+    Examples
+    --------
+
+    Drop a single field:
+
+    >>> data = otp.Ticks(X1=[1, 2, 3],
+    ...                  X2=[3, 2, 1],
+    ...                  A1=["A", "A", "A"])
+    >>> data = data.drop("X1")  # OTdirective: snippet-name: Arrange.drop.one field;
+    >>> otp.run(data)
+                         Time  X2 A1
+    0 2003-12-01 00:00:00.000   3  A
+    1 2003-12-01 00:00:00.001   2  A
+    2 2003-12-01 00:00:00.002   1  A
+
+    Regexes also could be specified in such case all matched columns will be deleted:
+
+    >>> data = otp.Ticks(X1=[1, 2, 3],
+    ...                  X2=[3, 2, 1],
+    ...                  A1=["A", "A", "A"])
+    >>> data = data.drop(r"X\d+")   # OTdirective: snippet-name: Arrange.drop.regex;
+    >>> otp.run(data)
+                         Time A1
+    0 2003-12-01 00:00:00.000  A
+    1 2003-12-01 00:00:00.001  A
+    2 2003-12-01 00:00:00.002  A
+
+    Both column names and regular expressions can be specified at the same time:
+
+    >>> # OTdirective: snippet-name: Arrange.drop.multiple;
+    >>> data = otp.Ticks(X1=[1, 2, 3],
+    ...                  X2=[3, 2, 1],
+    ...                  Y1=[1, 2, 3],
+    ...                  Y2=[3, 2, 1],
+    ...                  Y11=["a", "b", "c"],
+    ...                  Y22=["A", "A", "A"])
+    >>> data = data.drop([r"X\d+", "Y1", data["Y2"]])
+    >>> otp.run(data)
+                         Time Y11 Y22
+    0 2003-12-01 00:00:00.000   a   A
+    1 2003-12-01 00:00:00.001   b   A
+    2 2003-12-01 00:00:00.002   c   A
+
+    **a.b** will be passed to OneTick as an identifier,
+    if you want specify such regex use parenthesis - **(a.b)**:
+
+    >>> data = otp.Ticks({"COLUMN.A": [1, 2, 3], "COLUMN1A": [3, 2, 1],
+    ...                   "COLUMN1B": ["a", "b", "c"], "COLUMN2A": ["c", "b", "a"]})
+    >>> data = data.drop("COLUMN.A")    # OTdirective: skip-snippet:;
+    >>> otp.run(data)
+                         Time  COLUMN1A COLUMN1B COLUMN2A
+    0 2003-12-01 00:00:00.000         3        a        c
+    1 2003-12-01 00:00:00.001         2        b        b
+    2 2003-12-01 00:00:00.002         1        c        a
+
+    >>> data = otp.Ticks({"COLUMN.A": [1, 2, 3], "COLUMN1A": [3, 2, 1],
+    ...                   "COLUMN1B": ["a", "b", "c"], "COLUMN2A": ["c", "b", "a"]})
+    >>> data = data.drop("(COLUMN.A)")  # OTdirective: skip-snippet:;
+    >>> otp.run(data)
+                         Time COLUMN1B
+    0 2003-12-01 00:00:00.000        a
+    1 2003-12-01 00:00:00.001        b
+    2 2003-12-01 00:00:00.002        c
+    """
+    self.__delitem__(columns)
+    return self
+
+
+def __delitem__(self: 'Source', obj):
+    if isinstance(obj, (list, tuple)):
+        objs = obj
+    else:
+        objs = (obj,)
+
+    items_to_passthrough, regex = self._columns_names_regex(objs, drop=True)
+    self.sink(otq.Passthrough(drop_fields=True, fields=",".join(items_to_passthrough), use_regex=regex))