kaggle-environments 1.16.9__py2.py3-none-any.whl → 1.16.10__py2.py3-none-any.whl

kaggle_environments/envs/kore_fleets/starter_bots/java/test/PointTest.java

@@ -0,0 +1,21 @@
+package test;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import kore.Point;
+
+public class PointTest {
+
+    @Test
+    public void fromIndexToIndex_isIdentity() {
+        int idx = 254;
+        int size = 31;
+
+        Point point = Point.fromIndex(idx, size);
+        int mirroredIdx = point.toIndex(size);
+
+        Assert.assertEquals(idx, mirroredIdx);
+    }
+    
+}

kaggle_environments/envs/kore_fleets/starter_bots/java/test/ShipyardTest.java

@@ -0,0 +1,22 @@
+package test;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import kore.Point;
+import kore.Shipyard;
+
+public class ShipyardTest {
+
+    @Test
+    public void maxSpawn_worksCorrectly() {
+        int[] turns = {0, 1, 2, 293, 294, 295};
+        int[] expected = {1, 1, 2, 9, 10, 10};
+        for (int i = 0; i < turns.length; i ++) {
+            Shipyard shipyard = new Shipyard("A", 0, new Point(0, 0), 1, turns[i], null, null);
+
+            Assert.assertEquals(shipyard.maxSpawn(), expected[i]);
+        }
+    }
+    
+}

kaggle_environments/envs/kore_fleets/starter_bots/ts/README.md

@@ -0,0 +1,55 @@
+# Kore Fleets typescript bot
+
+## Requirements
+
+1. node and npm/npx/yarn
+2. typescript installed
+3. python3 installed
+4. kaggle_environments pip package installed
+
+## Getting started
+
+1. `npm install`
+
+## Running Locally
+
+1. transpile your bot with `npm run compile` or `tsc`
+2. run a match with `npm watch4`
+
+* if you don't have google-chrome installed, open the replay.html in the browser of your choice
+* see package.json for more options
+
+## Creating a submission
+
+1. `npm run package`
+2. upload submission.tar.gz to kaggle
+3. profit!
+
+## Running tests
+
+1. `npm test`
+
+## Interpreter and training
+
+A basic TS interpreter has been created in `interpreter.ts`. You can use or modify this file to train machine learning models in JS/TS.
+
+Currently it supports 2 agents and customizable number of episodes. 
+
+It has two modes: `run` and `step`.
+
+`run` mode: After each episode, you can access the complete history of the game. For each turn, you can access the full observation (state) as a Board object, actions performed and the reward obtained after performing the action. This mode is useful for evaluating an agent.
+
+`step` mode: The interpreter initializes new games and allows stepping through the game interactively. You have complete control over the board and the agent during each step. This mode is useful for training machine learning models.
+
+Sample command to run the interpreter can be found in npm scripts as `npm run interpreter:run` and `npm run interpreter:step`.
+
+## Miner bot and Do nothing bot
+
+A sample miner bot `MinerBot.ts` is provided, with Python entrypoint as `miner.py`. It has the same logic as the Python `miner` bot in `kore_fleets.py`.
+
+To run it aginst Python miner bot with TS interpreter for 20 episodes:
+
+1. `npm run compile`
+2. `node --require ts-node/register interpreter.ts 20 ./miner.py miner`
+
+A sample do nothing bot `DoNothingBot.ts` is also provided.

kaggle_environments/envs/llm_20_questions/llm_20_questions.py

@@ -293,7 +293,7 @@ with open(jsonpath) as f:
 
 def html_renderer():
     jspath = path.abspath(path.join(path.dirname(__file__), "llm_20_questions.js"))
-    with open(jspath) as f:
+    with open(jspath, encoding="utf-8") as f:
         return f.read()
 
 

kaggle_environments/envs/lux_ai_2021/README.md

@@ -0,0 +1,3 @@
+# Lux AI Challenge Season 1
+
+Welcome to the Kaggle Environments wrapped around the Lux AI Challenge Season 1! For more information or if you have an issues or want to make contributes, check out the main repository at https://github.com/Lux-AI-Challenge/Lux-Design-2021

kaggle_environments/envs/lux_ai_2021/dimensions/754.js.LICENSE.txt

