onetick-py 1.177.0__py3-none-any.whl

onetick/py/aggregations/generic.py

@@ -0,0 +1,104 @@
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source   # hack for annotations
+
+import onetick.py as otp
+from onetick.py.otq import otq
+from onetick.py.core.column import _Column
+from ._base import _Aggregation, _MultiColumnAggregation
+
+
+class Generic(_Aggregation, _MultiColumnAggregation):
+    NAME = 'GENERIC_AGGREGATION'
+    EP = otq.GenericAggregation
+
+    FIELDS_TO_SKIP = ['column_name', 'all_fields', 'output_field_name']
+    FIELDS_MAPPING = dict(_Aggregation.FIELDS_MAPPING, **{
+        'query_name': 'QUERY_NAME',
+        'bucket_delimiter': 'BUCKET_DELIMITERS',
+    })
+    FIELDS_DEFAULT = dict(_Aggregation.FIELDS_DEFAULT, **{
+        'bucket_delimiter': None,
+    })
+    _validations_to_skip = ['running_all_fields']
+
+    def __init__(self,
+                 query_fun,
+                 bucket_delimiter: bool = False,
+                 **kwargs):
+        self._query: Optional['Source'] = None
+        self._query_fun = query_fun
+        self._query_params: Optional[dict] = None
+        self.bucket_delimiter = 'D' if bucket_delimiter else None
+
+        # init variables which will be set later
+        self.query_name: Optional[str] = None
+        self._query_schema: Optional[dict] = None
+
+        if 'all_fields' in kwargs:
+            raise ValueError("Parameter 'all_fields' for generic aggregation is meaningless. "
+                             "Aggregated source will have all fields returned by 'query_fun'.")
+        # we don't want to set hard limit on the output of order book aggregations
+        kwargs['all_fields'] = True
+        super().__init__(column=_Column('TIMESTAMP'), **kwargs)
+
+    def _set_query_params(self, **kwargs):
+        self._query_params = kwargs
+
+    def apply(self, src: 'Source', name: Optional[str] = None, **kwargs) -> 'Source':
+        """Applies generic aggregation to Source and sets proper schema
+
+        Parameters
+        ----------
+        src: Source
+            Source to apply aggregation
+        name: str, optional
+            Name of output column. If not specified, will be used self.column_name
+        kwargs: dict
+            Parameters to be passed to `query_fun()` when creating aggregation query
+        """
+        self._set_query_params(**kwargs)
+        return super().apply(src, name=name)
+
+    def _make_query_object(self, schema):
+        query_params = self._query_params if self._query_params else {}
+        query = otp.DataSource(symbols='LOCAL::', tick_type='ANY', schema_policy='manual', schema=schema)
+        query = self._query_fun(query, **query_params)
+        return query
+
+    def _detect_query_fun_schema(self, res):
+        # this will be translated to passthrough with symbol and tick type set
+        if self._query is None:
+            self._query = self._make_query_object(res.schema)
+
+        return self._query.schema.copy()
+
+    def _modify_source(self, res: 'Source', **kwargs):
+        query_schema = self._detect_query_fun_schema(res)
+
+        # schema will be used when validating output
+        if self._query_schema is None:
+            self._query_schema = query_schema
+
+        if self._query is None:
+            raise RuntimeError('Attempted to use `self._query` before initialization')
+
+        # query_name will be used to create ep
+        query_name = self._query._store_in_tmp_otq(
+            res._tmp_otq, operation_suffix='generic_aggregation', add_passthrough=False,
+        )
+        self.query_name = f'THIS::{query_name}'
+
+    def _get_common_schema(self, src, name):
+        super()._get_common_schema(src, name)
+        return {
+            column: src.schema[column]
+            for column in map(str, self.group_by)
+        }
+
+    def _get_output_schema(self, src, name=None):
+        schema = self._query_schema.copy()
+        if self.bucket_delimiter:
+            schema['DELIMITER'] = str
+        return schema

onetick/py/aggregations/high_low.py

