Index

kloppy.domain.CodeDataset dataclass

CodeDataset(records, metadata, dataset_type=CODE)

Bases: Dataset[Code]

A dataset containing SportsCode annotations.

ATTRIBUTE	DESCRIPTION
dataset_type	"DatasetType.CODE" TYPE: DatasetType
codes	A list of codes. Alias for records. TYPE: List[Code]
metadata	Metadata of the code dataset. TYPE: Metadata

dataset_type class-attribute instance-attribute

dataset_type = CODE

codes property

codes

records instance-attribute

records

metadata instance-attribute

metadata

to_pandas

to_pandas(record_converter=None, additional_columns=None)

Source code in kloppy/domain/models/code.py

@deprecated(
    "to_pandas will be removed in the future. Please use to_df instead."
)
def to_pandas(
    self,
    record_converter: Optional[Callable[[Code], Dict]] = None,
    additional_columns=None,
) -> "DataFrame":
    try:
        import pandas as pd
    except ImportError:
        raise ImportError(
            "Seems like you don't have pandas installed. Please"
            " install it using: pip install pandas"
        )

    if not record_converter:
        from ..services.transformers.attribute import (
            DefaultCodeTransformer,
        )

        record_converter = DefaultCodeTransformer()

    def generic_record_converter(code: Code):
        row = record_converter(code)
        if additional_columns:
            for k, v in additional_columns.items():
                if callable(v):
                    value = v(code)
                else:
                    value = v
                row.update({k: value})

        return row

    return pd.DataFrame.from_records(
        map(generic_record_converter, self.records)
    )

transform

transform(*args, **kwargs)

See transform

filter

filter(filter_)

Filter all records used filter_

PARAMETER	DESCRIPTION
filter_	The filter to be used to filter the records. It can be a callable that takes a record and returns a boolean, or a string representing a css-like selector. TYPE: Union[str, Callable[[Code], bool]]

Examples:

>>> from kloppy.domain import EventType
>>> dataset = dataset.filter(lambda event: event.event_type == EventType.PASS)
>>> dataset = dataset.filter('pass')

map

map(mapper)

find_all

find_all(filter_)

find

find(filter_)

from_dataset classmethod

from_dataset(dataset, mapper_fn)

Create a new Dataset from other dataset

PARAMETER	DESCRIPTION
mapper_fn	TYPE: Callable[[Self], Self]

Examples:

>>> from kloppy.domain import Code,     CodeDataset

>>> code_dataset = (
>>>     CodeDataset
>>>     .from_dataset(
>>>         dataset,
>>>         lambda event: Code(
>>>             code_id=event.event_id,
>>>             code=event.event_name,
>>>             period=event.period,
>>>             timestamp=event.timestamp - 7,
>>>             end_timestamp=event.timestamp + 5,
>>>             labels={
>>>                 'Player': str(event.player),
>>>                 'Team': str(event.team)
>>>             }
>>>         )
>>>     )
>>> )

get_record_by_id

get_record_by_id(record_id)

to_records

to_records(
    *columns: Unpack[tuple[Column]],
    as_list: Literal[True] = True,
    **named_columns: NamedColumns
) -> List[Dict[str, Any]]

to_records(
    *columns: Unpack[tuple[Column]],
    as_list: Literal[False] = False,
    **named_columns: NamedColumns
) -> Iterable[Dict[str, Any]]

to_records(*columns, as_list=True, **named_columns)

to_dict

to_dict(*columns, orient='list', **named_columns)

to_df

to_df(*columns, engine=None, **named_columns)