@@ -0,0 +1,296 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+/*!
+ * accepts
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * body-parser
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * body-parser
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * bytes
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015 Jed Watson
+ * MIT Licensed
+ */
+
+/*!
+ * content-disposition
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * content-type
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * cookie
+ * Copyright(c) 2012-2014 Roman Shtylman
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * depd
+ * Copyright(c) 2014 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * depd
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * depd
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * depd
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * destroy
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
+
+/*!
+ * ee-first
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
+
+/*!
+ * encodeurl
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * escape-html
+ * Copyright(c) 2012-2013 TJ Holowaychuk
+ * Copyright(c) 2015 Andreas Lubbe
+ * Copyright(c) 2015 Tiancheng "Timothy" Gu
+ * MIT Licensed
+ */
+
+/*!
+ * etag
+ * Copyright(c) 2014-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * express
+ * Copyright(c) 2009-2013 TJ Holowaychuk
+ * Copyright(c) 2013 Roman Shtylman
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * express
+ * Copyright(c) 2009-2013 TJ Holowaychuk
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * finalhandler
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * forwarded
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * fresh
+ * Copyright(c) 2012 TJ Holowaychuk
+ * Copyright(c) 2016-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * http-errors
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * media-typer
+ * Copyright(c) 2014 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * merge-descriptors
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * methods
+ * Copyright(c) 2013-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * negotiator
+ * Copyright(c) 2012 Federico Romero
+ * Copyright(c) 2012-2014 Isaac Z. Schlueter
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * on-finished
+ * Copyright(c) 2013 Jonathan Ong
+ * Copyright(c) 2014 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * parseurl
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * proxy-addr
+ * Copyright(c) 2014-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * raw-body
+ * Copyright(c) 2013-2014 Jonathan Ong
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * send
+ * Copyright(c) 2012 TJ Holowaychuk
+ * Copyright(c) 2014-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * serve-static
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * Copyright(c) 2014-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * statuses
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * toidentifier
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * type-is
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * unpipe
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * vary
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/**
+ * @license Complex.js v2.0.13 12/05/2020
+ *
+ * Copyright (c) 2020, Robert Eisele (robert@xarg.org)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ **/
+
+/**
+ * @license Fraction.js v4.1.1 23/05/2021
+ * https://www.xarg.org/2014/03/rational-numbers-in-javascript/
+ *
+ * Copyright (c) 2021, Robert Eisele (robert@xarg.org)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ **/

kaggle_environments/envs/lux_ai_2021/testing.md

@@ -0,0 +1,23 @@
+Unfortunately at this moment, there isn't a progammatic way to test if the Kaggle Engine is the exact same as the engine competitors use when local testing. This is part of a TODO to make kaggle replays match the local replays players generate when they develop locally using https://github.com/Lux-AI-Challenge/Lux-Design-2021
+
+The following steps work for now:
+
+First download the simple kit from https://github.com/Lux-AI-Challenge/Lux-Design-2021/tree/master/kits/python (or another language) or use your own bot
+
+First run a game in Kaggle like so:
+
+```
+kaggle-environments run --environment lux_ai_2021 --agents path/to/bot/main.py path/to/bot/main.py --render '{"mode": "json"}' --out out.json --debug=True
+```
+
+Then upload the out.json to https://2021vis.lux-ai.org/ and go to the final turn.
+
+Then install the local engine `npm i -g install @lux-ai/2021-challenge` if you haven't done so already (you can remove `-g` and do `npx lux-ai-2021` as opposed to `lux-ai-2021`)
+
+Then run
+
+```
+lux-ai-2021 path/to/bot/main.py path/to/bot/main.py --out=replay.json
+```
+
+upload `replay.json` to the replay viewer again in a new tab and compare the final state with the other kaggle produced match. If the statistics and layout of units on the map match, then the engine is working correctly. (Given the complexity of the game and that `lux-ai-2021` generates action based replays, should a single thing be wrong, the differences in the final turn would be fairly massive so this is generally a sufficient test)

kaggle_environments/envs/lux_ai_2021/todo.md.og

@@ -0,0 +1,18 @@
+# TODOs
+
+
+[x] Setup Visualizer
+
+[x] Keep dimensions engine results consistent with kaggle-env integated version
+
+[ ] Verify rewards work correctly
+
+[ ] display correct agent names
+
+[ ] default turn debug mode off
+
+[ ] add tests for more bots
+
+[ ] allow user to pass in custom configurations
+
+[ ] allow user to specify debug mode level for the dimensions engine

kaggle_environments/envs/lux_ai_s2/.gitignore

@@ -0,0 +1 @@
+build/

kaggle_environments/envs/lux_ai_s2/README.md

