We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Fix error in failing flocking benchmark
Our benchmarks are failing: https://github.com/projectmesa/mesa/actions/workflows/benchmarks.yml

```bash
08:41:17 starting benchmarks.
08:41:35 Schelling      (small) timings: Init 0.00771 s; Run 0.0472 s
08:41:55 Schelling      (large) timings: Init 0.05062 s; Run 0.4629 s
08:42:01 WolfSheep      (small) timings: Init 0.00333 s; Run 0.0124 s
08:42:[15](https://github.com/projectmesa/mesa/actions/runs/8813652146/job/24191834761#step:7:16) WolfSheep      (large) timings: Init 0.05334 s; Run 0.2206 s
  File "/home/runner/work/mesa/mesa/benchmarks/global_benchmark.py", line 62, in <module>
    results = run_experiments(model, config)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/runner/work/mesa/mesa/benchmarks/global_benchmark.py", line 47, in run_experiments
    init_time, run_time = run_model(model_class, seed, config["parameters"])
                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/runner/work/mesa/mesa/benchmarks/global_benchmark.py", line [21](https://github.com/projectmesa/mesa/actions/runs/8813652146/job/24191834761#step:7:22), in run_model
    model = model_class(simulator=simulator, seed=seed, **parameters)
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/runner/work/mesa/mesa/benchmarks/Flocking/flocking.py", line 139, in __init__
    boid = Boid(
           ^^^^^
TypeError: Boid.__init__() got an unexpected keyword argument 'pos'
Error: Process completed with exit code 1.
```
Most likely something was changed in [benchmarks/Flocking/flocking.py](https://github.com/projectmesa/mesa/blob/main/benchmarks/Flocking/flocking.py) that needs to be fixed/reverted.

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `benchmarks/Flocking/flocking.py`
Content:
```
1 """
2 Flockers
3 =============================================================
4 A Mesa implementation of Craig Reynolds's Boids flocker model.
5 Uses numpy arrays to represent vectors.
6 """
7 
8 import numpy as np
9 
10 import mesa
11 
12 
13 class Boid(mesa.Agent):
14     """
15     A Boid-style flocker agent.
16 
17     The agent follows three behaviors to flock:
18         - Cohesion: steering towards neighboring agents.
19         - Separation: avoiding getting too close to any other agent.
20         - Alignment: try to fly in the same direction as the neighbors.
21 
22     Boids have a vision that defines the radius in which they look for their
23     neighbors to flock with. Their speed (a scalar) and direction (a vector)
24     define their movement. Separation is their desired minimum distance from
25     any other Boid.
26     """
27 
28     def __init__(
29         self,
30         unique_id,
31         model,
32         speed,
33         direction,
34         vision,
35         separation,
36         cohere=0.03,
37         separate=0.015,
38         match=0.05,
39     ):
40         """
41         Create a new Boid flocker agent.
42 
43         Args:
44             unique_id: Unique agent identifier.
45             speed: Distance to move per step.
46             direction: numpy vector for the Boid's direction of movement.
47             vision: Radius to look around for nearby Boids.
48             separation: Minimum distance to maintain from other Boids.
49             cohere: the relative importance of matching neighbors' positions
50             separate: the relative importance of avoiding close neighbors
51             match: the relative importance of matching neighbors' directions
52 
53         """
54         super().__init__(unique_id, model)
55         self.speed = speed
56         self.direction = direction
57         self.vision = vision
58         self.separation = separation
59         self.cohere_factor = cohere
60         self.separate_factor = separate
61         self.match_factor = match
62 
63     def step(self):
64         """
65         Get the Boid's neighbors, compute the new vector, and move accordingly.
66         """
67 
68         neighbors = self.model.space.get_neighbors(self.pos, self.vision, False)
69         n = 0
70         match_vector, separation_vector, cohere = np.zeros((3, 2))
71         for neighbor in neighbors:
72             n += 1
73             heading = self.model.space.get_heading(self.pos, neighbor.pos)
74             cohere += heading
75             if self.model.space.get_distance(self.pos, neighbor.pos) < self.separation:
76                 separation_vector -= heading
77             match_vector += neighbor.direction
78         n = max(n, 1)
79         cohere = cohere * self.cohere_factor
80         separation_vector = separation_vector * self.separate_factor
81         match_vector = match_vector * self.match_factor
82         self.direction += (cohere + separation_vector + match_vector) / n
83         self.direction /= np.linalg.norm(self.direction)
84         new_pos = self.pos + self.direction * self.speed
85         self.model.space.move_agent(self, new_pos)
86 
87 
88 class BoidFlockers(mesa.Model):
89     """
90     Flocker model class. Handles agent creation, placement and scheduling.
91     """
92 
93     def __init__(
94         self,
95         seed=None,
96         population=100,
97         width=100,
98         height=100,
99         vision=10,
100         speed=1,
101         separation=1,
102         cohere=0.03,
103         separate=0.015,
104         match=0.05,
105         simulator=None,
106     ):
107         """
108         Create a new Flockers model.
109 
110         Args:
111             population: Number of Boids
112             width, height: Size of the space.
113             speed: How fast should the Boids move.
114             vision: How far around should each Boid look for its neighbors
115             separation: What's the minimum distance each Boid will attempt to
116                     keep from any other
117             cohere, separate, match: factors for the relative importance of
118                     the three drives.
119         """
120         super().__init__(seed=seed)
121         self.population = population
122         self.width = width
123         self.height = height
124         self.simulator = simulator
125 
126         self.schedule = mesa.time.RandomActivation(self)
127         self.space = mesa.space.ContinuousSpace(self.width, self.height, True)
128         self.factors = {
129             "cohere": cohere,
130             "separate": separate,
131             "match": match,
132         }
133 
134         for i in range(self.population):
135             x = self.random.random() * self.space.x_max
136             y = self.random.random() * self.space.y_max
137             pos = np.array((x, y))
138             direction = np.random.random(2) * 2 - 1
139             boid = Boid(
140                 unique_id=i,
141                 model=self,
142                 pos=pos,
143                 speed=speed,
144                 direction=direction,
145                 vision=vision,
146                 separation=separation,
147                 **self.factors,
148             )
149             self.space.place_agent(boid, pos)
150             self.schedule.add(boid)
151 
152     def step(self):
153         self.schedule.step()
154 
155 
156 if __name__ == "__main__":
157     import time
158 
159     # model = BoidFlockers(seed=15, population=200, width=100, height=100, vision=5)
160     model = BoidFlockers(seed=15, population=400, width=100, height=100, vision=15)
161 
162     start_time = time.perf_counter()
163     for _ in range(100):
164         model.step()
165 
166     print(time.perf_counter() - start_time)
167
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/benchmarks/Flocking/flocking.py b/benchmarks/Flocking/flocking.py
--- a/benchmarks/Flocking/flocking.py
+++ b/benchmarks/Flocking/flocking.py
@@ -139,7 +139,6 @@
             boid = Boid(
                 unique_id=i,
                 model=self,
-                pos=pos,
                 speed=speed,
                 direction=direction,
                 vision=vision,

{"golden_diff": "diff --git a/benchmarks/Flocking/flocking.py b/benchmarks/Flocking/flocking.py\n--- a/benchmarks/Flocking/flocking.py\n+++ b/benchmarks/Flocking/flocking.py\n@@ -139,7 +139,6 @@\n             boid = Boid(\n                 unique_id=i,\n                 model=self,\n-                pos=pos,\n                 speed=speed,\n                 direction=direction,\n                 vision=vision,\n", "issue": "Fix error in failing flocking benchmark\nOur benchmarks are failing: https://github.com/projectmesa/mesa/actions/workflows/benchmarks.yml\r\n\r\n```bash\r\n08:41:17 starting benchmarks.\r\n08:41:35 Schelling      (small) timings: Init 0.00771 s; Run 0.0472 s\r\n08:41:55 Schelling      (large) timings: Init 0.05062 s; Run 0.4629 s\r\n08:42:01 WolfSheep      (small) timings: Init 0.00333 s; Run 0.0124 s\r\n08:42:[15](https://github.com/projectmesa/mesa/actions/runs/8813652146/job/24191834761#step:7:16) WolfSheep      (large) timings: Init 0.05334 s; Run 0.2206 s\r\n  File \"/home/runner/work/mesa/mesa/benchmarks/global_benchmark.py\", line 62, in <module>\r\n    results = run_experiments(model, config)\r\n              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\r\n  File \"/home/runner/work/mesa/mesa/benchmarks/global_benchmark.py\", line 47, in run_experiments\r\n    init_time, run_time = run_model(model_class, seed, config[\"parameters\"])\r\n                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\r\n  File \"/home/runner/work/mesa/mesa/benchmarks/global_benchmark.py\", line [21](https://github.com/projectmesa/mesa/actions/runs/8813652146/job/24191834761#step:7:22), in run_model\r\n    model = model_class(simulator=simulator, seed=seed, **parameters)\r\n            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\r\n  File \"/home/runner/work/mesa/mesa/benchmarks/Flocking/flocking.py\", line 139, in __init__\r\n    boid = Boid(\r\n           ^^^^^\r\nTypeError: Boid.__init__() got an unexpected keyword argument 'pos'\r\nError: Process completed with exit code 1.\r\n```\r\nMost likely something was changed in [benchmarks/Flocking/flocking.py](https://github.com/projectmesa/mesa/blob/main/benchmarks/Flocking/flocking.py) that needs to be fixed/reverted.\n", "before_files": [{"content": "\"\"\"\nFlockers\n=============================================================\nA Mesa implementation of Craig Reynolds's Boids flocker model.\nUses numpy arrays to represent vectors.\n\"\"\"\n\nimport numpy as np\n\nimport mesa\n\n\nclass Boid(mesa.Agent):\n    \"\"\"\n    A Boid-style flocker agent.\n\n    The agent follows three behaviors to flock:\n        - Cohesion: steering towards neighboring agents.\n        - Separation: avoiding getting too close to any other agent.\n        - Alignment: try to fly in the same direction as the neighbors.\n\n    Boids have a vision that defines the radius in which they look for their\n    neighbors to flock with. Their speed (a scalar) and direction (a vector)\n    define their movement. Separation is their desired minimum distance from\n    any other Boid.\n    \"\"\"\n\n    def __init__(\n        self,\n        unique_id,\n        model,\n        speed,\n        direction,\n        vision,\n        separation,\n        cohere=0.03,\n        separate=0.015,\n        match=0.05,\n    ):\n        \"\"\"\n        Create a new Boid flocker agent.\n\n        Args:\n            unique_id: Unique agent identifier.\n            speed: Distance to move per step.\n            direction: numpy vector for the Boid's direction of movement.\n            vision: Radius to look around for nearby Boids.\n            separation: Minimum distance to maintain from other Boids.\n            cohere: the relative importance of matching neighbors' positions\n            separate: the relative importance of avoiding close neighbors\n            match: the relative importance of matching neighbors' directions\n\n        \"\"\"\n        super().__init__(unique_id, model)\n        self.speed = speed\n        self.direction = direction\n        self.vision = vision\n        self.separation = separation\n        self.cohere_factor = cohere\n        self.separate_factor = separate\n        self.match_factor = match\n\n    def step(self):\n        \"\"\"\n        Get the Boid's neighbors, compute the new vector, and move accordingly.\n        \"\"\"\n\n        neighbors = self.model.space.get_neighbors(self.pos, self.vision, False)\n        n = 0\n        match_vector, separation_vector, cohere = np.zeros((3, 2))\n        for neighbor in neighbors:\n            n += 1\n            heading = self.model.space.get_heading(self.pos, neighbor.pos)\n            cohere += heading\n            if self.model.space.get_distance(self.pos, neighbor.pos) < self.separation:\n                separation_vector -= heading\n            match_vector += neighbor.direction\n        n = max(n, 1)\n        cohere = cohere * self.cohere_factor\n        separation_vector = separation_vector * self.separate_factor\n        match_vector = match_vector * self.match_factor\n        self.direction += (cohere + separation_vector + match_vector) / n\n        self.direction /= np.linalg.norm(self.direction)\n        new_pos = self.pos + self.direction * self.speed\n        self.model.space.move_agent(self, new_pos)\n\n\nclass BoidFlockers(mesa.Model):\n    \"\"\"\n    Flocker model class. Handles agent creation, placement and scheduling.\n    \"\"\"\n\n    def __init__(\n        self,\n        seed=None,\n        population=100,\n        width=100,\n        height=100,\n        vision=10,\n        speed=1,\n        separation=1,\n        cohere=0.03,\n        separate=0.015,\n        match=0.05,\n        simulator=None,\n    ):\n        \"\"\"\n        Create a new Flockers model.\n\n        Args:\n            population: Number of Boids\n            width, height: Size of the space.\n            speed: How fast should the Boids move.\n            vision: How far around should each Boid look for its neighbors\n            separation: What's the minimum distance each Boid will attempt to\n                    keep from any other\n            cohere, separate, match: factors for the relative importance of\n                    the three drives.\n        \"\"\"\n        super().__init__(seed=seed)\n        self.population = population\n        self.width = width\n        self.height = height\n        self.simulator = simulator\n\n        self.schedule = mesa.time.RandomActivation(self)\n        self.space = mesa.space.ContinuousSpace(self.width, self.height, True)\n        self.factors = {\n            \"cohere\": cohere,\n            \"separate\": separate,\n            \"match\": match,\n        }\n\n        for i in range(self.population):\n            x = self.random.random() * self.space.x_max\n            y = self.random.random() * self.space.y_max\n            pos = np.array((x, y))\n            direction = np.random.random(2) * 2 - 1\n            boid = Boid(\n                unique_id=i,\n                model=self,\n                pos=pos,\n                speed=speed,\n                direction=direction,\n                vision=vision,\n                separation=separation,\n                **self.factors,\n            )\n            self.space.place_agent(boid, pos)\n            self.schedule.add(boid)\n\n    def step(self):\n        self.schedule.step()\n\n\nif __name__ == \"__main__\":\n    import time\n\n    # model = BoidFlockers(seed=15, population=200, width=100, height=100, vision=5)\n    model = BoidFlockers(seed=15, population=400, width=100, height=100, vision=15)\n\n    start_time = time.perf_counter()\n    for _ in range(100):\n        model.step()\n\n    print(time.perf_counter() - start_time)\n", "path": "benchmarks/Flocking/flocking.py"}], "after_files": [{"content": "\"\"\"\nFlockers\n=============================================================\nA Mesa implementation of Craig Reynolds's Boids flocker model.\nUses numpy arrays to represent vectors.\n\"\"\"\n\nimport numpy as np\n\nimport mesa\n\n\nclass Boid(mesa.Agent):\n    \"\"\"\n    A Boid-style flocker agent.\n\n    The agent follows three behaviors to flock:\n        - Cohesion: steering towards neighboring agents.\n        - Separation: avoiding getting too close to any other agent.\n        - Alignment: try to fly in the same direction as the neighbors.\n\n    Boids have a vision that defines the radius in which they look for their\n    neighbors to flock with. Their speed (a scalar) and direction (a vector)\n    define their movement. Separation is their desired minimum distance from\n    any other Boid.\n    \"\"\"\n\n    def __init__(\n        self,\n        unique_id,\n        model,\n        speed,\n        direction,\n        vision,\n        separation,\n        cohere=0.03,\n        separate=0.015,\n        match=0.05,\n    ):\n        \"\"\"\n        Create a new Boid flocker agent.\n\n        Args:\n            unique_id: Unique agent identifier.\n            speed: Distance to move per step.\n            direction: numpy vector for the Boid's direction of movement.\n            vision: Radius to look around for nearby Boids.\n            separation: Minimum distance to maintain from other Boids.\n            cohere: the relative importance of matching neighbors' positions\n            separate: the relative importance of avoiding close neighbors\n            match: the relative importance of matching neighbors' directions\n\n        \"\"\"\n        super().__init__(unique_id, model)\n        self.speed = speed\n        self.direction = direction\n        self.vision = vision\n        self.separation = separation\n        self.cohere_factor = cohere\n        self.separate_factor = separate\n        self.match_factor = match\n\n    def step(self):\n        \"\"\"\n        Get the Boid's neighbors, compute the new vector, and move accordingly.\n        \"\"\"\n\n        neighbors = self.model.space.get_neighbors(self.pos, self.vision, False)\n        n = 0\n        match_vector, separation_vector, cohere = np.zeros((3, 2))\n        for neighbor in neighbors:\n            n += 1\n            heading = self.model.space.get_heading(self.pos, neighbor.pos)\n            cohere += heading\n            if self.model.space.get_distance(self.pos, neighbor.pos) < self.separation:\n                separation_vector -= heading\n            match_vector += neighbor.direction\n        n = max(n, 1)\n        cohere = cohere * self.cohere_factor\n        separation_vector = separation_vector * self.separate_factor\n        match_vector = match_vector * self.match_factor\n        self.direction += (cohere + separation_vector + match_vector) / n\n        self.direction /= np.linalg.norm(self.direction)\n        new_pos = self.pos + self.direction * self.speed\n        self.model.space.move_agent(self, new_pos)\n\n\nclass BoidFlockers(mesa.Model):\n    \"\"\"\n    Flocker model class. Handles agent creation, placement and scheduling.\n    \"\"\"\n\n    def __init__(\n        self,\n        seed=None,\n        population=100,\n        width=100,\n        height=100,\n        vision=10,\n        speed=1,\n        separation=1,\n        cohere=0.03,\n        separate=0.015,\n        match=0.05,\n        simulator=None,\n    ):\n        \"\"\"\n        Create a new Flockers model.\n\n        Args:\n            population: Number of Boids\n            width, height: Size of the space.\n            speed: How fast should the Boids move.\n            vision: How far around should each Boid look for its neighbors\n            separation: What's the minimum distance each Boid will attempt to\n                    keep from any other\n            cohere, separate, match: factors for the relative importance of\n                    the three drives.\n        \"\"\"\n        super().__init__(seed=seed)\n        self.population = population\n        self.width = width\n        self.height = height\n        self.simulator = simulator\n\n        self.schedule = mesa.time.RandomActivation(self)\n        self.space = mesa.space.ContinuousSpace(self.width, self.height, True)\n        self.factors = {\n            \"cohere\": cohere,\n            \"separate\": separate,\n            \"match\": match,\n        }\n\n        for i in range(self.population):\n            x = self.random.random() * self.space.x_max\n            y = self.random.random() * self.space.y_max\n            pos = np.array((x, y))\n            direction = np.random.random(2) * 2 - 1\n            boid = Boid(\n                unique_id=i,\n                model=self,\n                speed=speed,\n                direction=direction,\n                vision=vision,\n                separation=separation,\n                **self.factors,\n            )\n            self.space.place_agent(boid, pos)\n            self.schedule.add(boid)\n\n    def step(self):\n        self.schedule.step()\n\n\nif __name__ == \"__main__\":\n    import time\n\n    # model = BoidFlockers(seed=15, population=200, width=100, height=100, vision=5)\n    model = BoidFlockers(seed=15, population=400, width=100, height=100, vision=15)\n\n    start_time = time.perf_counter()\n    for _ in range(100):\n        model.step()\n\n    print(time.perf_counter() - start_time)\n", "path": "benchmarks/Flocking/flocking.py"}]}