@@ -0,0 +1,80 @@
+from typing import Union, TYPE_CHECKING
+from copy import deepcopy
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source   # hack for annotations
+
+from onetick.py.core.column import _Column
+from onetick.py import types as ott
+from onetick.py.otq import otq
+
+from ._base import (
+    _AggregationTSType, _AggregationTSSelection, _KeepTs, _FloatAggregation, _ExpectLargeInts, _AllColumnsAggregation,
+)
+
+
+class Max(_AggregationTSType, _ExpectLargeInts):
+
+    NAME = "HIGH"
+    EP = otq.High
+    require_type = (int, float, ott.nsectime, ott._inf)
+
+    FIELDS_MAPPING = deepcopy(_AggregationTSType.FIELDS_MAPPING)
+    FIELDS_MAPPING.update(_ExpectLargeInts.FIELDS_MAPPING)
+    FIELDS_DEFAULT = deepcopy(_AggregationTSType.FIELDS_DEFAULT)
+    FIELDS_DEFAULT.update(_ExpectLargeInts.FIELDS_DEFAULT)
+
+
+class Min(Max):
+    NAME = "LOW"
+    EP = otq.Low
+
+
+class HighTick(_AggregationTSType, _AggregationTSSelection, _KeepTs, _FloatAggregation, _AllColumnsAggregation):
+    EP = otq.HighTick
+    NAME = 'HIGH_TICK'
+    DEFAULT_OUTPUT_NAME = 'HIGH_TICK'
+
+    FIELDS_MAPPING = deepcopy(_AggregationTSType.FIELDS_MAPPING)
+    FIELDS_MAPPING.update(_AggregationTSSelection.FIELDS_MAPPING)
+    FIELDS_MAPPING['n'] = 'NUM_TICKS'
+    FIELDS_DEFAULT = deepcopy(_AggregationTSType.FIELDS_DEFAULT)
+    FIELDS_DEFAULT.update(_AggregationTSSelection.FIELDS_DEFAULT)
+    FIELDS_DEFAULT['n'] = 1
+
+    FIELDS_TO_SKIP = ['output_field_name', 'all_fields']
+
+    def __init__(self, column: Union[str, _Column], n: int = 1, *args, **kwargs):
+        """
+        Select `n` ticks with the highest values in the `column` field
+        """
+        super().__init__(column, *args, **kwargs)
+        self.n = n
+
+    @staticmethod
+    def validate_output_name(*args, **kwargs):
+        # HighTick and LowTick aggregations don't have output fields
+        pass
+
+
+class LowTick(HighTick):
+    EP = otq.LowTick
+    NAME = 'LOW_TICK'
+    DEFAULT_OUTPUT_NAME = 'LOW_TICK'
+
+
+class HighTime(_AggregationTSType, _AggregationTSSelection, _FloatAggregation):
+    NAME = "HIGH_TIME"
+    EP = otq.HighTime
+
+    FIELDS_MAPPING = deepcopy(_AggregationTSType.FIELDS_MAPPING)
+    FIELDS_MAPPING.update(_AggregationTSSelection.FIELDS_MAPPING)
+    FIELDS_DEFAULT = deepcopy(_AggregationTSType.FIELDS_DEFAULT)
+    FIELDS_DEFAULT.update(_AggregationTSSelection.FIELDS_DEFAULT)
+    output_field_type = ott.nsectime
+
+
+class LowTime(HighTime):
+    """Returns timestamp of tick with lowest value of input field"""
+    NAME = "LOW_TIME"
+    EP = otq.LowTime

onetick/py/aggregations/num_distinct.py

@@ -0,0 +1,83 @@
+from typing import TYPE_CHECKING
+from copy import deepcopy
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source   # hack for annotations
+
+from onetick.py.otq import otq
+
+from onetick.py.core.column import _Column
+from onetick.py import types as ott
+
+from ._base import _Aggregation
+from ._docs import (_running_doc,
+                    _all_fields_doc,
+                    _bucket_interval_doc,
+                    _bucket_time_doc,
+                    _bucket_units_doc,
+                    _bucket_end_condition_doc,
+                    _boundary_tick_bucket_doc,
+                    _group_by_doc,
+                    _groups_to_display_doc)
+from onetick.py.docs.utils import docstring
+
+
+# OneTick build >= 20220913120000
+if hasattr(otq, 'NumDistinct'):
+
+    class NumDistinct(_Aggregation):
+        NAME = 'NUM_DISTINCT'
+        EP = otq.NumDistinct
+
+        FIELDS_MAPPING = deepcopy(_Aggregation.FIELDS_MAPPING)
+        FIELDS_MAPPING['keys'] = 'KEYS'
+
+        FIELDS_TO_SKIP = ['column_name', 'end_condition_per_group']
+
+        output_field_type = int
+
+        def __init__(self, keys, *args, **kwargs):
+            super().__init__(column=_Column('TIMESTAMP'), *args, **kwargs)
+            if isinstance(keys, str):
+                keys = [keys]
+            self._keys = keys
+
+        @property
+        def keys(self):
+            return ott.value2str(','.join(self._keys))
+
+        def apply(self, src, name='VALUE'):
+            return super().apply(src, name)
+
+        def validate_input_columns(self, src: 'Source'):
+            for column in self._keys:
+                if column not in src.schema:
+                    raise TypeError(f"Aggregation {self.__class__.__name__} uses"
+                                    f" column '{column}' as input, which doesn't exist")
+
+    @docstring(parameters=[_running_doc, _all_fields_doc,
+                           _bucket_interval_doc, _bucket_units_doc, _bucket_time_doc,
+                           _bucket_end_condition_doc, _boundary_tick_bucket_doc, _group_by_doc, _groups_to_display_doc])
+    def num_distinct(*args, **kwargs):
+        """
+        Outputs number of distinct values for a specified set of key fields.
+
+        Parameters
+        ----------
+        keys: str or list of str or list of :py:class:`~onetick.py.Column`
+            Specifies a list of tick attributes for which unique values are found.
+            The ticks in the input time series must contain those attributes.
+
+        Examples
+        --------
+        >>> data = otp.Ticks(dict(X=[1, 3, 2, 1, 3]))
+        >>> data = data.agg({'X': otp.agg.num_distinct('X')})
+        >>> otp.run(data)
+                Time  X
+        0 2003-12-04  3
+
+        See also
+        --------
+        **NUM_DISTINCT** OneTick event processor
+        """
+        return NumDistinct(*args, **kwargs)