kaggle-environments 1.17.12__tar.gz → 1.18.0__tar.gz

{kaggle_environments-1.17.12 → kaggle_environments-1.18.0}/MANIFEST.in

@@ -4,4 +4,6 @@ recursive-include kaggle_environments *.html
 recursive-include kaggle_environments *.js
 recursive-include kaggle_environments *.ts
 global-exclude */node_modules
-recursive-include kaggle_environments *.json
+recursive-include kaggle_environments *.json
+recursive-include kaggle_environments/envs/cabt *.so
+recursive-include kaggle_environments/envs/cabt *.dll

{kaggle_environments-1.17.12/kaggle_environments.egg-info → kaggle_environments-1.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaggle-environments
-Version: 1.17.12
+Version: 1.18.0
 Summary: Kaggle Environments
 Home-page: https://github.com/Kaggle/kaggle-environments
 Author: Kaggle
@@ -37,7 +37,7 @@ Dynamic: summary
 # [<img src="https://kaggle.com/static/images/site-logo.png" height="50" style="margin-bottom:-15px" />](https://kaggle.com) Environments
 
 ```bash
-pip install kaggle-environments
+uv pip install kaggle-environments
 ```
 
 # TLDR;
@@ -320,72 +320,3 @@ The following rendering modes are supported:
 out = env.render(mode="ansi")
 print(out)
 ```
-
-# Command Line
-
-```sh
-> python main.py -h
-```
-
-## List Registered Environments
-
-```sh
-> python main.py list
-```
-
-## Evaluate Episode Rewards
-
-```sh
-python main.py evaluate --environment tictactoe --agents random random --episodes 10
-```
-
-## Run an Episode
-
-```sh
-> python main.py run --environment tictactoe --agents random /pathtomy/agent.py --debug True
-```
-
-## Load an Episode
-
-This is useful when converting an episode json output into html.
-
-```sh
-python main.py load --environment tictactoe --steps [...] --render '{"mode": "html"}'
-```
-
-# HTTP Server
-
-The HTTP server contains the same interface/actions as the CLI above merging both POST body and GET params.
-
-## Setup
-
-```bash
-python main.py http-server --port=8012 --host=0.0.0.0
-```
-
-### Running Agents on Separate Servers
-
-```python
-# How to run agent on a separate server.
-import requests
-import json
-
-path_to_agent1 = "/home/ajeffries/git/playground/agent1.py"
-path_to_agent2 = "/home/ajeffries/git/playground/agent2.py"
-
-agent1_url = f"http://localhost:5001?agents[]={path_to_agent1}"
-agent2_url = f"http://localhost:5002?agents[]={path_to_agent2}"
-
-body = {
-    "action": "run",
-    "environment": "tictactoe",
-    "agents": [agent1_url, agent2_url]
-}
-resp = requests.post(url="http://localhost:5000", data=json.dumps(body)).json()
-
-# Inflate the response replay to visualize.
-from kaggle_environments import make
-env = make("tictactoe", steps=resp["steps"], debug=True)
-env.render(mode="ipython")
-print(resp)
-```

{kaggle_environments-1.17.12 → kaggle_environments-1.18.0}/README.md

@@ -1,7 +1,7 @@
 # [<img src="https://kaggle.com/static/images/site-logo.png" height="50" style="margin-bottom:-15px" />](https://kaggle.com) Environments
 
 ```bash
-pip install kaggle-environments
+uv pip install kaggle-environments
 ```
 
 # TLDR;
@@ -284,72 +284,3 @@ The following rendering modes are supported:
 out = env.render(mode="ansi")
 print(out)
 ```
-
-# Command Line
-
-```sh
-> python main.py -h
-```
-
-## List Registered Environments
-
-```sh
-> python main.py list
-```
-
-## Evaluate Episode Rewards
-
-```sh
-python main.py evaluate --environment tictactoe --agents random random --episodes 10
-```
-
-## Run an Episode
-
-```sh
-> python main.py run --environment tictactoe --agents random /pathtomy/agent.py --debug True
-```
-
-## Load an Episode
-
-This is useful when converting an episode json output into html.
-
-```sh
-python main.py load --environment tictactoe --steps [...] --render '{"mode": "html"}'
-```
-
-# HTTP Server
-
-The HTTP server contains the same interface/actions as the CLI above merging both POST body and GET params.
-
-## Setup
-
-```bash
-python main.py http-server --port=8012 --host=0.0.0.0
-```
-
-### Running Agents on Separate Servers
-
-```python
-# How to run agent on a separate server.
-import requests
-import json
-
-path_to_agent1 = "/home/ajeffries/git/playground/agent1.py"
-path_to_agent2 = "/home/ajeffries/git/playground/agent2.py"
-
-agent1_url = f"http://localhost:5001?agents[]={path_to_agent1}"
-agent2_url = f"http://localhost:5002?agents[]={path_to_agent2}"
-
-body = {
-    "action": "run",
-    "environment": "tictactoe",
-    "agents": [agent1_url, agent2_url]
-}
-resp = requests.post(url="http://localhost:5000", data=json.dumps(body)).json()
-
-# Inflate the response replay to visualize.
-from kaggle_environments import make
-env = make("tictactoe", steps=resp["steps"], debug=True)
-env.render(mode="ipython")
-print(resp)
-```

{kaggle_environments-1.17.12 → kaggle_environments-1.18.0}/kaggle_environments/__init__.py

@@ -20,7 +20,7 @@ from .core import *
 from .main import http_request
 from . import errors
 
-__version__ = "1.17.12"
+__version__ = "1.18.0"
 
 __all__ = ["Agent", "environments", "errors", "evaluate", "http_request",
            "make", "register", "utils", "__version__",

{kaggle_environments-1.17.12 → kaggle_environments-1.18.0}/kaggle_environments/api.py

@@ -1,6 +1,6 @@
 import requests
 
-from typing import *
+from typing import List
 
 base_url = "https://www.kaggle.com/requests/EpisodeService/"
 get_url = base_url + "GetEpisodeReplay"
@@ -8,30 +8,22 @@ list_url = base_url + "ListEpisodes"
 
 
 def get_episode_replay(episode_id: int):
-    body = {
-        "EpisodeId": episode_id
-    }
+    body = {"EpisodeId": episode_id}
 
     response = requests.post(get_url, json=body)
     return response.json()
 
 
 def list_episodes(episode_ids: List[int]):
-    return __list_episodes({
-        "Ids": episode_ids
-    })
+    return __list_episodes({"Ids": episode_ids})
 
 
 def list_episodes_for_team(team_id: int):
-    return __list_episodes({
-        "TeamId": team_id
-    })
+    return __list_episodes({"TeamId": team_id})
 
 
 def list_episodes_for_submission(submission_id: int):
-    return __list_episodes({
-        "SubmissionId": submission_id
-    })
+    return __list_episodes({"SubmissionId": submission_id})
 
 
 def __list_episodes(body):

kaggle_environments-1.18.0/kaggle_environments/envs/cabt/cabt.js

@@ -0,0 +1,164 @@
+
+function renderer(context) {
+  const step = context.step
+  const visList = context.environment.steps[0][0].visualize
+  const energyText = "CGRWLPFDM A"
+
+  const info = context.environment.info
+  const players = [
+    info?.TeamNames?.[0] || "Player 0",
+    info?.TeamNames?.[1] || "Player 1"
+  ]
+
+  let canvas = context.parent.querySelector("canvas")
+  if (!canvas) {
+    container = document.createElement("div")
+    container.style.position = "relative"
+    context.parent.appendChild(container)
+
+    canvas = document.createElement("canvas")
+    canvas.width = 750
+    canvas.height = 700
+    container.appendChild(canvas)
+
+    if (visList) {
+      for (let k = 0; k < 2; k++) {
+        const button = document.createElement("button")
+        button.style.width = "120px"
+        button.style.height = "50px"
+        button.style.left = k == 0 ? "240px" : "380px"
+        button.style.top = "10px"
+        button.style.position = "absolute"
+        button.style.zIndex = 1
+        button.innerHTML = "Open Visualizer<br>" + players[k]
+        button.addEventListener("click", (e) => {
+          for (let i = 0; i < visList.length; i++) {
+            for (let j = 0; j < 2; j++) {
+              visList[i].current.players[j].ramainingTime = context.environment.steps[i][j].observation.remainingOverageTime
+            }
+          }
+          visList[0].ps = players
+
+          const input = document.createElement("input")
+          input.type = "hidden"
+          input.name = "json"
+          input.value = JSON.stringify(visList)
+
+          const form = document.createElement("form")
+          form.method = "POST"
+          form.action = "https://ptcgvis.heroz.jp/Visualizer/Replay/"
+          if (info.EpisodeId == null) {
+            form.action += k
+          } else {
+            form.action += info.EpisodeId + "/" + k
+          }
+          form.target = "_blank"
+          form.appendChild(input)
+
+          document.body.appendChild(form)
+          form.submit()
+        })
+        container.appendChild(button)
+      }
+    } else {
+      const ctx = canvas.getContext("2d")
+      ctx.strokeStyle = "#ccc"
+      ctx.fillStyle = "#fff"
+      ctx.font = "30px sans-serif"
+      ctx.fillText("No visualize data.", 10, 100)
+      const error = context.environment.steps[0][0].error
+      if (error) {
+        ctx.fillText(error, 10, 150)
+      }
+    }
+  }
+
+  if (visList.length <= step) {
+    return
+  }
+  const vis = visList[step]
+  const state = vis.current
+
+  const ctx = canvas.getContext("2d")
+  ctx.clearRect(0, 0, canvas.width, canvas.height)
+
+  ctx.strokeStyle = "#ccc"
+  ctx.fillStyle = "#fff"
+  ctx.lineWidth = 2
+
+  ctx.font = "20px sans-serif"
+  if (state.result >= 0) {
+    if (state.result == 2) {
+      ctx.fillText("Draw", 330, 70)
+    } else {
+      ctx.fillText(players[state.result] + " Win", 310, 120)
+    }
+  }
+
+  ctx.font = "12px sans-serif"
+
+  const drawCard = (x, y, card) => {
+    ctx.beginPath()
+    ctx.rect(x, y, 80, 60)
+    ctx.stroke()
+    nm = card.name
+    nm2 = null
+    if (nm.length >= 13) {
+      for (let i = 0; i < nm.length; i++) {
+        if (nm[i] == " ") {
+          nm2 = nm.substring(i + 1)
+          nm = nm.substring(0, i)
+          break
+        }
+      }
+    }
+    ctx.fillText(nm, x + 5, y + 13)
+    if (nm2 != null) {
+      ctx.fillText(nm2, x + 5, y + 27)
+    }
+  }
+  const drawField = (x, y, card) => {
+    drawCard(x, y, card)
+    ctx.fillText("HP " + card.hp, x + 5, y + 41)
+    energy = ""
+    for (let e of card.energies) {
+      energy = energy + energyText[e]
+    }
+    ctx.fillText(energy, x + 5, y + 55)
+  }
+  const posY = (index, len) => {
+    const center = 290
+    let height
+    if (len <= 8) {
+      height = 35 * len
+    } else {
+      height = 280
+    }
+    return center + height * (2 * index + 1 - len) / len
+  }
+
+  for (let j = 0; j < state.stadium.length; j++) {
+    drawCard(330, 420, state.stadium[j])
+  }
+
+  for (let i = 0; i < 2; i++) {
+    const ps = state.players[i]
+
+    ctx.fillText("Active", i == 0 ? 245 : 425, 270)
+    ctx.fillText("Bench", i == 0 ? 145 : 525, 10)
+    ctx.fillText("Hand", i == 0 ? 15 : 655, 10)
+    ctx.fillText("Deck " + ps.deckCount, i == 0 ? 258 : 438, 150)
+    ctx.fillText("Discard " + ps.discard.length, i == 0 ? 245 : 425, 170)
+    ctx.fillText("Prize " + ps.prize.length, i == 0 ? 258 : 438, 200)
+
+    for (let j = 0; j < ps.active.length; j++) {
+      drawField(i == 0 ? 240 : 420, posY(j, ps.active.length), ps.active[j])
+    }
+    for (let j = 0; j < ps.bench.length; j++) {
+      drawField(i == 0 ? 140 : 520, posY(j, ps.bench.length), ps.bench[j])
+    }
+    for (let j = 0; j < ps.hand.length; j++) {
+      drawCard(i == 0 ? 10 : 650, posY(j, ps.hand.length), ps.hand[j])
+    }
+  }
+}

kaggle_environments-1.18.0/kaggle_environments/envs/cabt/cabt.json

@@ -0,0 +1,28 @@
+{
+  "name": "cabt",
+  "title": "Card Battle",
+  "description": "Limited Card Battle.",
+  "version": "1.0.0",
+  "agents": [2],
+  "configuration": {
+    "episodeSteps": 10000,
+    "actTimeout": 0,
+    "runTimeout": 3000
+  },
+  "reward": {
+    "description": "Lost:-1, Won:1, Draw:0",
+    "enum": [-1, 0, 1],
+    "default": 0
+  },
+  "observation": {
+    "remainingOverageTime": 600
+  },
+  "action": {
+    "description": "List of option index.",
+    "type": "array",
+    "default": []
+  },
+  "status": {
+    "defaults": ["INACTIVE", "INACTIVE"]
+  }
+}

kaggle_environments-1.18.0/kaggle_environments/envs/cabt/cabt.py

@@ -0,0 +1,119 @@
+import random
+import os
+import json
+
+from .cg.sim import Battle
+from .cg.game import battle_start, battle_finish, battle_select, visualize_data
+
+deck = [5,5,5,5,5,5,5,5,5,5,9,9,77,77,77,77,156,156,156,156,157,157,157,157,331,331,331,331,408,408,408,408,474,474,474,474,528,528,528,528,530,530,530,530,532,554,554,554,576,576,576,576,585,585,585,585,630,630,630,630]
+
+def random_agent(obs: dict) -> list[int]:
+    if obs["select"] == None:
+        return deck
+    return random.sample(list(range(len(obs["select"]["option"]))), obs["select"]["maxCount"])
+
+def first_agent(obs: dict) -> list[int]:
+    if obs["select"] == None:
+        return deck
+    return list(range(obs["select"]["maxCount"]))
+
+agents = {"random": random_agent, "first": first_agent}
+
+
+def finish(env):
+    if len(env.steps) > 0:
+        env.steps[0][0]["visualize"] = json.loads(visualize_data())
+    battle_finish()
+
+def interpreter(state, env):
+    if env.done:
+        Battle.battle_ptr = None
+        for i in range(2):
+            state[i].status = "ACTIVE"
+            o = state[i].observation
+            o["select"] = None
+            o["logs"] = []
+            o["current"] = None
+            o["search_begin_input"] = None
+        return state
+    elif Battle.battle_ptr == None:
+        decks = [state[0].action, state[1].action]
+        error = False
+        for i in range(2):
+            if state[i].status == "TIMEOUT" or state[i].status == "ERROR":
+                error = True
+                continue
+            if len(decks[i]) != 60:
+                state[i].status = "INVALID"
+                env.steps[0][0]["error"] = f"Player {i}'s deck does not have 60 cards."
+                error = True
+        if not error:
+            _, start_data = battle_start(state[0].action, state[1].action)
+            if start_data.errorPlayer >= 0:
+                state[start_data.errorPlayer].status = "INVALID"
+                env.steps[0][0]["error"] = f"Player {i}'s deck error."
+                error = True
+        if error:
+            for i in range(2):
+                if state[i].status == "ACTIVE":
+                    state[i].status = "DONE"
+            return state
+        if Battle.battle_ptr == None:
+            raise ValueError("battle_ptr None.")
+    else:
+        error = False
+        select_player = Battle.obs["current"]["yourIndex"]
+        if state[select_player].status == "TIMEOUT" or state[select_player].status == "ERROR":
+            error = True
+        else:
+            try:
+                battle_select(state[select_player].action)
+            except:
+                state[select_player].status = "INVALID"
+                error = True
+
+        if error:
+            state[select_player].reward = -1
+            state[1 - select_player].status = "DONE"
+            state[1 - select_player].reward = 1
+            finish(env)
+            return state
+
+    obs = Battle.obs
+    s = obs["current"]
+    if s["result"] >= 0:
+        state[0].status = "DONE"
+        state[1].status = "DONE"
+        if s["result"] == 0:
+            state[0].reward = 1
+            state[1].reward = -1
+        elif s["result"] == 1:
+            state[0].reward = -1
+            state[1].reward = 1
+        else:
+            state[0].reward = 0
+            state[1].reward = 0
+        finish(env)
+    else:
+        index = s["yourIndex"]
+        state[index].status = "ACTIVE"
+        state[1 - index].status = "INACTIVE"
+        o = state[index].observation
+        o["select"] = obs["select"]
+        o["logs"] = obs["logs"]
+        o["current"] = obs["current"]
+        o["search_begin_input"] = obs["search_begin_input"]
+    return state
+
+def renderer(state, env):
+    return json.dumps(Battle.obs)
+
+def html_renderer():
+    jspath = os.path.abspath(os.path.join(os.path.dirname(__file__), "cabt.js"))
+    with open(jspath, encoding="utf-8") as f:
+        return f.read()
+
+
+jsonpath = os.path.abspath(os.path.join(os.path.dirname(__file__), "cabt.json"))
+with open(jsonpath) as f:
+    specification = json.load(f)

kaggle_environments-1.18.0/kaggle_environments/envs/cabt/cg/game.py

@@ -0,0 +1,70 @@
+import ctypes
+import json
+
+from .sim import StartData, lib, Battle
+
+def _get_battle_data() -> dict:
+    """Retrieve the current state.
+
+    Returns:
+        dict: Current observation.
+    """
+    sd = lib.GetBattleData(Battle.battle_ptr)
+    Battle.obs = json.loads(sd.json.decode())
+    Battle.obs["search_begin_input"] = ctypes.string_at(sd.data, sd.count).decode('ascii')
+    return Battle.obs
+
+def battle_start(deck0: list[int], deck1: list[int]) -> tuple[dict, StartData]:
+    """Start the battle.
+    
+    Args:
+        deck0: List of card IDs included in the first player’s deck.
+        deck1: List of card IDs included in the second player’s deck.
+
+    Returns:
+        tuple: A tuple containing:
+            - dict: First observation.
+            - StartData: Battle start data.
+    """
+    if len(deck0) != 60 or len(deck1) != 60:
+        raise ValueError("The deck must contain 60 cards.")
+    cards = deck0 + deck1
+    arg = (ctypes.c_int*len(cards))(*cards)
+    start_data = lib.BattleStart(arg)
+    Battle.battle_ptr = start_data.battlePtr
+    if Battle.battle_ptr == None or Battle.battle_ptr == 0:
+        return (None, start_data)
+    else:
+        return (_get_battle_data(), start_data)
+
+def battle_finish():
+    """End the battle and free the memory used during it."""
+    lib.BattleFinish(Battle.battle_ptr)
+
+def battle_select(select_list: list[int]) -> dict:
+    """Select option.
+    
+    Args:
+        select_list: 
+
+    Returns:
+        dict: Next observation.
+    """
+    if not isinstance(select_list, list) or not all(isinstance(i, int) for i in select_list):
+        raise ValueError("select_list is not list[int]")
+    arg = (ctypes.c_int*len(select_list))(*select_list)
+    err = lib.Select(Battle.battle_ptr, arg, len(select_list))
+    if err != 0:
+        if err == 30:
+            raise ValueError("battle_ptr broken.")
+        else:
+            raise IndexError()
+    return _get_battle_data()
+
+def visualize_data() -> str:
+    """Retrieve the data to be used by the visualizer.
+
+    Returns:
+        str: The data to be used by the visualizer.
+    """
+    return lib.VisualizeData(Battle.battle_ptr).decode()

kaggle_environments-1.18.0/kaggle_environments/envs/cabt/cg/sim.py

@@ -0,0 +1,44 @@
+import ctypes
+import os
+    
+class StartData(ctypes.Structure):
+    _fields_ = [
+        ("battlePtr", ctypes.c_void_p),
+        ("errorPlayer", ctypes.c_int),
+        ("errorType", ctypes.c_int),
+    ]
+
+class SerialData(ctypes.Structure):
+    _fields_ = [
+        ("json", ctypes.c_char_p),
+        ("data", ctypes.POINTER(ctypes.c_ubyte)),
+        ("count", ctypes.c_int),
+        ("selectPlayer", ctypes.c_int)
+    ]
+
+if os.name == 'nt':
+    lib_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cg.dll")
+else:
+    lib_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "libcg.so")
+lib = ctypes.cdll.LoadLibrary(lib_path)
+
+lib.GameInitialize()
+
+lib.BattleStart.restype = StartData
+lib.BattleStart.argtypes = [ctypes.POINTER(ctypes.c_int)]
+
+lib.BattleFinish.argtypes = [ctypes.c_void_p]
+
+lib.GetBattleData.restype = SerialData
+lib.GetBattleData.argtypes = [ctypes.c_void_p]
+
+lib.Select.restype = ctypes.c_int
+lib.Select.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_int), ctypes.c_int]
+
+lib.VisualizeData.restype = ctypes.c_char_p
+lib.VisualizeData.argtypes = [ctypes.c_void_p]
+
+class Battle:
+    battle_ptr = None
+    obs = None
+    raminingTime = [[], []]