@@ -0,0 +1,21 @@
+# Lux AI Challenge Season 2
+
+Welcome to the Kaggle Environments wrapped around the Lux AI Challenge Season 2! For more information or if you have an issues or want to make contributes, check out the main repository at https://github.com/Lux-AI-Challenge/Lux-Design-2022
+
+## Test scripts
+
+```
+kaggle-environments run --environment lux_ai_2022 --agents path/to/bot/main.py path/to/bot/main.py --render '{"mode": "json"}' --out out.json --debug=True
+```
+
+```
+kaggle-environments run --environment lux_ai_2022 --agents ../Lux-Design-2022/kits/js/main.py ../Lux-Design-2022/kits/js/main.py --render '{"mode": "json"}' --out out.json --debug=True
+```
+
+## Packaging external packages locally
+
+git clone open_simplex and petting zoo directly and move them into here
+
+## Visualizer
+
+Ensure that the script module is at the bottom of <body> tag.

kaggle_environments/envs/lux_ai_s3/README.md

@@ -0,0 +1,21 @@
+# Lux AI Challenge Season 3
+
+Welcome to the Kaggle Environments wrapped around the Lux AI Challenge Season 3! For more information or if you have an issues or want to make contributes, check out the main repository at https://github.com/Lux-AI-Challenge/Lux-Design-S3
+
+## Test scripts
+
+```
+kaggle-environments run --environment lux_ai_s3 --agents path/to/bot/main.py path/to/bot/main.py --render '{"mode": "json"}' --out out.json --debug=True
+```
+
+```
+kaggle-environments run --environment lux_ai_s3 --agents ../LuxAI/Lux-Design-S3/kits/python/main.py ../LuxAI/Lux-Design-S3/kits/python/main.py --render '{"mode": "json"}' --out out.json --debug=True
+```
+<!-- 
+## Packaging external packages locally
+
+git clone open_simplex and petting zoo directly and move them into here -->
+
+## Visualizer
+
+Ensure that the script module is at the bottom of <body> tag.

kaggle_environments/envs/lux_ai_s3/lux_ai_s3.json

@@ -11,7 +11,7 @@
       "type": "integer"
     },
     "actTimeout": 3,
