Measure minutes played in and out of possession

[lodevt]

The current MinutesPlayedAggregator (see here) calculates a general MinutesPlayed and optionally also a MinutesPlayedPerPosition. I think it would make sense to extend this to also calculate MinutesPlayerPerPossessionState, which would provide minutes played for three possession states:

• in possession
• out of possession
• ball dead

The existing ball_state and ball_owning_team properties can be used to extract the necessary information.

Example data structure:

class PossessionState(Enum): 
    IN_POSSESSION = 'in-possession'
    OUT_OF_POSSESSION = 'out-of-possession'
    BALL_DEAD = 'ball-dead'

class MinutesPlayedPerPossessionState(NamedTuple):
    player: Player
    possession_state: PossessionState
    duration: timedelta

[UnravelSports]

This is a cool idea! I've been doing this for event data with a Frankenstein approach (we need sequences, receival moment etc), but doing this from tracking data is pretty smart.

I don't think MinutesPlayed current works on tracking data, maybe that's something we should support too?

[koenvo]

Absolutely love this idea!

Would it be possible to make this more generic? Can imagine you also want to do this on team level. Or maybe only on possession state level, to check real playing time.

[lodevt]

Absolutely love this idea!

Would it be possible to make this more generic? Can imagine you also want to do this on team level. Or maybe only on possession state level, to check real playing time.

I think we could make it more generic by defining a general executor that can represent either a Player or a Team. The same data structure can be reused for both executors (of course the MinutesPlayedPerPosition would only be calculated for players).

class MinutesPlayed(NamedTuple):
    executor: Union[Player, Team]
    start_time: Time
    end_time: Time
    duration: timedelta

[koenvo]

What if we use key instead of executor and allow a tuple / NamedTuple as key?

[lode-mgp]

To make sure we are alligned, do you suggest using a class like this as key (replacing the playerfield)?

class MinutesPlayedKey(NamedTuple):
    player: Optional[Player] = None
    team: Optional[Team] = None

class MinutesPlayed(NamedTuple):
    key: MinutesPlayedKey
    start_time: Time
    end_time: Time
    duration: timedelta

[koenvo]

Yes. Please let me know if this sounds like a terrible idea :-)

[lode-mgp]

No, I think it definitely makes sense to be able to easily check whether you are dealing with a player or a team ;))

[koenvo]

The key can be extended in any way, like:

class MinutesPlayedKey(NamedTuple):
    player: Player
    possession_state: PossessionState

Only problem might be that it can/might break typechecking.

[lode-mgp]

Can you give an example of how this might break typechecking?

[koenvo]

When the key can contain arbitrary items it is harder (or impossible) to return the correct type for the key at https://github.com/PySport/kloppy/blob/master/kloppy/domain/services/aggregators/minutes_played.py#L31 .

[lode-mgp]

Do you see any issues with the approach below?

class MinutesPlayedKey(NamedTuple):
    player: Optional[Player] = None
    team: Optional[Team] = None
    possession_state: Optional[PossessionState] = None
    position: Optional[PositionType] = None

   

class MinutesPlayed(NamedTuple):
    key: MinutesPlayedKey
    start_time: Time
    end_time: Time
    duration: timedelta

Then the aggregate function can return List[MinutesPlayed], where the keys contain

1. either a player or a team (we should probably enforce that exactly one of the two is not None)
2. optionally also a possession_state or position

When initializing the MinutesPlayedAggregator, the user can define which keys should be included.