kaggle-environments 0.2.0__py3-none-any.whl → 1.20.0__py3-none-any.whl

kaggle_environments/envs/connectx/connectx.js

@@ -282,7 +282,7 @@ function renderer({
     for (let d = 0; d < 8; d++) {
       const seq = getSequence(graph[i], d);
       if (seq) {
-        drawLine(seq[0], seq[3]);
+        drawLine(seq[0], seq[inarow - 1]);
         i = board.length;
         break;
       }

kaggle_environments/envs/connectx/connectx.json

@@ -22,6 +22,19 @@
       "type": "integer",
       "default": 4,
       "minimum": 1
+    },
+    "agentTimeout": {
+      "description": "Obsolete field kept for backwards compatibility, please use observation.remainingOverageTime.",
+      "type": "number",
+      "minimum": 0,
+      "default": 60
+    },
+    "actTimeout": 2,
+    "timeout": {
+      "description": "Obsolete copy of actTimeout maintained for backwards compatibility. May be removed in the future.",
+      "type": "integer",
+      "default": 2,
+      "minimum": 0
     }
   },
   "reward": {
@@ -43,7 +56,8 @@
       "defaults": [1, 2],
       "description": "Which checkers are the agents.",
       "enum": [1, 2]
-    }
+    },
+    "remainingOverageTime": 60
   },
   "action": {
     "description": "Column to drop a checker onto the board.",

kaggle_environments/envs/connectx/connectx.py

@@ -40,13 +40,7 @@ def is_win(board, column, mark, config, has_played=True):
         for i in range(1, inarow + 1):
             r = row + offset_row * i
             c = column + offset_column * i
-            if (
-                r < 0
-                or r >= rows
-                or c < 0
-                or c >= columns
-                or board[c + (r * columns)] != mark
-            ):
+            if r < 0 or r >= rows or c < 0 or c >= columns or board[c + (r * columns)] != mark:
                 return i - 1
         return inarow
 
@@ -89,20 +83,11 @@ def negamax_agent(obs, config):
             if board[column] == EMPTY:
                 # Max depth reached. Score based on cell proximity for a clustering effect.
                 if depth <= 0:
-                    row = max(
-                        [
-                            r
-                            for r in range(rows)
-                            if board[column + (r * columns)] == EMPTY
-                        ]
-                    )
+                    row = max([r for r in range(rows) if board[column + (r * columns)] == EMPTY])
                     score = (size + 1 - moves) / 2
                     if column > 0 and board[row * columns + column - 1] == mark:
                         score += 1
-                    if (
-                        column < columns - 1
-                        and board[row * columns + column + 1] == mark
-                    ):
+                    if column < columns - 1 and board[row * columns + column + 1] == mark:
                         score += 1
                     if row > 0 and board[(row - 1) * columns + column] == mark:
                         score += 1
@@ -111,8 +96,7 @@ def negamax_agent(obs, config):
                 else:
                     next_board = board[:]
                     play(next_board, column, mark, config)
-                    (score, _) = negamax(next_board,
-                                         1 if mark == 2 else 2, depth - 1)
+                    (score, _) = negamax(next_board, 1 if mark == 2 else 2, depth - 1)
                     score = score * -1
                 if score > best_score or (score == best_score and choice([True, False])):
                     best_score = score
@@ -194,8 +178,7 @@ def renderer(state, env):
     row_bar = "+" + "+".join(["---"] * columns) + "+\n"
     out = row_bar
     for r in range(rows):
-        out = out + \
-            print_row(board[r * columns: r * columns + columns]) + row_bar
+        out = out + print_row(board[r * columns : r * columns + columns]) + row_bar
 
     return out
 
@@ -208,5 +191,5 @@ with open(jsonpath) as f:
 
 def html_renderer():
     jspath = path.abspath(path.join(dirpath, "connectx.js"))
-    with open(jspath) as f:
+    with open(jspath, encoding="utf-8") as f:
         return f.read()

kaggle_environments/envs/connectx/test_connectx.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from kaggle_environments import make, evaluate
+from kaggle_environments import evaluate, make
 
 env = None
 
@@ -20,8 +20,30 @@ env = None
 def before_each(state=None, configuration=None):
     global env
     steps = [] if state == None else [state]
-    env = make("connectx", steps=steps,
-               configuration=configuration, debug=True)
+    env = make("connectx", steps=steps, configuration=configuration, debug=False)
+
+
+def test_has_correct_timeouts():
+    before_each()
+    assert env.configuration.actTimeout == 2
+
+
+def test_can_train_first():
+    before_each()
+    trainer = env.train([None, "random"])
+    obs = trainer.reset()
+    assert "board" in obs
+    obs, _, _, _ = trainer.step(0)
+    assert "board" in obs
+
+
+def test_can_train_second():
+    before_each()
+    trainer = env.train(["random", None])
+    obs = trainer.reset()
+    assert "board" in obs
+    obs, _, _, _ = trainer.step(0)
+    assert "board" in obs
 
 
 def test_to_json():
@@ -40,14 +62,14 @@ def test_can_reset():
             "action": 0,
             "status": "ACTIVE",
             "info": {},
-            "observation": {"board": [0] * 42, "mark": 1},
+            "observation": {"remainingOverageTime": 60, "board": [0] * 42, "mark": 1, "step": 0},
             "reward": 0,
         },
         {
             "action": 0,
             "status": "INACTIVE",
             "info": {},
-            "observation": {"mark": 2},
+            "observation": {"remainingOverageTime": 60, "mark": 2},
             "reward": 0,
         },
     ]
