onetick-py 1.177.0__py3-none-any.whl

onetick/py/core/_source/source_methods/pandases.py

@@ -0,0 +1,155 @@
+from typing import TYPE_CHECKING
+
+from onetick import py as otp
+
+if TYPE_CHECKING:
+    import pandas
+    from onetick.py.core.source import Source
+
+
+def plot(self: 'Source', y, x='Time', kind='line', **kwargs):
+    """
+    Executes the query with known properties and builds a plot resulting dataframe.
+
+    Uses the :pandas:`pandas.DataFrame.plot` method to plot data.
+    Other parameters could be specified through the ``kwargs``.
+
+    Parameters
+    ----------
+    x: str
+        Column name for the X axis
+    y: str
+        Column name for the Y axis
+    kind: str
+        The kind of plot
+
+    Examples
+    --------
+    >>> data = otp.Ticks(X=[1, 2, 3])
+    >>> data.plot(y='X', kind='bar')  # doctest: +SKIP
+    """
+    result = self.copy()
+    return result[[y, x]]().plot(x=x, y=y, kind=kind, **kwargs)
+
+
+def count(self: 'Source', **kwargs) -> int:
+    """
+    Returns the number of ticks in the query.
+
+    Adds an aggregation that calculate total ticks count, and *executes a query*.
+    Result is a single value -- number of ticks. Possible application is the Jupyter when
+    a developer wants to check data presences for example.
+
+    Parameters
+    ----------
+    kwargs
+        parameters that will be passed to :py:func:`otp.run <onetick.py.run>`
+
+    Returns
+    -------
+    int
+
+    See Also
+    --------
+    | :py:func:`onetick.py.agg.count`
+    | :py:func:`otp.run <onetick.py.run>`
+    | :py:meth:`onetick.py.Source.head`
+    | :py:meth:`onetick.py.Source.tail`
+
+    Examples
+    --------
+
+    >>> data = otp.Ticks(X=[1, 2, 3])
+    >>> data.count()
+    3
+
+    >>> data = otp.Empty()
+    >>> data.count()
+    0
+    """
+    result = self.copy()
+    df = otp.run(result.agg({'__num_rows': otp.agg.count()}), **kwargs)
+    if df.empty:
+        return 0
+    return int(df['__num_rows'][0])
+
+
+def head(self: 'Source', n=5, **kwargs) -> 'pandas.DataFrame':
+    """
+    *Executes the query* and returns first ``n`` ticks as a pandas dataframe.
+
+    It is useful in the Jupyter case when you want to observe first ``n`` values.
+
+    Parameters
+    ----------
+    n: int, default=5
+        number of ticks to return
+    kwargs:
+        parameters will be passed to :py:func:`otp.run <onetick.py.run>`
+
+    Returns
+    -------
+    :pandas:`DataFrame <pandas.DataFrame>`
+
+    See Also
+    --------
+    | :py:func:`onetick.py.agg.first`
+    | :py:func:`otp.run <onetick.py.run>`
+    | :py:meth:`onetick.py.Source.tail`
+    | :py:meth:`onetick.py.Source.count`
+
+    Examples
+    --------
+
+    >>> data = otp.Ticks(X=list('abcdefgik'))
+    >>> data.head()[['X']]
+        X
+    0 a
+    1 b
+    2 c
+    3 d
+    4 e
+    """
+    result = self.copy()
+    result = result.first(n=n)  # pylint: disable=E1123
+    return otp.run(result, **kwargs)
+
+
+def tail(self: 'Source', n=5, **kwargs) -> 'pandas.DataFrame':
+    """
+    *Executes the query* and returns last ``n`` ticks as a pandas dataframe.
+
+    It is useful in the Jupyter case when you want to observe last ``n`` values.
+
+    Parameters
+    ----------
+    n: int
+        number of ticks to return
+    kwargs:
+        parameters will be passed to :py:func:`otp.run <onetick.py.run>`
+
+    Returns
+    -------
+    :pandas:`DataFrame <pandas.DataFrame>`
+
+    See Also
+    --------
+    | :py:func:`onetick.py.agg.last`
+    | :py:func:`otp.run <onetick.py.run>`
+    | :py:meth:`onetick.py.Source.head`
+    | :py:meth:`onetick.py.Source.count`
+
+    Examples
+    --------
+    >>> data = otp.Ticks(X=list('abcdefgik'))
+    >>> data.tail()[['X']]
+        X
+    0 e
+    1 f
+    2 g
+    3 i
+    4 k
+    """
+    result = self.copy()
+    result = result.last(n=n)  # pylint: disable=E1123
+    return otp.run(result, **kwargs)

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

