ak.contents.Content

Defined in awkward.contents.content on line 136.

class ak.contents.Content

_init(parameters: dict[str, awkward._typing.Any] | None, backend: awkward._backends.backend.Backend)

property backend: awkward._backends.backend.Backend

property form: awkward.forms.form.Form

form_with_key(form_key: str | None | collections.abc.Callable = 'node{id}', id_start: int = 0) → awkward.forms.form.Form

abstract _form_with_key(getkey: collections.abc.Callable[[Content], str | None]) → awkward.forms.form.Form

form_with_key_path(root: awkward.forms.form.FormKeyPathT = ()) → awkward.forms.form.Form

abstract _form_with_key_path(path: awkward.forms.form.FormKeyPathT) → awkward.forms.form.Form

property form_cls: type[awkward.forms.form.Form]

Abstractmethod:

to_typetracer(forget_length: bool = False) → awkward._typing.Self

abstract _to_typetracer(forget_length: bool) → awkward._typing.Self

abstract _touch_data(recursive: bool)

abstract _touch_shape(recursive: bool)

property length: awkward._nplikes.shape.ShapeItem

Abstractmethod:

abstract _to_buffers(form: awkward.forms.form.Form, getkey: collections.abc.Callable[[Content, awkward.forms.form.Form, str], str], container: collections.abc.MutableMapping[str, awkward._typing.Any] | None, backend: awkward._backends.backend.Backend, byteorder: awkward._typing.Literal[<, >]) → tuple[awkward.forms.form.Form, int, collections.abc.Mapping[str, awkward._typing.Any]]

_repr_extra(indent: str) → list[str]

maybe_to_NumpyArray()

_maybe_index_error(error: awkward._kernels.KernelError | None, slicer)

_getitem_next_field(head: awkward._slicing.SliceItem | tuple, tail: tuple[awkward._slicing.SliceItem, Ellipsis], advanced: awkward.index.Index | None)

_getitem_next_fields(head: awkward._slicing.SliceItem, tail: tuple[awkward._slicing.SliceItem, Ellipsis], advanced: awkward.index.Index | None) → Content

_getitem_next_newaxis(tail: tuple[awkward._slicing.SliceItem, Ellipsis], advanced: awkward.index.Index | None) → awkward.contents.regulararray.RegularArray

_getitem_next_ellipsis(tail: tuple[awkward._slicing.SliceItem, Ellipsis], advanced: awkward.index.Index | None) → Content

_getitem_next_regular_missing(head: awkward.contents.indexedoptionarray.IndexedOptionArray, tail: tuple[awkward._slicing.SliceItem, Ellipsis], advanced: awkward.index.Index | None, raw: Content, length: int) → awkward.contents.regulararray.RegularArray

_getitem_next_missing_jagged(head: Content, tail, advanced: awkward.index.Index | None, that: Content) → awkward.contents.regulararray.RegularArray

_getitem_next_missing(head: awkward.contents.indexedoptionarray.IndexedOptionArray, tail: tuple[awkward._slicing.SliceItem, Ellipsis], advanced: awkward.index.Index | None) → Content

_getitem(where, named_axis: awkward._typing.Type[awkward._namedaxis.NamedAxis] = NamedAxis)

abstract _is_getitem_at_placeholder() → bool

_is_getitem_at_virtual() → bool

abstract _getitem_at(where: awkward._nplikes.numpy_like.IndexType)

abstract _getitem_range(start: awkward._nplikes.numpy_like.IndexType, stop: awkward._nplikes.numpy_like.IndexType) → Content

abstract _getitem_field(where: str | awkward._typing.SupportsIndex, only_fields: tuple[str, Ellipsis] = ()) → Content

abstract _getitem_fields(where: list[str], only_fields: tuple[str, Ellipsis] = ()) → Content

abstract _getitem_next(head: awkward._slicing.SliceItem | tuple, tail: tuple[awkward._slicing.SliceItem, Ellipsis], advanced: awkward.index.Index | None) → Content

abstract _getitem_next_jagged(slicestarts: awkward.index.Index, slicestops: awkward.index.Index, slicecontent: Content, tail: tuple[awkward._slicing.SliceItem, Ellipsis]) → Content

abstract _carry(carry: awkward.index.Index, allow_lazy: bool) → Content

_local_index_axis0() → awkward.contents.numpyarray.NumpyArray

abstract _mergeable_next(other: Content, mergebool: bool, mergecastable: awkward._typing.Literal[same_kind, equiv, family]) → bool

abstract _mergemany(others: collections.abc.Sequence[Content]) → Content

_merging_strategy(others: list[Content]) → tuple[list[Content], list[Content]]

abstract _local_index(axis: int, depth: int)

abstract _reduce_next(reducer: awkward._reducers.Reducer, negaxis: int, starts: awkward.index.Index, shifts: awkward.index.Index | None, parents: awkward.index.Index | awkward.index.ZeroIndex, offsets: awkward.index.Index | awkward.index.EmptyIndex, outlength: int, mask: bool, keepdims: bool, behavior: dict | None)