@@ -61,8 +83,10 @@ def test_can_mark():
             "status": "INACTIVE",
             "info": {},
             "observation": {
+                "remainingOverageTime": 60,
                 "board": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
                 "mark": 1,
+                "step": 1,
             },
             "reward": 0,
         },
@@ -70,7 +94,7 @@ def test_can_mark():
             "action": 0,
             "status": "ACTIVE",
             "info": {},
-            "observation": {"mark": 2},
+            "observation": {"remainingOverageTime": 60, "mark": 2},
             "reward": 0,
         },
     ]
@@ -84,8 +108,10 @@ def test_can_mark_out_of_bounds():
             "status": "INVALID",
             "info": {},
             "observation": {
+                "remainingOverageTime": 60,
                 "board": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                 "mark": 1,
+                "step": 1,
             },
             "reward": None,
         },
@@ -93,7 +119,7 @@ def test_can_mark_out_of_bounds():
             "action": 0,
             "status": "DONE",
             "info": {},
-            "observation": {"mark": 2},
+            "observation": {"remainingOverageTime": 60, "mark": 2},
             "reward": 0,
         },
     ]
@@ -103,22 +129,21 @@ def test_can_mark_a_full_column():
     board = [1, 2, 0, 0, 0, 1, 2, 0, 0, 0, 1, 2, 0, 0, 0, 1, 2, 0, 0, 0]
     before_each(
         configuration={"rows": 4, "columns": 5, "inarow": 3},
-        state=[{"observation": {"board": board}},
-               {"observation": {}}],
+        state=[{"observation": {"board": board}}, {"observation": {}}],
     )
     assert env.step([1, None]) == [
         {
             "action": 1,
             "status": "INVALID",
             "info": {},
-            "observation": {"board": board, "mark": 1},
+            "observation": {"remainingOverageTime": 60, "board": board, "mark": 1, "step": 1},
             "reward": None,
         },
         {
             "action": 0,
             "status": "DONE",
             "info": {},
-            "observation": {"mark": 2},
+            "observation": {"remainingOverageTime": 60, "mark": 2},
             "reward": 0,
         },
     ]
@@ -130,22 +155,21 @@ def test_can_win():
     board_post_move[0] = 1
     before_each(
         configuration={"rows": 4, "columns": 5, "inarow": 3},
-        state=[{"observation": {"board": board}},
-               {"observation": {}}],
+        state=[{"observation": {"board": board}}, {"observation": {}}],
     )
     assert env.step([0, None]) == [
         {
             "action": 0,
             "status": "DONE",
             "info": {},
-            "observation": {"board": board_post_move, "mark": 1},
+            "observation": {"remainingOverageTime": 60, "board": board_post_move, "mark": 1, "step": 1},
             "reward": 1,
         },
         {
             "action": 0,
             "status": "DONE",
             "info": {},
-            "observation": {"mark": 2},
+            "observation": {"remainingOverageTime": 60, "mark": 2},
             "reward": -1,
         },
     ]
