analyzer.postprocessing.grouping

Attributes

logger
ResultSet
T

Classes

InputTrace
SelectTrace
CaptureGroupTrace
GroupingTrace
TransformStepTrace
GroupTrace
GroupBuilder	Constructs and applies a sequence of operations to filter, group, and

Functions

applyTransform(transform, items)
configureConverter(conv)

Module Contents

analyzer.postprocessing.grouping.logger

analyzer.postprocessing.grouping.ResultSet

analyzer.postprocessing.grouping.T

class analyzer.postprocessing.grouping.InputTrace

count: int = 0

items: list[str]

record(items: list[analyzer.utils.structure_tools.ItemWithMeta])

class analyzer.postprocessing.grouping.SelectTrace

pattern: str | None = None

selected_count: int = 0

dropped_count: int = 0

selected_items: list[str]

dropped_items: list[str]

record(pattern: analyzer.utils.querying.BasePattern, selected: list[analyzer.utils.structure_tools.ItemWithMeta], dropped: list[analyzer.utils.structure_tools.ItemWithMeta])

class analyzer.postprocessing.grouping.CaptureGroupTrace

key: str = ''

count: int = 0

items: list[str]

classmethod fromCaptureSet(cs: analyzer.utils.querying.CaptureSet) → CaptureGroupTrace

class analyzer.postprocessing.grouping.GroupingTrace

pattern: str | None = None

groups: list[CaptureGroupTrace]

record(pattern: analyzer.utils.querying.BasePattern, capture_sets: list[analyzer.utils.querying.CaptureSet])

class analyzer.postprocessing.grouping.TransformStepTrace

name: str = ''

post_count: int = 0

class analyzer.postprocessing.grouping.GroupTrace

input: InputTrace

select: SelectTrace | None = None

grouping: GroupingTrace | None = None

transforms: list[TransformStepTrace]

subgroup_traces: list[dict[str, GroupTrace] | list[GroupTrace]]

recordInput(items: list[analyzer.utils.structure_tools.ItemWithMeta])

recordSelect(pattern: analyzer.utils.querying.BasePattern, selected: list[analyzer.utils.structure_tools.ItemWithMeta], dropped: list[analyzer.utils.structure_tools.ItemWithMeta])

recordGrouping(pattern: analyzer.utils.querying.BasePattern, capture_sets: list[analyzer.utils.querying.CaptureSet])

recordTransform(transform, total_count: int)

analyzer.postprocessing.grouping.applyTransform(transform, items)

class analyzer.postprocessing.grouping.GroupBuilder

Constructs and applies a sequence of operations to filter, group, and transform collections of items based on their metadata.

Attributes:

group (BasePattern | None): A pattern used to capture and group items.

If provided, items are gathered by the capture groups defined in this pattern.

select (BasePattern | None): A pattern used to filter the initial items.

Only items whose metadata matches this pattern are kept.

subgroups (list[GroupBuilder] | dict[str, GroupBuilder] | None): Nested

group builders to apply recursively to the resulting groups. If a dictionary, the output will be a dictionary with corresponding keys. If a list, the output will be a list of applied results.

transforms (list[Transform] | None): A list of transformation functions

to apply to each formed group.

group: analyzer.utils.querying.BasePattern | None = None

select: analyzer.utils.querying.BasePattern | None = None

subgroups: list[GroupBuilder] | dict[str, GroupBuilder] | None = None

transforms: list[analyzer.postprocessing.transforms.registry.Transform | list[analyzer.postprocessing.transforms.registry.Transform]] | None = None

apply(items, trace: GroupTrace | None = None)

Applies the selection, grouping, transformations, and subgroup operations to the given items.

Args:

items: A list of items (typically objects with metadata) to be

processed.

trace: If provided, populated in-place with a trace of every

decision made during the pipeline.

Returns:

The processed groups. The exact return type depends on the structure of subgroups:

• If subgroups is None, returns the list of transformed groups.

• If subgroups is a dict, returns a list of dictionaries containing the subgroup results.

• If subgroups is a list, returns a list of lists containing the subgroup results.

explain(items) → GroupTrace

analyzer.postprocessing.grouping.configureConverter(conv)