abstract _argsort_next(negaxis: int, starts: awkward.index.Index, shifts: awkward.index.Index | None, parents: awkward.index.Index | awkward.index.ZeroIndex, offsets: awkward.index.Index | awkward.index.EmptyIndex, outlength: int, ascending: bool, stable: bool)

abstract _sort_next(negaxis: int, starts: awkward.index.Index, parents: awkward.index.Index | awkward.index.ZeroIndex, offsets: awkward.index.Index | awkward.index.EmptyIndex, outlength: int, ascending: bool, stable: bool)

_combinations_axis0(n: int, replacement: bool, recordlookup: list[str] | None, parameters: dict | None)

abstract _combinations(n: int, replacement: bool, recordlookup: list[str] | None, parameters: dict[str, awkward._typing.Any] | None, axis: int, depth: int)

abstract _validity_error(path: str) → str

property nbytes: int

purelist_parameter(key: str)

Return the value of the outermost parameter matching key in a sequence of nested lists, stopping at the first record or tuple layer.

If a layer has #ak.types.UnionType, the value is only returned if all possibilities have the same value.

purelist_parameters(*keys: str)

Return the value of the outermost parameter matching one of keys in a sequence of nested lists, stopping at the first record or tuple layer.

If a layer has #ak.types.UnionType, the value is only returned if all possibilities have the same value.

abstract _is_unique(negaxis: awkward._typing.AxisMaybeNone, starts: awkward.index.Index, parents: awkward.index.Index | awkward.index.ZeroIndex, offsets: awkward.index.Index | awkward.index.EmptyIndex, outlength: int) → bool

abstract _unique(negaxis: awkward._typing.AxisMaybeNone, starts: awkward.index.Index, parents: awkward.index.Index | awkward.index.ZeroIndex, offsets: awkward.index.Index | awkward.index.EmptyIndex, outlength: int)

_pad_none_axis0(target: int, clip: bool) → Content

abstract _pad_none(target: int, axis: int, depth: int, clip: bool) → Content

to_arrow(list_to32: bool = False, string_to32: bool = False, bytestring_to32: bool = False, emptyarray_to=None, categorical_as_dictionary: bool = False, extensionarray: bool = True, count_nulls: bool = True, record_is_scalar: bool = False)

abstract _to_arrow(pyarrow: awkward._typing.Any, mask_node: Content | None, validbytes: Content | None, length: int, options: ToArrowOptions)

abstract _to_cudf(cudf: awkward._typing.Any, mask: Content | None, length: int)

to_backend_array(allow_missing: bool = True, *, backend: awkward._backends.backend.Backend | str | None = None)

abstract _to_backend_array(allow_missing: bool, backend: awkward._backends.backend.Backend)

drop_none()

abstract _drop_none() → Content

abstract _remove_structure(backend: awkward._backends.backend.Backend, options: RemoveStructureOptions) → list[Content]

abstract _recursively_apply(action: ImplementsApplyAction, depth: int, depth_context: collections.abc.Mapping[str, awkward._typing.Any] | None, lateral_context: collections.abc.Mapping[str, awkward._typing.Any] | None, options: ApplyActionOptions) → Content | None

to_json(nan_string: str | None = None, posinf_string: str | None = None, neginf_string: str | None = None, complex_record_fields: tuple[str, str] | None = None, convert_bytes: bool | None = None, behavior: dict | None = None) → list

to_packed(recursive: bool = True) → Content

abstract _to_packed(recursive: bool = True) → Content

to_list(behavior: dict | None = None) → list

abstract _to_list(behavior: dict | None, json_conversions: dict[str, awkward._typing.Any] | None) → list

_to_list_custom(behavior: dict | None, json_conversions: dict[str, awkward._typing.Any] | None)

abstract _offsets_and_flattened(axis: int, depth: int) → tuple[awkward.index.Index, Content]

to_backend(backend: awkward._backends.backend.Backend | str | None = None) → awkward._typing.Self

abstract _to_backend(backend: awkward._backends.backend.Backend) → awkward._typing.Self

materialize(type_: type = MaterializableArray) → awkward._typing.Self

abstract _materialize(type_) → awkward._typing.Self

property is_all_materialized: bool

property _is_all_materialized: bool

Abstractmethod:

property is_any_materialized: bool

property _is_any_materialized: bool

Abstractmethod:

with_parameter(key: str, value: awkward._typing.Any) → awkward._typing.Self

is_equal_to(other: Content, index_dtype: bool = True, numpyarray: bool = True, *, all_parameters: bool = False) → bool

_is_equal_to_generic(other: Content, all_parameters: bool) → bool

abstract _is_equal_to(other: awkward._typing.Self, index_dtype: bool, numpyarray: bool, all_parameters: bool) → bool

abstract _repr(indent: str, pre: str, post: str) → str

abstract _numbers_to_type(name: str, including_unknown: bool) → Content

abstract _fill_none(value: Content) → Content

abstract copy(*, parameters: awkward._typing.JSONMapping | None = UNSET) → awkward._typing.Self

classmethod _arrow_needs_option_type()