onetick-py 1.162.2__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)

onetick/py/aggregations/order_book.py

@@ -0,0 +1,427 @@
+from typing import TYPE_CHECKING, List, Optional, Union
+from onetick.py.backports import Literal
+
+from abc import ABC
+
+import onetick.py as otp
+from onetick.py.otq import otq
+from onetick.py import types as ott
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source   # hack for annotations
+from onetick.py.core.column import _Column
+from onetick.py.compatibility import is_supported_otq_ob_summary
+from ._base import _Aggregation, get_seconds_from_time_offset
+from ._docs import (_running_doc,
+                    _bucket_interval_doc,
+                    _bucket_time_doc,
+                    _bucket_units_ob_doc,
+                    _bucket_end_condition_doc,
+                    _end_condition_per_group_doc,
+                    _group_by_doc,
+                    _groups_to_display_doc,
+                    _side_doc,
+                    _max_levels_doc,
+                    _min_levels_doc,
+                    _max_depth_shares_doc,
+                    _max_depth_for_price_doc,
+                    _book_uncross_method_doc,
+                    _dq_events_that_clear_book_doc,
+                    _best_ask_price_field_doc,
+                    _best_bid_price_field_doc,
+                    _bucket_interval_ob_num_levels_doc,
+                    _identify_source_doc,
+                    _show_full_detail_doc,
+                    _show_only_changes_doc,
+                    _book_delimiters_doc,
+                    _max_initialization_days_doc,
+                    _state_key_max_inactivity_sec_doc,
+                    _size_max_fractional_digits_doc)
+
+
+OB_SNAPSHOT_DOC_PARAMS = [
+    _running_doc,
+    _bucket_interval_doc, _bucket_time_doc, _bucket_units_ob_doc,
+    _bucket_end_condition_doc, _end_condition_per_group_doc, _group_by_doc, _groups_to_display_doc,
+    _side_doc, _max_levels_doc, _max_depth_shares_doc, _max_depth_for_price_doc,
+    _book_uncross_method_doc, _dq_events_that_clear_book_doc, _identify_source_doc,
+    _show_full_detail_doc, _show_only_changes_doc, _book_delimiters_doc,
+    _max_initialization_days_doc, _state_key_max_inactivity_sec_doc,
+    _size_max_fractional_digits_doc
+]
+OB_SNAPSHOT_WIDE_DOC_PARAMS = [
+    _running_doc,
+    _bucket_interval_doc, _bucket_time_doc, _bucket_units_ob_doc, _bucket_end_condition_doc,
+    _end_condition_per_group_doc, _group_by_doc, _groups_to_display_doc,
+    _max_levels_doc, _max_depth_shares_doc, _max_depth_for_price_doc,
+    _book_uncross_method_doc, _dq_events_that_clear_book_doc,
+    _book_delimiters_doc,
+    _max_initialization_days_doc, _state_key_max_inactivity_sec_doc,
+    _size_max_fractional_digits_doc
+]
+OB_SNAPSHOT_FLAT_DOC_PARAMS = [
+    _running_doc,
+    _bucket_interval_doc, _bucket_time_doc, _bucket_units_ob_doc, _bucket_end_condition_doc,
+    _end_condition_per_group_doc, _group_by_doc, _groups_to_display_doc,
+    _max_levels_doc,
+    _book_uncross_method_doc, _dq_events_that_clear_book_doc,
+    _show_full_detail_doc,
+    _max_initialization_days_doc, _state_key_max_inactivity_sec_doc,
+    _size_max_fractional_digits_doc
+]
+OB_SUMMARY_DOC_PARAMS = [
+    _running_doc,
+    _bucket_interval_doc, _bucket_time_doc, _bucket_units_ob_doc,
+    _bucket_end_condition_doc, _end_condition_per_group_doc, _group_by_doc, _groups_to_display_doc,
+    _side_doc, _max_levels_doc, _min_levels_doc, _max_depth_shares_doc, _max_depth_for_price_doc,
+    _book_uncross_method_doc, _dq_events_that_clear_book_doc, _max_initialization_days_doc,
+    _state_key_max_inactivity_sec_doc, _size_max_fractional_digits_doc
+]
+
+OB_SIZE_DOC_PARAMS = [
+    _running_doc,
+    _bucket_interval_doc, _bucket_time_doc, _bucket_units_ob_doc,
+    _bucket_end_condition_doc, _end_condition_per_group_doc, _group_by_doc, _groups_to_display_doc,
+    _side_doc, _max_levels_doc, _max_depth_for_price_doc,
+    _book_uncross_method_doc, _dq_events_that_clear_book_doc, _max_initialization_days_doc,
+    _best_ask_price_field_doc, _best_bid_price_field_doc,
+]
+
+OB_VWAP_DOC_PARAMS = [
+    _running_doc,
+    _bucket_interval_doc, _bucket_time_doc, _bucket_units_ob_doc,
+    _bucket_end_condition_doc, _end_condition_per_group_doc, _group_by_doc, _groups_to_display_doc,
+    _side_doc, _max_levels_doc, _max_depth_shares_doc,
+    _book_uncross_method_doc, _dq_events_that_clear_book_doc, _max_initialization_days_doc,
+]
+
+OB_NUM_LEVELS_DOC_PARAMS = [
+    _running_doc,
+    _bucket_interval_ob_num_levels_doc, _side_doc,
+    _book_uncross_method_doc, _dq_events_that_clear_book_doc, _max_initialization_days_doc,
+]
+
+
+class _OrderBookAggregation(_Aggregation, ABC):
+    FIELDS_TO_SKIP = ['column_name', 'all_fields', 'boundary_tick_bucket', 'output_field_name']
+    FIELDS_MAPPING = dict(_Aggregation.FIELDS_MAPPING, **{
+        'side': 'SIDE',
+        'max_levels': 'MAX_LEVELS',
+        'max_depth_shares': 'MAX_DEPTH_SHARES',
+        'max_depth_for_price': 'MAX_DEPTH_FOR_PRICE',
+        'max_initialization_days': 'MAX_INITIALIZATION_DAYS',
+        'book_uncross_method': 'BOOK_UNCROSS_METHOD',
+        'dq_events_that_clear_book': 'DQ_EVENTS_THAT_CLEAR_BOOK',
+    })
+    FIELDS_DEFAULT = dict(_Aggregation.FIELDS_DEFAULT, **{
+        'side': None,
+        'max_levels': None,
+        'max_depth_shares': None,
+        'max_depth_for_price': None,
+        'max_initialization_days': 1,
+        'book_uncross_method': None,
+        'dq_events_that_clear_book': None,
+    })
+    _validations_to_skip = ['running_all_fields']
+
+    def __init__(self,
+                 *args,
+                 side: Optional[Literal['ASK', 'BID']] = None,
+                 max_levels: Optional[int] = None,
+                 max_depth_shares: Optional[int] = None,
+                 max_depth_for_price: Optional[float] = None,
+                 max_initialization_days: int = 1,
+                 book_uncross_method: Optional[Literal['REMOVE_OLDER_CROSSED_LEVELS']] = None,
+                 dq_events_that_clear_book: Optional[List[str]] = None,
+                 **kwargs):
+        self.side = side
+        self.max_levels = max_levels
+        self.max_depth_shares = max_depth_shares
+        self.max_depth_for_price = max_depth_for_price
+        self.max_initialization_days = max_initialization_days
+        self.book_uncross_method = book_uncross_method
+        self.dq_events_that_clear_book = ','.join(dq_events_that_clear_book) if dq_events_that_clear_book else None
+        super().__init__(_Column('TIMESTAMP'), *args, **kwargs)
+
+    def _param_validation(self):
+        super()._param_validation()
+        book_uncross_methods = (None, 'REMOVE_OLDER_CROSSED_LEVELS')
+        if self.book_uncross_method not in book_uncross_methods:
+            raise ValueError(
+                f"Wrong value for parameter 'book_uncross_method': '{self.book_uncross_method}'. "
+                f"Possible values: {book_uncross_methods}."
+            )
+        valid_units = ("seconds", "days", "months", "flexible")
+        if self.bucket_units not in valid_units:
+            raise ValueError("'bucket_units' can be one of the following: "
+                             f"'{', '.join(valid_units)}'; however, '{self.bucket_units}' was passed")
+
+    def validate_input_columns(self, src: 'Source'):
+        super().validate_input_columns(src)
+        if any([
+            not {'BUY_SELL_FLAG', 'PRICE', 'SIZE'}.issubset(src.schema),
+            'UPDATE_TIME' not in src.schema and 'DELETED_TIME' not in src.schema
+        ]):
+            raise TypeError(f"Aggregation `{self.NAME}` need these columns: "
+                            f"BUY_SELL_FLAG, PRICE, SIZE and (UPDATE_TIME or DELETED_TIME)")
+
+
+class ObSnapshot(_OrderBookAggregation):
+    NAME = 'OB_SNAPSHOT'
+    EP = otq.ObSnapshot
+
+    FIELDS_MAPPING = dict(_OrderBookAggregation.FIELDS_MAPPING, **{
+        'identify_source': 'IDENTIFY_SOURCE',
+        'show_full_detail': 'SHOW_FULL_DETAIL',
+        'show_only_changes': 'SHOW_ONLY_CHANGES',
+        'book_delimiters': 'BOOK_DELIMITERS',
+        'state_key_max_inactivity_sec': 'STATE_KEY_MAX_INACTIVITY_SEC',
+        'size_max_fractional_digits': 'SIZE_MAX_FRACTIONAL_DIGITS',
+    })
+    FIELDS_DEFAULT = dict(_OrderBookAggregation.FIELDS_DEFAULT, **{
+        'identify_source': False,
+        'show_full_detail': False,
+        'show_only_changes': False,
+        'book_delimiters': None,
+        'state_key_max_inactivity_sec': None,
+        'size_max_fractional_digits': 0,
+    })
+
+    def __init__(self,
+                 *args,
+                 identify_source: bool = False,
+                 show_full_detail: bool = False,
+                 show_only_changes: bool = False,
+                 book_delimiters: Optional[Literal['D']] = None,
+                 state_key_max_inactivity_sec: Optional[int] = None,
+                 size_max_fractional_digits: int = 0,
+                 **kwargs):
+        self.identify_source = identify_source
+        self.show_full_detail = show_full_detail
+        self.show_only_changes = show_only_changes
+        self.book_delimiters = book_delimiters
+        self.state_key_max_inactivity_sec = state_key_max_inactivity_sec
+        self.size_max_fractional_digits = size_max_fractional_digits
+        # we don't want to set hard limit on the output of order book aggregations
+        if self.show_full_detail:
+            kwargs['all_fields'] = True
+        super().__init__(*args, **kwargs)
+
+    def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
+        schema = {
+            'PRICE': float,
+            'SIZE': int,
+            'LEVEL': int,
+            'UPDATE_TIME': otp.nsectime,
+            'BUY_SELL_FLAG': int,
+        }
+        if self.book_delimiters:
+            schema['DELIMITER'] = str
+        return schema
+
+
+class ObSnapshotWide(ObSnapshot):
+    NAME = 'OB_SNAPSHOT_WIDE'
+    EP = otq.ObSnapshotWide
+
+    FIELDS_TO_SKIP = [
+        *ObSnapshot.FIELDS_TO_SKIP, 'side', 'identify_source', 'show_full_detail', 'show_only_changes'
+    ]
+
+    def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
+        schema = {
+            'BID_PRICE': float,
+            'BID_SIZE': int,
+            'BID_UPDATE_TIME': otp.nsectime,
+            'ASK_PRICE': float,
+            'ASK_SIZE': int,
+            'ASK_UPDATE_TIME': otp.nsectime,
+            'LEVEL': int,
+        }
+        if self.book_delimiters:
+            schema['DELIMITER'] = str
+        return schema
+
+
+class ObSnapshotFlat(ObSnapshot):
+    NAME = 'OB_SNAPSHOT_FLAT'
+    EP = otq.ObSnapshotFlat
+
+    FIELDS_TO_SKIP = [
+        *ObSnapshot.FIELDS_TO_SKIP,
+        'side', 'identify_source', 'show_only_changes',
+        'book_delimiters', 'max_depth_shares', 'max_depth_for_price',
+    ]
+
+    def validate_input_columns(self, src: 'Source'):
+        super().validate_input_columns(src)
+        if self.max_levels is None or self.max_levels < 1 or self.max_levels > 100_000:
+            raise ValueError(f"Parameter 'max_levels' must be set in aggregation `{self.NAME}`"
+                             f" and must be between 1 and 100000.")
+
+    def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
+        schema = {}
+        assert self.max_levels is not None
+        for level in range(1, self.max_levels + 1):
+            schema.update({
+                f'BID_PRICE{level}': float,
+                f'BID_SIZE{level}': int,
+                f'BID_UPDATE_TIME{level}': otp.nsectime,
+                f'ASK_PRICE{level}': float,
+                f'ASK_SIZE{level}': int,
+                f'ASK_UPDATE_TIME{level}': otp.nsectime,
+            })
+        return schema
+
+
+class ObSummary(_OrderBookAggregation):
+    NAME = 'OB_SUMMARY'
+
+    # Will be set later, to prevent error while importing this module with outdated onetick
+    EP = None
+
+    FIELDS_MAPPING = dict(_OrderBookAggregation.FIELDS_MAPPING, **{
+        'min_levels': 'MIN_LEVELS',
+        'state_key_max_inactivity_sec': 'STATE_KEY_MAX_INACTIVITY_SEC',
+        'size_max_fractional_digits': 'SIZE_MAX_FRACTIONAL_DIGITS',
+    })
+    FIELDS_DEFAULT = dict(_OrderBookAggregation.FIELDS_DEFAULT, **{
+        'min_levels': None,
+        'state_key_max_inactivity_sec': None,
+        'size_max_fractional_digits': 0,
+    })
+
+    def __init__(self,
+                 *args,
+                 min_levels: Optional[int] = None,
+                 state_key_max_inactivity_sec: Optional[int] = None,
+                 size_max_fractional_digits: int = 0,
+                 **kwargs):
+        if is_supported_otq_ob_summary():
+            self.EP = otq.ObSummary
+        else:
+            raise RuntimeError("Used onetick installation not support onetick.query.ObSummary")
+
+        self.min_levels = min_levels
+        self.state_key_max_inactivity_sec = state_key_max_inactivity_sec
+        self.size_max_fractional_digits = size_max_fractional_digits
+        super().__init__(*args, **kwargs)
+
+    def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
+        schema = {
+            'BID_SIZE': int,
+            'BID_VWAP': float,
+            'BEST_BID_PRICE': float,
+            'WORST_BID_PRICE': float,
+            'NUM_BID_LEVELS': int,
+            'ASK_SIZE': int,
+            'ASK_VWAP': float,
+            'BEST_ASK_PRICE': float,
+            'WORST_ASK_PRICE': float,
+            'NUM_ASK_LEVELS': int,
+        }
+        return schema
+
+
+class ObSize(_OrderBookAggregation):
+    NAME = 'OB_SIZE'
+    EP = otq.ObSize
+
+    FIELDS_MAPPING = dict(_OrderBookAggregation.FIELDS_MAPPING, **{
+        'min_levels': 'MIN_LEVELS',
+        'best_ask_price_field': 'BEST_ASK_PRICE_FIELD',
+        'best_bid_price_field': 'BEST_BID_PRICE_FIELD',
+    })
+    FIELDS_DEFAULT = dict(_OrderBookAggregation.FIELDS_DEFAULT, **{
+        'min_levels': None,
+        'best_ask_price_field': '',
+        'best_bid_price_field': '',
+    })
+
+    def __init__(
+        self, *args, min_levels: Optional[int] = None,
+        best_ask_price_field: Optional[Union[str, _Column]] = None,
+        best_bid_price_field: Optional[Union[str, _Column]] = None,
+        **kwargs,
+    ):
+        if min_levels and not kwargs.get('max_depth_for_price'):
+            raise ValueError('`min_levels` parameter must not be set when `max_depth_for_price` not set')
+
+        self.min_levels = min_levels
+
+        if isinstance(best_ask_price_field, _Column):
+            best_ask_price_field = str(best_ask_price_field)
+        elif best_ask_price_field is None:
+            best_ask_price_field = ''
+
+        if isinstance(best_bid_price_field, _Column):
+            best_bid_price_field = str(best_bid_price_field)
+        elif best_bid_price_field is None:
+            best_bid_price_field = ''
+
+        self.best_ask_price_field = best_ask_price_field
+        self.best_bid_price_field = best_bid_price_field
+        super().__init__(*args, **kwargs)
+
+    def validate_input_columns(self, src: 'Source'):
+        super().validate_input_columns(src)
+
+        if self.best_ask_price_field and self.best_ask_price_field not in src.schema:
+            raise ValueError(
+                f'Column \'{self.best_ask_price_field}\' from `best_ask_price_field` parameter not in the schema.'
+            )
+
+        if self.best_bid_price_field and self.best_bid_price_field not in src.schema:
+            raise ValueError(
+                f'Column \'{self.best_bid_price_field}\' from `best_bid_price_field` parameter not in the schema.'
+            )
+
+    def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
+        if self.side:
+            return {'VALUE': float}
+
+        return {
+            'ASK_VALUE': float,
+            'BID_VALUE': float,
+        }
+
+
+class ObVwap(_OrderBookAggregation):
+    NAME = 'OB_VWAP'
+    EP = otq.ObVwap
+
+    def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
+        if self.side:
+            return {'VALUE': float}
+
+        return {
+            'ASK_VALUE': float,
+            'BID_VALUE': float,
+        }
+
+
+class ObNumLevels(_OrderBookAggregation):
+    NAME = 'OB_NUM_LEVELS'
+    EP = otq.ObNumLevels
+
+    def __init__(self, *args, bucket_interval: Union[int, ott.OTPBaseTimeOffset] = 0, **kwargs):
+        if not isinstance(bucket_interval, (int, ott.OTPBaseTimeOffset)):
+            raise ValueError('Unsupported value type for `bucket_interval` parameter')
+
+        if isinstance(bucket_interval, ott.OTPBaseTimeOffset):
+            _, datepart = bucket_interval.get_offset()
+            if datepart not in {'second', 'minute', 'hour', 'day'}:
+                raise ValueError(f"Unsupported DatePart passed to bucket_interval: {datepart}")
+
+            bucket_interval = get_seconds_from_time_offset(bucket_interval)
+
+        super().__init__(*args, bucket_interval=bucket_interval, **kwargs)
+
+    def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
+        if self.side:
+            return {'VALUE': float}
+
+        return {
+            'ASK_VALUE': float,
+            'BID_VALUE': float,
+        }