@@ -0,0 +1,356 @@
+import re
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from onetick.py.core.column import _Column
+from onetick.py.otq import otq
+
+from .misc import inplace_operation
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source
+
+
+def _add_prefix_and_suffix(
+    self: 'Source',
+    prefix='',
+    suffix='',
+    columns=None,
+    ignore_columns=None,
+) -> Optional['Source']:
+    if not prefix and not suffix:
+        raise ValueError('Both suffix and prefix are empty')
+    if ' ' in prefix:
+        raise ValueError(f'There is space in prefix: {prefix}')
+    if ' ' in suffix:
+        raise ValueError(f'There is space in suffix: {prefix}')
+    columns = columns or []
+    ignore_columns = ignore_columns or []
+    if columns and ignore_columns:
+        raise ValueError('It is allowed to use only one of `columns` or `ignore_columns` parameters at a time')
+    schema = self.schema
+    for column in columns:
+        if column not in schema:
+            raise AttributeError(f'Column `{column}` does not exist in the schema')
+    for column_name in columns or schema:
+        if column_name in ignore_columns:
+            continue
+        new_column_name = f'{prefix}{column_name}{suffix}'
+        if new_column_name in self.__dict__:
+            if (not columns and not ignore_columns
+                    or columns and new_column_name in columns
+                    or ignore_columns and new_column_name not in ignore_columns):
+                # if the column with the same name already exists, but will be renamed too,
+                # then we don't need to raise exception, as it will have a different name after renaming
+                continue
+            if prefix:
+                raise AttributeError(f'Column {new_column_name} already exists, please, use another prefix')
+            else:
+                raise AttributeError(f'Column {new_column_name} already exists, please, use another suffix')
+    for column_name in columns or schema:
+        if column_name in ignore_columns:
+            continue
+        new_column_name = f'{prefix}{column_name}{suffix}'
+        self.__dict__[column_name].rename(new_column_name, update_parent_object=False)
+        self.__dict__[new_column_name] = self.__dict__[column_name]
+        del self.__dict__[column_name]
+    if not columns and not ignore_columns:
+        self.sink(otq.RenameFieldsEp(rename_fields=f'(.*)={prefix}\\1{suffix}', use_regex=True))
+    elif columns:
+        renames = [f'{column}={prefix}{column}{suffix}' for column in columns]
+        self.sink(otq.RenameFieldsEp(rename_fields=','.join(renames)))
+    else:
+        renames = [f'{column}={prefix}{column}{suffix}' for column in schema if column not in ignore_columns]
+        self.sink(otq.RenameFieldsEp(rename_fields=','.join(renames)))
+    return self
+
+
+def _is_excluded(s: str, not_to_rename: List[str]) -> bool:
+    for excluded in not_to_rename:
+        if re.match(excluded, s):
+            return True
+    return False
+
+
+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
+    as an onetick's param, but rename all matched columns from python Source cache.
+
+    Parameters
+    ----------
+    rename_dict:
+        Dict old_name -> new_name. Some of the dictionary's items use regex.
+
+    Returns
+    -------
+    output_dict:
+        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_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)
+    return output_dict
+
+
+@inplace_operation
+def add_prefix(self: 'Source', prefix, inplace=False, columns=None, ignore_columns=None) -> Optional['Source']:
+    """
+    Adds prefix to all column names (except **TIMESTAMP** (or **Time**) special column).
+
+    Parameters
+    ----------
+    prefix : str
+        String prefix to add to all columns.
+    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.
+    columns: List[str], optional
+        If set, only selected columns will be updated with prefix. Can't be used with ``ignore_columns`` parameter.
+    ignore_columns: List[str], optional
+        If set, selected columns won't be updated with prefix. Can't be used with ``columns`` parameter.
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    Examples
+    --------
+
+    Add prefix *test_* to all columns (note that column **Time** is not renamed):
+
+    >>> data = otp.DataSource(db='US_COMP', tick_type='TRD', symbols='AAPL')
+    >>> data = data.add_prefix('test_')
+    >>> otp.run(data, start=otp.dt(2022, 3, 1), end=otp.dt(2022, 3, 2))
+                         Time  test_PRICE  test_SIZE
+    0 2022-03-01 00:00:00.000         1.3        100
+    1 2022-03-01 00:00:00.001         1.4         10
+    2 2022-03-01 00:00:00.002         1.4         50
+
+    Parameter ``columns`` specifies columns to be updated with prefix:
+
+    >>> data = otp.Tick(A=1, B=2, C=3, D=4, E=5)
+    >>> data = data.add_prefix('test_', columns=['A', 'B', 'C'])
+    >>> otp.run(data)
+            Time  test_A  test_B  test_C  D  E
+    0 2003-12-01       1       2       3  4  5
+
+    Parameter ``ignore_columns`` specifies columns to ignore:
+
+    >>> data = otp.Tick(A=1, B=2, C=3, D=4, E=5)
+    >>> data = data.add_prefix('test_', ignore_columns=['A', 'B', 'C'])
+    >>> otp.run(data)
+            Time  A  B  C  test_D  test_E
+    0 2003-12-01  1  2  3       4       5
+
+    Parameters ``columns`` and ``ignore_columns`` can't be used at the same time:
+
+    >>> data = otp.Tick(A=1, B=2, C=3, D=4, E=5)
+    >>> data.add_prefix('test_', columns=['B', 'C'], ignore_columns=['A'])
+    Traceback (most recent call last):
+        ...
+    ValueError: It is allowed to use only one of `columns` or `ignore_columns` parameters at a time
+
+    Columns can't be renamed if their resulting name will be equal to existing column name:
+
+    >>> data = otp.Tick(X=1, XX=2)
+    >>> data.add_prefix('X', columns=['X'])
+    Traceback (most recent call last):
+        ...
+    AttributeError: Column XX already exists, please, use another prefix
+
+    """
+    return self._add_prefix_and_suffix(
+        prefix=prefix,
+        columns=columns,
+        ignore_columns=ignore_columns,
+    )
+
+
+@inplace_operation
+def add_suffix(self: 'Source', suffix, inplace=False, columns=None, ignore_columns=None) -> Optional['Source']:
+    """
+    Adds suffix to all column names (except **TIMESTAMP** (or **Time**) special column).
+
+    Parameters
+    ----------
+    suffix : str
+        String suffix to add to all columns.
+    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.
+    columns: List[str], optional
+        If set, only selected columns will be updated with suffix. Can't be used with ``ignore_columns`` parameter.
+    ignore_columns: List[str], optional
+        If set, selected columns won't be updated with suffix. Can't be used with ``columns`` parameter.
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    Examples
+    --------
+
+    Add suffix *_test* to all columns (note that column **Time** is not renamed):
+
+    >>> data = otp.DataSource(db='US_COMP', tick_type='TRD', symbols='AAPL')
+    >>> data = data.add_suffix('_test')
+    >>> otp.run(data, start=otp.dt(2022, 3, 1), end=otp.dt(2022, 3, 2))
+                         Time  PRICE_test  SIZE_test
+    0 2022-03-01 00:00:00.000         1.3        100
+    1 2022-03-01 00:00:00.001         1.4         10
+    2 2022-03-01 00:00:00.002         1.4         50
+
+    Parameter ``columns`` specifies columns to be updated with suffix:
+
+    >>> data = otp.Tick(A=1, B=2, C=3, D=4, E=5)
+    >>> data = data.add_suffix('_test', columns=['A', 'B', 'C'])
+    >>> otp.run(data)
+            Time  A_test  B_test  C_test  D  E
+    0 2003-12-01       1       2       3  4  5
+
+    Parameter ``ignore_columns`` specifies columns to ignore:
+
+    >>> data = otp.Tick(A=1, B=2, C=3, D=4, E=5)
+    >>> data = data.add_suffix('_test', ignore_columns=['A', 'B', 'C'])
+    >>> otp.run(data)
+            Time  A  B  C  D_test  E_test
+    0 2003-12-01  1  2  3       4       5
+
+    Parameters ``columns`` and ``ignore_columns`` can't be used at the same time:
+
+    >>> data = otp.Tick(A=1, B=2, C=3, D=4, E=5)
+    >>> data.add_suffix('_test', columns=['B', 'C'], ignore_columns=['A'])
+    Traceback (most recent call last):
+        ...
+    ValueError: It is allowed to use only one of `columns` or `ignore_columns` parameters at a time
+
+    Columns can't be renamed if their resulting name will be equal to existing column name:
+
+    >>> data = otp.Tick(X=1, XX=2)
+    >>> data.add_suffix('X', columns=['X'])
+    Traceback (most recent call last):
+        ...
+    AttributeError: Column XX already exists, please, use another suffix
+    """
+    return self._add_prefix_and_suffix(
+        suffix=suffix,
+        columns=columns,
+        ignore_columns=ignore_columns,
+    )
+
+
+@inplace_operation
+def rename(self: 'Source', columns=None, use_regex=False, fields_to_skip=None, inplace=False) -> Optional['Source']:
+    r"""
+    Rename columns
+
+    Parameters
+    ----------
+    columns : dict
+        Rules how to rename in the following format: {<column> : <new-column-name>},
+        where <column> is either existing column name of str type or reference to a column,
+        and <new-column-name> a new column name of str type.
+    use_regex: bool
+        If true, then old-name=new-name pairs in the `columns` parameter are treated as regular expressions.
+        This allows bulk renaming for field names. Notice that regular expressions for old names are treated as
+        if both their prefix and their suffix are .*, i.e. the prefix and suffix match any substring.
+        As a result, old-name *XX* will match all of *aXX*, *aXXB*, and *XXb*, when `use_regex=true`.
+        You can have old-name begin from ^ to indicate that .* prefix does not apply,
+        and you can have old name end at $ to indicate that .* suffix does not apply.
+        Default: false
+    fields_to_skip: list of str
+        A list of regular expressions for specifying fields that should be skipped
+        (i.e., not be renamed). If a field is matched by one of the specified regular expressions,
+        it won't be considered for renaming.
+        Default: None
+    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.
+
+    Returns
+    -------
+    :class:`Source` or ``None``
+
+    See also
+    --------
+    **RENAME** OneTick event processor
+
+    Examples
+    --------
+    >>> data = otp.Ticks(X=[1], Y=[2])
+    >>> data = data.rename({'X': 'XX',
+    ...                     data['Y']: 'YY'})
+    >>> otp.run(data)
+            Time  XX  YY
+    0 2003-12-01   1   2
+
+    >>> data = otp.Tick(**{'X.X': 1, 'X.Y': 2})
+    >>> data = data.rename({r'X\.(.*)': r'\1'}, use_regex=True)
+    >>> otp.run(data)
+            Time   X   Y
+    0 2003-12-01   1   2
+
+    >>> data = otp.Tick(**{'X.X': 1, 'X.Y': 2})
+    >>> data = data.rename({r'X\.(.*)': r'\1'}, use_regex=True, fields_to_skip=['X.Y'])
+    >>> otp.run(data)
+            Time   X X.Y
+    0 2003-12-01   1   2
+    """
+    if columns is None:
+        columns = {}
+
+    # prepare
+    items = {}
+    out_names = set()
+    fields_to_skip = fields_to_skip or []
+
+    for in_obj, out_obj in columns.items():
+        if isinstance(in_obj, _Column):
+            items[in_obj.name.strip()] = out_obj.strip()
+        elif isinstance(in_obj, str):
+            items[in_obj.strip()] = out_obj.strip()
+        else:
+            raise TypeError(f"It is not supported to rename item '{in_obj}' of type {type(in_obj)}'")
+
+        if out_obj in out_names:
+            raise AttributeError(
+                f"You want to rename '{in_obj}' into '{out_obj}', "
+                f"but also want to rename another column into '{out_obj}'"
+            )
+
+        out_names.add(out_obj)
+
+    schema_update_dict = items
+    if use_regex:
+        schema_update_dict = _get_columns_names_renaming(self.schema, items, fields_to_skip)
+
+    # validate
+    for in_key, out_key in schema_update_dict.items():
+        if in_key not in self.__dict__ or not isinstance(self.__dict__[in_key], _Column):
+            raise AttributeError(f"There is no '{in_key}' column to rename")
+
+        if out_key in self.__dict__ and isinstance(self.__dict__[out_key], _Column):
+            raise AttributeError(f"Column '{out_key}' already exists")
+
+    # apply
+    for in_key, out_key in schema_update_dict.items():
+        self.__dict__[in_key].rename(out_key, update_parent_object=False)
+        self.__dict__[out_key] = self.__dict__[in_key]
+        del self.__dict__[in_key]
+
+    rename_rules = [key + "=" + value for key, value in items.items()]
+    kwargs: Dict[str, Any] = dict(rename_fields=",".join(rename_rules))
+    if use_regex:
+        kwargs['use_regex'] = True
+    if fields_to_skip:
+        kwargs['fields_to_skip'] = ",".join(fields_to_skip)
+
+    self.sink(otq.RenameFieldsEp(**kwargs))
+
+    return self