-    "runTimeout": 60,
+    "runTimeout": 1600,
     "env_cfg": {
       "description": "Environment configuration. Not to be filled out by user as it is randomly generated.",
       "type": "object"

kaggle_environments/envs/lux_ai_s3/luxai_s3/env.py

@@ -40,23 +40,27 @@ class LuxAIS3Env(environment.Environment):
         params = jax.tree_map(jax.numpy.array, params)
         return params
 
-    def compute_unit_counts_map(self, state: EnvState, params: EnvParams):
+    def compute_unit_counts_map(self, state: EnvState, params: EnvParams, exclude_negative_energy_units: bool = False):
         # map of total units per team on each tile, shape (num_teams, map_width, map_height)
         unit_counts_map = jnp.zeros(
             (self.fixed_env_params.num_teams, self.fixed_env_params.map_width, self.fixed_env_params.map_height), dtype=jnp.int16
         )
 
-        def update_unit_counts_map(unit_position, unit_mask, unit_counts_map):
+        def update_unit_counts_map(unit_position, unit_mask, unit_energy_nonnegative, unit_counts_map):
+            if exclude_negative_energy_units:
+                mask = unit_mask & unit_energy_nonnegative
+            else:
+                mask = unit_mask
             unit_counts_map = unit_counts_map.at[
                 unit_position[0], unit_position[1]
-            ].add(unit_mask.astype(jnp.int16))
+            ].add(mask.astype(jnp.int16))
             return unit_counts_map
 
         for t in range(self.fixed_env_params.num_teams):
             unit_counts_map = unit_counts_map.at[t].add(
                 jnp.sum(
-                    jax.vmap(update_unit_counts_map, in_axes=(0, 0, None), out_axes=0)(
-                        state.units.position[t], state.units_mask[t], unit_counts_map[t]
+                    jax.vmap(update_unit_counts_map, in_axes=(0, 0, 0, None), out_axes=0)(
+                        state.units.position[t], state.units_mask[t], state.units.energy[t, :, 0] >= 0, unit_counts_map[t]
                     ),
                     axis=0,
                     dtype=jnp.int16
@@ -378,7 +382,7 @@ class LuxAIS3Env(environment.Environment):
                             & (other_units_adjacent_sapped_count[:, :, None] > 0),
                             all_units.energy[other_team_ids]
                             - jnp.array(
-                                params.unit_sap_cost.astype(jnp.float32)
+                                jnp.array(params.unit_sap_cost, dtype=jnp.float32)
                                 * params.unit_sap_dropoff_factor
                                 * other_units_adjacent_sapped_count[:, :, None].astype(jnp.float32),
                                 dtype=jnp.int16,
@@ -667,7 +671,10 @@ class LuxAIS3Env(environment.Environment):
         new_energy_nodes = jnp.clip(
             state.energy_nodes + energy_node_deltas,
             min=jnp.array([0, 0], dtype=jnp.int16),
-            max=jnp.array([self.fixed_env_params.map_width, self.fixed_env_params.map_height], dtype=jnp.int16),
+            max=jnp.array(
+                [self.fixed_env_params.map_width - 1, self.fixed_env_params.map_height - 1],
+                dtype=jnp.int16
+            ),
         )
         new_energy_nodes = jnp.where(
             state.steps * params.energy_node_drift_speed % 1 == 0,
@@ -686,7 +693,7 @@ class LuxAIS3Env(environment.Environment):
 
         # note we need to recompue unit counts since units can get removed due to collisions
         team_scores = jax.vmap(team_relic_score)(
-            self.compute_unit_counts_map(state, params)
+            self.compute_unit_counts_map(state, params, exclude_negative_energy_units=True)
         )
         # Update team points
         state = state.replace(team_points=state.team_points + team_scores)

kaggle_environments/envs/lux_ai_s3/luxai_s3/pygame_render.py

@@ -90,35 +90,12 @@ class LuxAIPygameRenderer:
             surface.blit(shape_surf, rect)
 
         if self.display_options["show_relic_spots"]:
-            for i in range(params.max_relic_nodes):
-                if state.relic_nodes_mask[i]:
-                    x, y = state.relic_nodes[i, :2]
-                    config_size = params.relic_config_size
-                    half_size = config_size // 2
-                    for dx in range(-half_size, half_size + 1):
-                        for dy in range(-half_size, half_size + 1):
-                            config_x = x + dx
-                            config_y = y + dy
-
-                            if (
-                                0 <= config_x < params.map_width
-                                and 0 <= config_y < params.map_height
-                            ):
-
-                                config_value = state.relic_node_configs[
-                                    i, dy + half_size, dx + half_size
-                                ]
-
-                                if config_value > 0:
-                                    rect = pygame.Rect(
-                                        config_x * TILE_SIZE,
-                                        config_y * TILE_SIZE,
-                                        TILE_SIZE,
-                                        TILE_SIZE,
-                                    )
-                                    draw_rect_alpha(
-                                        self.surface, (255, 215, 0, 50), rect
-                                    )  # Semi-transparent gold
+            mask = state.relic_nodes_map_weights
+            for x in range(params.map_width):
+                for y in range(params.map_height):
+                    if mask[x, y] > 0:
+                        rect = pygame.Rect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)
+                        draw_rect_alpha(self.surface, (255, 215, 0, 50), rect)
 
         # Draw energy nodes
         for i in range(params.max_energy_nodes):

kaggle_environments/envs/lux_ai_s3/luxai_s3/wrappers.py

@@ -23,23 +23,6 @@ class LuxAIS3GymEnv(gym.Env):
         self.jax_env = LuxAIS3Env(auto_reset=False)
         self.env_params: EnvParams = EnvParams()
 
-        # auto run compiling steps here:
-        # print("Running compilation steps")
-        key = jax.random.key(0)
-        # Reset the environment
-        dummy_env_params = EnvParams(map_type=1)
-        key, reset_key = jax.random.split(key)
-        obs, state = self.jax_env.reset(reset_key, params=dummy_env_params)
-        # Take a random action
-        key, subkey = jax.random.split(key)
-        action = self.jax_env.action_space(dummy_env_params).sample(subkey)
-        # Step the environment and compile. Not sure why 2 steps? are needed
-        for _ in range(2):
-            key, subkey = jax.random.split(key)
-            obs, state, reward, terminated, truncated, info = self.jax_env.step(
-                subkey, state, action, params=dummy_env_params
-            )
-        # print("Finish compilation steps")
         low = np.zeros((self.env_params.max_units, 3))
         low[:, 1:] = -self.env_params.unit_sap_range
         high = np.ones((self.env_params.max_units, 3)) * 6