from hazelcast.serialization.api import IdentifiedDataSerializable
_AGGREGATORS_FACTORY_ID = -29
[docs]class Aggregator(object):
"""Marker base class for all aggregators.
Aggregators allow computing a value of some function (e.g sum or max) over
the stored map entries. The computation is performed in a fully distributed
manner, so no data other than the computed value is transferred to the client,
making the computation fast.
"""
pass
class _AbstractAggregator(Aggregator, IdentifiedDataSerializable):
def __init__(self, attribute_path=None):
self._attribute_path = attribute_path
def write_data(self, object_data_output):
raise NotImplementedError("write_data")
def read_data(self, object_data_input):
pass
def get_factory_id(self):
return _AGGREGATORS_FACTORY_ID
def get_class_id(self):
raise NotImplementedError("get_class_id")
class _CountAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_long(0)
def get_class_id(self):
return 4
class _DistinctValuesAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_int(0)
def get_class_id(self):
return 5
class _DoubleAverageAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_double(0)
object_data_output.write_long(0)
def get_class_id(self):
return 6
class _DoubleSumAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_double(0)
def get_class_id(self):
return 7
class _FixedPointSumAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_long(0)
def get_class_id(self):
return 8
class _FloatingPointSumAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_double(0)
def get_class_id(self):
return 9
class _IntegerAverageAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_long(0)
object_data_output.write_long(0)
def get_class_id(self):
return 10
class _IntegerSumAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_long(0)
def get_class_id(self):
return 11
class _LongAverageAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_long(0)
object_data_output.write_long(0)
def get_class_id(self):
return 12
class _LongSumAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_long(0)
def get_class_id(self):
return 13
class _MaxAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_object(None)
def get_class_id(self):
return 14
class _MinAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_object(None)
def get_class_id(self):
return 15
class _NumberAverageAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_double(0)
object_data_output.write_long(0)
def get_class_id(self):
return 16
class _MaxByAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_object(None)
object_data_output.write_object(None)
def get_class_id(self):
return 17
class _MinByAggregator(_AbstractAggregator):
def write_data(self, object_data_output):
object_data_output.write_string(self._attribute_path)
object_data_output.write_object(None)
object_data_output.write_object(None)
def get_class_id(self):
return 18
[docs]def count(attribute_path=None):
"""Creates an aggregator that counts the input values.
Accepts ``None`` input values and ``None`` extracted values.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[int]: An aggregator that counts the input values.
"""
return _CountAggregator(attribute_path)
[docs]def distinct(attribute_path=None):
"""Creates an aggregator that calculates the distinct set of input values.
Accepts ``None`` input values and ``None`` extracted values.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[set]: An aggregator that calculates the distinct set of
input values.
"""
return _DistinctValuesAggregator(attribute_path)
[docs]def double_avg(attribute_path=None):
"""Creates an aggregator that calculates the average of the input values.
Does NOT accept ``None`` input values or ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must be of type ``double`` (primitive or boxed) in Java or of a type
that can be converted to that. That means, one should be able to use this
aggregator with ``float`` or ``int`` values sent from the Python client
unless they are out of range for ``double`` type in Java.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[float]: An aggregator that calculates the average of
the input values.
"""
return _DoubleAverageAggregator(attribute_path)
[docs]def double_sum(attribute_path=None):
"""Creates an aggregator that calculates the sum of the input values.
Does NOT accept ``None`` input values or ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must be of type ``double`` (primitive or boxed) in Java or of a type
that can be converted to that. That means, one should be able to use this
aggregator with ``float`` or ``int`` values sent from the Python client
unless they are out of range for ``double`` type in Java.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[float]: An aggregator that calculates the sum of the input
values.
"""
return _DoubleSumAggregator(attribute_path)
[docs]def fixed_point_sum(attribute_path=None):
"""Creates an aggregator that calculates the sum of the input values.
Does NOT accept ``None`` input values or ``None`` extracted values.
Accepts generic number input values. That means, one should be able to
use this aggregator with ``float`` or ``int`` value sent from the Python
client unless they are out of range for ``long`` type in Java.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[int]: An aggregator that calculates the sum of the
input values.
"""
return _FixedPointSumAggregator(attribute_path)
[docs]def floating_point_sum(attribute_path=None):
"""Creates an aggregator that calculates the sum of the input values.
Does NOT accept ``None`` input values or ``None`` extracted values.
Accepts generic number input values. That means, one should be able to
use this aggregator with ``float`` or ``int`` value sent from the Python
client unless they are out of range for ``double`` type in Java.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[float]: An aggregator that calculates the sum of the
input values.
"""
return _FloatingPointSumAggregator(attribute_path)
[docs]def int_avg(attribute_path=None):
"""Creates an aggregator that calculates the average of the input values.
Does NOT accept ``None`` input values or ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must be of type ``int`` (primitive or boxed) in Java or of a type
that can be converted to that. That means, one should be able to use this
aggregator with ``int`` values sent from the Python client unless they
are out of range for ``int`` type in Java.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[int]: An aggregator that calculates the average of the
input values.
"""
return _IntegerAverageAggregator(attribute_path)
[docs]def int_sum(attribute_path=None):
"""Creates an aggregator that calculates the sum of the input values.
Does NOT accept ``None`` input values or ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must be of type ``int`` (primitive or boxed) in Java or of a type
that can be converted to that. That means, one should be able to use this
aggregator with ``int`` values sent from the Python client unless they
are out of range for ``int`` type in Java.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[int]: An aggregator that calculates the sum of the
input values.
"""
return _IntegerSumAggregator(attribute_path)
[docs]def long_avg(attribute_path=None):
"""Creates an aggregator that calculates the average of the input values.
Does NOT accept ``None`` input values or ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must be of type ``long`` (primitive or boxed) in Java or of a type
that can be converted to that. That means, one should be able to use this
aggregator with ``int`` values sent from the Python client unless they
are out of range for ``long`` type in Java.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[int]: An aggregator that calculates the average of the
input values.
"""
return _LongAverageAggregator(attribute_path)
[docs]def long_sum(attribute_path=None):
"""Creates an aggregator that calculates the sum of the input values.
Does NOT accept ``None`` input values or ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must be of type ``long`` (primitive or boxed) in Java or of a type
that can be converted to that. That means, one should be able to use this
aggregator with ``int`` values sent from the Python client unless they
are out of range for ``long`` type in Java.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[int]: An aggregator that calculates the sum of the
input values.
"""
return _LongSumAggregator(attribute_path)
[docs]def max_(attribute_path=None):
"""Creates an aggregator that calculates the max of the input values.
Accepts ``None`` input values and ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must implement the ``Comparable`` interface in Java. That means, one
should be able to use this aggregator with most of the primitive values
sent from the Python client, as Java implements this interface for the
equivalents of types like ``int``, ``str``, and ``float``.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[any]: An aggregator that calculates the max of the input
values.
"""
return _MaxAggregator(attribute_path)
[docs]def min_(attribute_path=None):
"""Creates an aggregator that calculates the min of the input values.
Accepts ``None`` input values and ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must implement the ``Comparable`` interface in Java. That means, one
should be able to use this aggregator with most of the primitive values
sent from the Python client, as Java implements this interface for the
equivalents of types like ``int``, ``str``, and ``float``.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[any]: An aggregator that calculates the min of the
input values.
"""
return _MinAggregator(attribute_path)
[docs]def number_avg(attribute_path=None):
"""Creates an aggregator that calculates the average of the input values.
Does NOT accept ``None`` input values or ``None`` extracted values.
Accepts generic number input values. That means, one should be able to
use this aggregator with ``float`` or ``int`` value sent from the Python
client unless they are out of range for ``double`` type in Java.
Args:
attribute_path (str): Extracts values from this path, if given.
Returns:
Aggregator[float]: An aggregator that calculates the average of
the input values.
"""
return _NumberAverageAggregator(attribute_path)
[docs]def max_by(attribute_path=None):
"""Creates an aggregator that calculates the max of the input values
extracted from the given ``attribute_path`` and returns the input
item containing the maximum value. If multiple items contain the
maximum value, any of them is returned.
Accepts ``None`` input values and ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must implement the ``Comparable`` interface in Java. That means, one
should be able to use this aggregator with most of the primitive values
sent from the Python client, as Java implements this interface for the
equivalents of types like ``int``, ``str``, and ``float``.
Args:
attribute_path (str): Path to extract values from.
Returns:
Aggregator[hazelcast.core.MapEntry]: An aggregator that calculates
the input value containing the maximum value extracted from the path.
"""
return _MaxByAggregator(attribute_path)
[docs]def min_by(attribute_path):
"""Creates an aggregator that calculates the min of the input values
extracted from the given ``attribute_path`` and returns the input
item containing the minimum value. If multiple items contain the
minimum value, any of them is returned.
Accepts ``None`` input values and ``None`` extracted values.
Since the server-side implementation is in Java, values stored in the
Map must implement the ``Comparable`` interface in Java. That means, one
should be able to use this aggregator with most of the primitive values
sent from the Python client, as Java implements this interface for the
equivalents of types like ``int``, ``str``, and ``float``.
Args:
attribute_path (str): Path to extract values from.
Returns:
Aggregator[hazelcast.core.MapEntry]: An aggregator that calculates
the input value containing the minimum value extracted from the path.
"""
return _MinByAggregator(attribute_path)