# DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/python/mod.rs
# Based on "crates/store/re_sdk_types/definitions/rerun/components/aggregation_policy.fbs".

# You can extend this class by creating a "AggregationPolicyExt" class in "aggregation_policy_ext.py".

from __future__ import annotations

from collections.abc import Sequence
from typing import Literal

import pyarrow as pa

from .._baseclasses import (
    BaseBatch,
    ComponentBatchMixin,
)

__all__ = ["AggregationPolicy", "AggregationPolicyArrayLike", "AggregationPolicyBatch", "AggregationPolicyLike"]


from enum import Enum


class AggregationPolicy(Enum):
    """
    **Component**: Policy for aggregation of multiple scalar plot values.

    This is used for lines in plots when the X axis distance of individual points goes below a single pixel,
    i.e. a single pixel covers more than one tick worth of data. It can greatly improve performance
    (and readability) in such situations as it prevents overdraw.
    """

    Off = 1
    """No aggregation."""

    Average = 2
    """Average all points in the range together."""

    Max = 3
    """Keep only the maximum values in the range."""

    Min = 4
    """Keep only the minimum values in the range."""

    MinMax = 5
    """
    Keep both the minimum and maximum values in the range.

    This will yield two aggregated points instead of one, effectively creating a vertical line.
    """

    MinMaxAverage = 6
    """Find both the minimum and maximum values in the range, then use the average of those."""

    @classmethod
    def auto(cls, val: str | int | AggregationPolicy) -> AggregationPolicy:
        """Best-effort converter, including a case-insensitive string matcher."""
        if isinstance(val, AggregationPolicy):
            return val
        if isinstance(val, int):
            return cls(val)
        try:
            return cls[val]
        except KeyError:
            val_lower = val.lower()
            for variant in cls:
                if variant.name.lower() == val_lower:
                    return variant
        raise ValueError(f"Cannot convert {val} to {cls.__name__}")

    def __str__(self) -> str:
        """Returns the variant name."""
        return self.name


AggregationPolicyLike = (
    AggregationPolicy
    | Literal[
        "Average",
        "Max",
        "Min",
        "MinMax",
        "MinMaxAverage",
        "Off",
        "average",
        "max",
        "min",
        "minmax",
        "minmaxaverage",
        "off",
    ]
    | int
)
"""A type alias for any AggregationPolicy-like object."""

AggregationPolicyArrayLike = (
    AggregationPolicy
    | Literal[
        "Average",
        "Max",
        "Min",
        "MinMax",
        "MinMaxAverage",
        "Off",
        "average",
        "max",
        "min",
        "minmax",
        "minmaxaverage",
        "off",
    ]
    | int
    | Sequence[AggregationPolicyLike]
)
"""A type alias for any AggregationPolicy-like array object."""


class AggregationPolicyBatch(BaseBatch[AggregationPolicyArrayLike], ComponentBatchMixin):
    _ARROW_DATATYPE = pa.uint8()
    _COMPONENT_TYPE: str = "rerun.components.AggregationPolicy"

    @staticmethod
    def _native_to_pa_array(data: AggregationPolicyArrayLike, data_type: pa.DataType) -> pa.Array:
        if isinstance(data, (AggregationPolicy, int, str)):
            data = [data]

        pa_data = [AggregationPolicy.auto(v).value if v is not None else None for v in data]  # type: ignore[redundant-expr]  # ty: ignore[not-iterable]

        return pa.array(pa_data, type=data_type)