@@ -158,7 +182,7 @@ def test_can_tie():
     board_post_move[1] = 2
     before_each(
         configuration={"rows": 4, "columns": 5, "inarow": 3},
-        state=[{"observation": {"board": board}}, {"observation": {}}],
+        state=[{"observation": {"remainingOverageTime": 60, "board": board}}, {"observation": {}}],
     )
     env.step([0, None])
     assert env.step([None, 1]) == [
@@ -166,14 +190,14 @@ def test_can_tie():
             "action": 0,
             "status": "DONE",
             "info": {},
-            "observation": {"board": board_post_move, "mark": 1},
+            "observation": {"remainingOverageTime": 60, "board": board_post_move, "mark": 1, "step": 2},
             "reward": 0,
         },
         {
             "action": 1,
             "status": "DONE",
             "info": {},
-            "observation": {"mark": 2},
+            "observation": {"remainingOverageTime": 60, "mark": 2},
             "reward": 0,
         },
     ]
@@ -183,9 +207,11 @@ def test_can_render():
     board = [0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 2, 1, 0, 1, 2, 1, 2, 1]
     before_each(
         configuration={"rows": 4, "columns": 5, "inarow": 3},
-        state=[{"observation": {"board": board}}, {"observation": {}}],
+        state=[{"observation": {"remainingOverageTime": 60, "board": board}}, {"observation": {}}],
     )
-    assert env.render(mode="ansi").strip() == """
+    assert (
+        env.render(mode="ansi").strip()
+        == """
 +---+---+---+---+---+
 | 0 | 0 | 0 | 0 | 0 |
 +---+---+---+---+---+
