MatchAnalysis Part 3 — PassGraph

In this part you will build the actual graph that keeps track of passes between players and performs simple analyses.
We use an adjacency list representation: for each sender (player) we store a list of outgoing Pass objects.

---

Background

A graph consists of nodes and edges.
In our application, a node is a player and an edge is a pass between two players.

We use an adjacency list representation:

• Each player has a list of passes they have given.
• A pass always has:
  • a sender — the player who gives the ball
  • a receiver — the player who receives the ball
  • a weight — nr_of_times, the number of times this pass occurred in the match

---

Goal

Implement a class PassGraph that allows you to:

• add players,
• register and increment passes,
• query neighbors/outgoing passes,
• compute simple statistics such as pass intensity within (a part of) the team.

---

Given

From Part 1 and Part 2 you already have:

• Player(name: str, number: int)
• Pass(sender: Player, receiver: Player, nr_of_times: int) with:
  • get_weight() → nr_of_times
  • get_start() → sender
  • get_end() → receiver
  • __eq__ compares only sender and receiver
  • __str__ returns "Pass from <sender> to <receiver>"

---

What to build (11 points)

Class: PassGraph

1) Internal representation (1 point)

• players — list with all players in the graph.
• adj — dictionary with sender name as key and a list of Pass objects as value (all passes from that sender).

2) Basic operations (6 points)

• Method add_player with player as argument
  • Add player if no other player with the same name exists.
  • Ensure an empty list exists for that player in adj.
• Method has_player with player (object or name) as argument
  • Return True if the player (or name) is in the graph.
  • Support both a Player object and a str (name).
• Method get_player with name as argument
  • Find and return the Player with this name, or None if it does not exist.
• Method add_pass with arguments sender (Player object), receiver (Player object), and times (int, default = 1).
  • Requires that both players have already been added to the graph.
  • If a pass sender → receiver already exists, increment nr_of_times by times.
  • Otherwise create a new Pass(sender, receiver, times) and add it to adj at the correct sender.
  • if times <= 0, either ignore or raise ValueError.
• Method get_pass with arguments sender_name (str) and receiver_name (str)
  • Return the pass if it exists; otherwise None.
• Method neighbors with argument sender_name (str)
  • Return the list of outgoing passes of this sender (empty list if unknown or no outgoing passes).

3) Analysis functions (4 points)

• Method total_weight with argument subset (a list of player names)
  • Return the sum of nr_of_times for all passes where both sender and receiver are in the subset.
  • If subset is None: take all players.
  • subset is always a list of player names.

• Method pass_intensity(self, subset: list[str] | None = None) -> float with argument subset (list of player names)
  This method computes how strongly a group of players pass among each other.

  The intensity is defined as:
  \(\text{pass_intensity} = \frac{\text{total number of passes within the subset}}{\text{maximum possible number of directed passes within the subset}}\)

  • Numerator: the sum of all nr_of_times for passes where both sender and receiver are in the subset.
  • Denominator: the maximum possible number of directed passes within the subset.
    • For ( n ) players in the subset, each player can pass to ( n-1 ) other players.
    • So the denominator is ( n \times (n-1) ).

  Special cases

  • If the subset has fewer than 2 players (( n < 2 )), the intensity is defined as 0.0.

  Example

  • With a subset of 3 players, there are at most ( 3 \times 2 = 6 ) possible directed passes.
  • If in reality 9 passes happened between these 3 players, then the intensity is ( 9 / 6 = 1.5 ).
    (The value can be greater than 1, since passes can happen multiple times.)
• Method top_pairs with argument k (int, default = 5)
  • Return the top k passes as a list, ordered by highest nr_of_times (globally).
• Method distribution_from with argument sender_name (str)
  • Return for a sender a list (receiver_name, count) sorted descending by count.
  • Useful to see to whom a player passes most often.

---

Notes

• Methods expecting names must handle unknown names robustly:
  • Return None or [] (as specified), but do not raise exceptions in normal query methods.
• Assume that player names are unique within the same PassGraph.

---

Testing (1 point)

Create the following test scenario:

• create a PassGraph object
• create 4 players
• add the players to the PassGraph
• add 6 passes
• test the different analysis methods