Skip to content

PairwiseCompared

autogen.beta.eval.events.PairwiseCompared #

PairwiseCompared(*args, **kwargs)

Bases: EvalEvent

Emitted when one comparator finishes one paired task (per case).

Source code in autogen/beta/events/base.py 
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
def __init__(self, *args: Any, **kwargs: Any) -> None:
    # MRO walk: map positional args and collect defaults.
    positional_names: list[str] = []
    defaults: dict[str, Any] = {}
    seen: set[str] = set()

    for klass in reversed(type(self).__mro__):
        for name, f in getattr(klass, "_event_fields_", {}).items():
            if name not in seen:
                if not f.kw_only:
                    positional_names.append(name)
                if name not in kwargs:
                    default = f.get_default()
                    if default is not Ellipsis:
                        defaults[name] = default
            seen.add(name)

    if args:
        if len(args) > len(positional_names):
            raise TypeError(
                f"{type(self).__name__}() takes {len(positional_names)} "
                f"positional argument(s) but {len(args)} were given"
            )
        for name, value in zip(positional_names, args):
            if name in kwargs:
                raise TypeError(f"{type(self).__name__}() got multiple values for argument '{name}'")
            kwargs[name] = value
            defaults.pop(name, None)

    # Apply defaults first, then user-provided kwargs so that
    # property setters (e.g. content -> _content) aren't overwritten
    # by a field default applied afterwards.
    for key, value in defaults.items():
        setattr(self, key, value)
    for key, value in kwargs.items():
        setattr(self, key, value)

task_id instance-attribute #

task_id

key instance-attribute #

key

winner class-attribute instance-attribute #

winner = Field('tie')

created_at class-attribute instance-attribute #

created_at = Field(default_factory=time, compare=False, repr=False)

run_id instance-attribute #

run_id

label class-attribute instance-attribute #

label = Field(None)

to_dict #

to_dict()

Serialize this event to a JSON-compatible dictionary.

Source code in autogen/beta/events/base.py 
228
229
230
def to_dict(self) -> dict[str, Any]:
    """Serialize this event to a JSON-compatible dictionary."""
    return event_to_dict(self)

from_dict classmethod #

from_dict(data)

Reconstruct an event from a serialized dictionary.

Filters input to only fields known by this class (via MRO Field descriptors), then constructs via cls(**filtered).

Source code in autogen/beta/events/base.py 
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
@classmethod
def from_dict(cls, data: dict[str, Any]) -> "BaseEvent":
    """Reconstruct an event from a serialized dictionary.

    Filters input to only fields known by this class (via MRO Field
    descriptors), then constructs via ``cls(**filtered)``.
    """
    # Collect known field names across the MRO
    known_fields: set[str] = set()
    for klass in cls.__mro__:
        for name in getattr(klass, "_event_fields_", {}):
            known_fields.add(name)

    # Deserialize nested events/special types, then filter to known fields
    deserialized = deserialize_payload(data)
    filtered = {k: v for k, v in deserialized.items() if k in known_fields}
    return cls(**filtered)