pandas-dev/pandas · error · TypeError

(...) must be called with a collection of some kind, was…

Error message

{cls.__name__}(...) must be called with a collection of some kind, {data} was passed

What it means

Raised by `IntervalArray.__new__` (and `_simple_new` paths) when the `data` argument is a scalar. IntervalArray requires a collection (array-like of intervals, or arrays for from_arrays) because it represents a sequence; a single Interval must be wrapped in a list. The check uses `is_scalar(data)` before attempting platform conversion.

Solutions

Wrap the scalar in a list: `pd.arrays.IntervalArray([pd.Interval(0, 1)])`.
If you have left/right bounds, use `IntervalArray.from_arrays(left, right)` instead of passing intervals.
Build the collection upstream and only call IntervalArray once you have >=1 element list.

Example fix

# before
arr = pd.arrays.IntervalArray(pd.Interval(0, 1))

# after
arr = pd.arrays.IntervalArray([pd.Interval(0, 1)])
# or
arr = pd.arrays.IntervalArray.from_arrays([0], [1])

Defensive patterns

Strategy: type-guard

Validate before calling

import pandas as pd
from pandas.api.types import is_scalar

def to_interval_array(data):
    if is_scalar(data):
        data = [data]
    return pd.arrays.IntervalArray(data)

Type guard

from collections.abc import Iterable, Sized
from pandas.api.types import is_scalar

def is_interval_collection(data) -> bool:
    return not is_scalar(data) and isinstance(data, (Iterable, Sized))

Try / catch

try:
    arr = pd.arrays.IntervalArray(data)
except TypeError as e:
    if 'must be called with a collection' in str(e):
        arr = pd.arrays.IntervalArray([data])
    else:
        raise

Prevention

Always wrap a single Interval in a list before passing to IntervalArray.
Use from_arrays(left, right) when you have bounds rather than Interval objects.
Type-check upstream containers in pipeline code.

When it happens

Trigger: `pd.arrays.IntervalArray(pd.Interval(0, 1))` (passing one Interval object); `pd.IntervalIndex(5)`; passing a bare scalar like an int or Timestamp where a list is expected.

Common situations: Programmatically building an interval array in a loop where the variable happens to be a single Interval rather than a list; refactoring from scalar handling to vectorised code; user confusion between Interval (scalar type) and IntervalArray/Index.

Related errors

AI-assisted analysis of pandas-dev/pandas@3b7651241d (2026-08-11). Data as JSON: /api/errors/3526585857b74fa1. Report an issue: GitHub.

Appendix: source

Thrown at pandas/core/arrays/interval.py:231

        dtype: Dtype | None = None,
        copy: bool = False,
        verify_integrity: bool = True,
    ) -> Self:
        data = extract_array(data, extract_numpy=True)

        if isinstance(data, cls):
            left: IntervalSide = data._left
            right: IntervalSide = data._right
            closed = closed or data.closed
            dtype = IntervalDtype(left.dtype, closed=closed)
        else:
            # don't allow scalars
            if is_scalar(data):
                msg = (
                    f"{cls.__name__}(...) must be called with a collection "
                    f"of some kind, {data} was passed"
                )
                raise TypeError(msg)

            # might need to convert empty or purely na data
            data = _maybe_convert_platform_interval(data)
            left, right, infer_closed = intervals_to_interval_bounds(
                data, validate_closed=closed is None
            )
            if left.dtype == object:
                left = lib.maybe_convert_objects(left)
                right = lib.maybe_convert_objects(right)
            closed = closed or infer_closed

            left, right, dtype = cls._ensure_simple_new_inputs(
                left,
                right,
                closed=closed,
                copy=copy,
                dtype=dtype,
            )

View on GitHub (pinned to 3b7651241d)