@@ -196,6 +222,7 @@ def test_can_render():
 | 1 | 2 | 1 | 2 | 1 |
 +---+---+---+---+---+
 """.strip()
+    )
 
 
 def test_can_run_agents():
@@ -204,6 +231,7 @@ def test_can_run_agents():
 
     def custom2():
         return 2
+
     before_each(
         configuration={"rows": 4, "columns": 5, "inarow": 3},
     )
@@ -213,14 +241,14 @@ def test_can_run_agents():
             "action": 1,
             "status": "DONE",
             "info": {},
-            "observation": {"board": board, "mark": 1},
+            "observation": {"remainingOverageTime": 60, "board": board, "mark": 1, "step": 5},
             "reward": 1,
         },
         {
             "action": 0,
             "status": "DONE",
             "info": {},
-            "observation": {"mark": 2},
+            "observation": {"remainingOverageTime": 60, "mark": 2},
             "reward": -1,
         },
     ]
@@ -228,5 +256,23 @@ def test_can_run_agents():
 
 def test_can_evaluate():
     rewards = evaluate("connectx", ["random", "random"], num_episodes=2)
-    assert (rewards[0][0] + rewards[0][1] ==
-            0) and rewards[1][0] + rewards[1][1] == 0
+    assert (rewards[0][0] + rewards[0][1] == 0) and rewards[1][0] + rewards[1][1] == 0
+
+
+def test_max_log_length():
+    def custom1():
+        # Write 20X to stdtout, we should strip to 10
+        print("X" * 20)
+        return 1
+
+    def custom2():
+        return 2
+
+    before_each(
+        # here we strip log to length 10
+        configuration={"rows": 4, "columns": 5, "inarow": 3, "maxLogLength": 10},
+    )
+    env.run([custom1, custom2])
+    last_log = env.logs[-1][0]["stdout"]
+    assert env.configuration.maxLogLength == 10, "max log length should be set to 10"
+    assert len(last_log.strip()) == 10, "max log length should be 10 (+ newline, which we stripped)"

kaggle_environments/envs/football/football.ipynb

@@ -0,0 +1,75 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "Kaggle football example",
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "edvwsjsJsAQY",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "## Installing kaggle-environments.\n",
+        "!uv pip install kaggle-environments\n",
+        "\n",
+        "# 4. Import register to define the environment and make to create it.\n",
+        "from kaggle_environments import make, register"
+      ],
+      "execution_count": 0,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "dWXjFxmDsiVb",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "# Installing Google Football environment.\n",
+        "\n",
+        "!apt-get update\n",
+        "!apt-get install -y libsdl2-gfx-dev libsdl2-ttf-dev\n",
+        "\n",
+        "# Make sure that the Branch in git clone and in wget call matches !!\n",
+        "!git clone -b v2.3 https://github.com/google-research/football.git\n",
+        "!mkdir -p football/third_party/gfootball_engine/lib\n",
+        "\n",
+        "!wget https://storage.googleapis.com/gfootball/prebuilt_gameplayfootball_v2.3.so -O football/third_party/gfootball_engine/lib/prebuilt_gameplayfootball.so\n",
+        "!cd football && GFOOTBALL_USE_PREBUILT_SO=1 pip3 install ."
+      ],
+      "execution_count": 0,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "4URn2BRvs3qL",
+        "colab_type": "code",
+        "colab": {}
+      },
+      "source": [
+        "env = make(\"football\", debug=True, configuration={\"scenario_name\": \"11_vs_11_kaggle\", \"team_1\": 1, \"team_2\": 1, \"running_in_notebook\": True, \"save_video\": True})\n",
+        "print(env.name, env.version)\n",
+        "print(\"Default Agents: \", *env.agents)\n",
+        "\n",
+        "env.run([\"run_right\", \"run_left\"])\n",
+        " \n",
+        "env.render(mode=\"html\", width=960, height=720)"
+      ],
+      "execution_count": 0,
+      "outputs": []
+    }
+  ]
+}

kaggle_environments/envs/football/football.json

@@ -0,0 +1,91 @@
+{
+  "name": "football",
+  "agents": [2],
+  "configuration": {
+    "episodeSteps": 3002,
+    "agentTimeout": {
+      "description": "Obsolete field kept for backwards compatibility, please use observation.remainingOverageTime.",
+      "type": "number",
+      "minimum": 0,
+      "default": 60
+    },
+    "actTimeout": 0.5,
+    "runTimeout": 12000,
+    "scenario_name": {
+      "description": "Name of the scenario: for example 11_vs_11_kaggle. Look inside https://github.com/google-research/football/tree/master/gfootball/scenarios.",
+      "type": "string",
+      "default": "11_vs_11_kaggle"
+    },
+    "id": {
+      "description": "Id of this environment run, a random uuid.",
+      "type": "string",
+      "default": null
+    },
+    "team_1": {
+      "description": "Number of players from the first team that agent controls.",
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 11,
+      "default": 1
+    },
+    "team_2": {
+      "description": "Number of players that other agent controls. If set to 0 - the second agent will always have to return 0 as action.",
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 11,
+      "default": 1
+    },
+    "render": {
+      "description": "If true - renders the game on the screen. This option will work on your local computer, but is not supported in colabs/notebooks.",
+      "type": "boolean",
+      "default": false
+    },
+    "save_video": {
+      "description": "If true, will record the video of the playthrough.",
+      "type": "boolean",
+      "default": false
+    },
+    "logdir": {
+      "description": "Directory to write the state dump and video information.",
+      "type": "string",
+      "default": "/tmp/football"
+    },
+    "running_in_notebook": {
+      "description": "Set to true, if you're creating this environment inside Kaggle/Colab notebook.",
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "reward": {
+    "description": "1.0 for scored goal, -1.0 for lost goal (it is given only when the goal is scored, and changes back to 0 afterwards)",
+    "type": "number"
+  },
+  "info": {
+    "debug_info": {
+      "description": "Human readable information passed from the system.",
+      "type": "string"
+    }
+  },
+  "observation": {
+    "players_raw": {
+      "description": "Array of raw observations, one entry per each player that your agent controls. See https://github.com/google-research/football/blob/master/gfootball/doc/observation.md for detailed description. WARNING: your players will always look like they are 'playing from left to right' (to make training easier).",
+      "type": "array"
+    },
+    "controlled_players": {
+      "description": "number of players that agent controls",
+      "type": "number",
+      "minimum": 0,
+      "maximum": 11
+    },
+    "remainingOverageTime": 60
+  },
+  "action": {
+    "description": "An action to execute for each player that agent controls: 0-idle, 1-left, 2-top_left, etc. See https://github.com/google-research/football/blob/master/gfootball/doc/observation.md",
+    "type": "array",
+    "items": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 19
+    }
+  }
+}