onetick/py/core/_source/source_methods/sorts.py

@@ -0,0 +1,183 @@
+from typing import TYPE_CHECKING, Collection, Optional, Union
+
+from onetick.py.core.column import _Column
+from onetick.py.otq import otq
+
+from .misc import inplace_operation
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source
+
+
+@inplace_operation
+def sort(
+    self: 'Source', by: Union[str, Collection[Union[str, '_Column']]], ascending=True, inplace=False
+) -> Optional['Source']:
+    """Sort ticks by columns.
+
+    Parameters
+    ----------
+    by: str, Column or list of them
+        Column(s) to sort by. It is possible to pass a list of column, where is the order is important:
+        from the left to the right.
+    ascending: bool or list
+        Order to sort by. If list of columns is specified, then list of ascending values per column is expected.
+        (the :class:`nan` is the smallest for ``float`` type fields)
+    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`
+
+    See also
+    --------
+    **ORDER_BY** OneTick event processor
+
+    Examples
+    --------
+
+    Single column examples
+
+    >>> data = otp.Ticks({'X':[     94,   5,   34],
+    ...                   'Y':[otp.nan, 3.1, -0.3]})
+    >>> data = data.sort(data['X'])
+    >>> otp.run(data)
+                         Time   X    Y
+    0 2003-12-01 00:00:00.001   5  3.1
+    1 2003-12-01 00:00:00.002  34 -0.3
+    2 2003-12-01 00:00:00.000  94  NaN
+
+    >>> data = otp.Ticks({'X':[     94,   5,   34],
+    ...                   'Y':[otp.nan, 3.1, -0.3]})
+    >>> data = data.sort(data['Y'])
+    >>> otp.run(data)
+                         Time   X    Y
+    0 2003-12-01 00:00:00.000  94  NaN
+    1 2003-12-01 00:00:00.002  34 -0.3
+    2 2003-12-01 00:00:00.001   5  3.1
+
+    Inplace
+
+    >>> data = otp.Ticks({'X':[     94,   5,   34],
+    ...                   'Y':[otp.nan, 3.1, -0.3]})
+    >>> data.sort(data['Y'], inplace=True)  # OTdirective: snippet-name: Arrange.sort.inplace;
+    >>> otp.run(data)
+                         Time   X    Y
+    0 2003-12-01 00:00:00.000  94 NaN
+    1 2003-12-01 00:00:00.002  34 -0.3
+    2 2003-12-01 00:00:00.001  5   3.1
+
+    Multiple columns
+
+    >>> data = otp.Ticks({'X':[  5,   6,   3,   6],
+    ...                   'Y':[1.4, 3.1, 9.1, 5.5]})
+    >>> data = data.sort([data['X'], data['Y']])
+    >>> otp.run(data)
+                         Time  X    Y
+    0 2003-12-01 00:00:00.002  3  9.1
+    1 2003-12-01 00:00:00.000  5  1.4
+    2 2003-12-01 00:00:00.001  6  3.1
+    3 2003-12-01 00:00:00.003  6  5.5
+
+    Ascending/descending control
+
+    >>> data = otp.Ticks({'X':[     94,   5,   34],
+    ...                   'Y':[otp.nan, 3.1, -0.3]})
+    >>> data = data.sort(data['X'], ascending=False)
+    >>> otp.run(data)
+                         Time   X    Y
+    0 2003-12-01 00:00:00.000  94  NaN
+    1 2003-12-01 00:00:00.002  34 -0.3
+    2 2003-12-01 00:00:00.001   5  3.1
+
+    >>> # OTdirective: snippet-name: Arrange.sort.sort;
+    >>> data = otp.Ticks({'X':[  5,   6,   3,   6],
+    ...                   'Y':[1.4, 3.1, 9.1, 5.5]})
+    >>> data = data.sort([data['X'], data['Y']], ascending=[True, False])
+    >>> otp.run(data)
+                         Time  X    Y
+    0 2003-12-01 00:00:00.002  3  9.1
+    1 2003-12-01 00:00:00.000  5  1.4
+    2 2003-12-01 00:00:00.003  6  5.5
+    3 2003-12-01 00:00:00.001  6  3.1
+    """
+    columns = by
+
+    if isinstance(columns, list):
+        objs = columns
+    else:
+        objs = [columns]
+
+    if isinstance(ascending, list):
+        asc_objs = ascending
+    else:
+        asc_objs = [ascending]
+
+    items = []
+
+    # -------------------------------
+    # Columns processing
+    # -------------------------------
+    # convert to strings
+    # TODO: it seems as a common code, need to move to a separate function
+    for obj in objs:
+        if isinstance(obj, _Column):
+            items.append(obj.name)
+        elif isinstance(obj, str):
+            items.append(obj)
+        else:
+            # TODO: cover with tests
+            raise TypeError(f"It is not supported to order by '{obj}' of type '{type(obj)}'")
+
+    # validate
+    for item in items:
+        if item in self.__dict__:
+            if not isinstance(self.__dict__[item], _Column):
+                # TODO: cover with tests
+                raise AttributeError(f"There is no '{item}' column")
+            #  if
+        else:
+            # TODO: covert with tests
+            raise AttributeError(f"There is no '{item}' column")
+
+    # -------------------------------
+    # Asc processing
+    # -------------------------------
+    asc_items = [True] * len(items)
+
+    def asc_convert(v):
+        return "ASC" if v else "DESC"
+
+    for inx in range(len(items)):
+        if inx >= len(asc_objs):
+            asc_obj = asc_items[inx]
+        else:
+            asc_obj = asc_objs[inx]
+
+        if isinstance(asc_obj, bool):
+            asc_items[inx] = asc_convert(asc_obj)
+        elif isinstance(asc_obj, int):
+            asc_items[inx] = asc_convert(asc_obj)
+        else:
+            raise TypeError(f"asc can not be '{asc_obj}' of type '{type(asc_obj)}'")
+
+    # ---------------
+    # combine together
+    order_by = [column_name + " " + asc for column_name, asc in zip(items, asc_items)]
+
+    self.sink(otq.OrderByEp(order_by=",".join(order_by)))
+    return self
+
+
+def sort_values(self: 'Source', *args, **kwargs):
+    """
+    alias of sort
+
+    See Also
+    --------
+    :meth:`Source.sort`
+    """
+    return self.sort(*args, **kwargs)