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

kaggle_environments/envs/battlegeese/battlegeese.py

@@ -1,223 +0,0 @@
-# Copyright 2020 Kaggle Inc
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import json
-from os import path
-from random import choice, sample
-
-
-def get_pos(from_pos, direction, columns, rows):
-    if direction == "N":
-        if from_pos - columns < 0:
-            return -1
-        return from_pos - columns
-    if direction == "S":
-        if from_pos + columns >= columns * rows:
-            return -1
-        return from_pos + columns
-    if direction == "E":
-        if from_pos // columns != (from_pos + 1) // columns:
-            return -1
-        return from_pos + 1
-    if direction == "W":
-        if from_pos // columns != (from_pos - 1) // columns:
-            return -1
-        return from_pos - 1
-
-
-def min_distance(pos, food, config):
-    cols = config.columns
-    return min([abs(pos % cols - fpos % cols) + abs(pos // cols - fpos // cols) for fpos in food])
-
-
-def random_agent():
-    return choice(["N", "S", "E", "W"])
-
-
-def shortest_path_agent(obs, config):
-    columns = config.columns
-    rows = config.rows
-    goose = obs.geese[obs.index]
-    head = goose[0]
-    max_value = columns * rows
-    directions = ["N", "S", "E", "W"]
-
-    geese = [g for g in obs.geese if len(g) > 0]
-    heads = [g[0] for g in geese]
-    tails = [g[-1] for g in geese]
-    bodies = [p for g in geese for p in g[:-1]]
-
-    actions = {}
-    for d in directions:
-        # Get new position - or -1 if run into wall.
-        pos = get_pos(head, d, columns, rows)
-        if (
-            pos in bodies or  # Hit a body.
-            (len(goose) > 1 and goose[1] == pos) or  # Backwards.
-            # Hit a tail when head over food.
-            (pos in tails and heads[tails.index(pos)] in obs.food)
-        ):
-            pos = -1
-        actions[d] = max_value if pos == - \
-            1 else min_distance(pos, obs.food, config)
-        # Possibility of a collision, devalue a valid action.
-        for h in heads:
-            if h == head:
-                continue
-            for dh in directions:
-                posh = get_pos(h, dh, columns, rows)
-                if posh == pos:
-                    actions[d] += 1
-
-    return min(actions, key=actions.get)
-
-
-agents = {"random": random_agent, "shortest": shortest_path_agent}
-
-
-def interpreter(state, env):
-    config = env.configuration
-    columns = config.columns
-    rows = config.rows
-    hunger_rate = config.hunger_rate
-    min_food = config.min_food
-    num_agents = len(state)
-
-    # Clone the geese and food observation between all the agents.
-    geese = state[0].observation.geese
-    food = state[0].observation.food
-    for agent in state:
-        agent.observation.geese = geese
-        agent.observation.food = food
-
-    # Reset the environment.
-    if env.done:
-        # Distribute food and geese randomly.
-        starting_positions = sample(range(columns * rows), num_agents * 2)
-        for index in range(num_agents):
-            geese.append([starting_positions[index]])
-            food.append(starting_positions[index + num_agents])
-        return state
-
-    # Update active agents rewards.
-    for index, agent in enumerate(state):
-        if agent.status == "ACTIVE":
-            agent.reward = len(env.steps) + len(geese[index])
-
-    # Apply the actions from active agents.
-    for index, agent in enumerate(state):
-        if agent.status != "ACTIVE":
-            continue
-        action = agent.action
-        goose = geese[index]
-        head = goose[0]
-        new_head = get_pos(head, action, columns, rows)
-
-        # Wall Hit.
-        if new_head == -1:
-            env.debug_print(f"Wall Hit: {action}")
-            agent.status = "INACTIVE"
-            geese[index] = []
-            continue
-
-        # Last Body Hit.
-        if len(goose) > 1 and goose[1] == new_head:
-            env.debug_print(f"Body Hit: {action}")
-            agent.status = "INACTIVE"
-            geese[index] = []
-            continue
-
-        # Add New Head to the Goose.
-        goose.insert(0, new_head)
-
-        # Check Food.
-        if head in food:
-            food.remove(head)
-        else:
-            goose.pop()
-
-        # If hunger strikes remove from the tail.
-        if len(env.steps) % hunger_rate == 0:
-            goose.pop()
-            if len(goose) == 0:
-                env.debug_print(f"Goose Starved: {action}")
-                agent.status = "INACTIVE"
-                geese[index] = []
-                continue
-
-    # Check for collisions.
-    collisions = {}
-    for goose in geese:
-        for pos in goose:
-            collisions[pos] = collisions.get(pos, 0) + 1
-    for index, agent in enumerate(state):
-        for pos in geese[index]:
-            if collisions[pos] > 1:
-                env.debug_print(f"Goose Collision: {agent.action}")
-                agent.status = "INACTIVE"
-                geese[index] = []
-                continue
-
-    # Add food if min_food threshold reached.
-    if len(food) < min_food:
-        available_positions = list(range(rows * columns))
-        for goose in geese:
-            for pos in goose:
-                available_positions.remove(pos)
-        food.extend(sample(available_positions, min_food - len(food)))
-
-    # If only one ACTIVE agent left, set it to INACTIVE.
-    active_agents = [a for a in state if a.status == "ACTIVE"]
-    if len(active_agents) == 1:
-        active_agents[0].status = "INACTIVE"
-
-    return state
-
-
-def renderer(state, env):
-    config = env.configuration
-    columns = config.columns
-    rows = config.rows
-
-    foodSymbol = "F"
-    colDivider = "|"
-    rowDivider = "+" + "+".join(["---"] * columns) + "+\n"
-
-    board = [" "] * (rows * columns)
-    for pos in state[0].observation.food:
-        board[pos] = foodSymbol
-
-    for index, goose in enumerate(state[0].observation.geese):
-        for pos in goose:
-            board[pos] = index
-
-    out = rowDivider
-    for row in range(rows):
-        for col in range(columns):
-            out += colDivider + f" {board[(row * columns) + col]} "
-        out += colDivider + "\n" + rowDivider
-
-    return out
-
-
-dirpath = path.dirname(__file__)
-jsonpath = path.abspath(path.join(dirpath, "battlegeese.json"))
-with open(jsonpath) as f:
-    specification = json.load(f)
-
-
-def html_renderer():
-    jspath = path.abspath(path.join(dirpath, "battlegeese.js"))
-    with open(jspath) as f:
-        return f.read()

kaggle_environments/temp.py

@@ -1,14 +0,0 @@
-import time
-
-
-def request(req):
-    print("request")
-    time.sleep(2)
-    req.agents = ["negamax", "random"]
-    return req
-
-
-def response(req, resp):
-    print("response")
-    time.sleep(2)
-    return resp

kaggle_environments-0.2.1.dist-info/METADATA

@@ -1,393 +0,0 @@
-Metadata-Version: 2.1
-Name: kaggle-environments
-Version: 0.2.1
-Summary: Kaggle Environments
-Home-page: https://github.com/Kaggle/kaggle-environments
-Author: Kaggle
-Author-email: support@kaggle.com
-License: Apache 2.0
-Keywords: Kaggle
-Platform: UNKNOWN
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: jsonschema (>=3.0.1)
-
-# [<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
-```
-
-# TLDR;
-
-```python
-from kaggle_environments import make
-
-# Setup a tictactoe environment.
-env = make("tictactoe")
-
-# Basic agent which marks the first available cell.
-def my_agent(obs):
-  return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]
-
-# Run the basic agent against a default agent which chooses a "random" move.
-env.run([my_agent, "random"])
-
-# Render an html ipython replay of the tictactoe game.
-env.render(mode="ipython")
-```
-
-# Overview
-
-Kaggle Environments was created to evaluate episodes. While other libraries have set interface precedents (such as Open.ai Gym), the emphasis of this library focuses on:
-
-1. Episode evaluation (compared to training agents).
-2. Configurable environment/agent lifecycles.
-3. Simplified agent and environment creation.
-4. Cross language compatible/transpilable syntax/interfaces.
-
-## Help Documentation
-
-```python
-# Additional documentation (especially interfaces) can be found on all public functions:
-from kaggle_environments import make
-help(make)
-env = make("tictactoe")
-dir(env)
-help(env.reset)
-```
-
-# Agents
-
-> A function which given an observation generates an action.
-
-## Writing
-
-Agent functions can have observation and configuration parameters and must return a valid action. Details about the observation, configuration, and actions can seen by viewing the specification.
-
-```python
-from kaggle_simulations import make
-env = make("connectx", {rows: 10, columns: 8, inarow: 5})
-
-def agent(observation, configration):
-  print(observation) # {board: [...], mark: 1}
-  print(configuration) # {rows: 10, columns: 8, inarow: 5}
-  return 3 # Action: always place a mark in the 3rd column.
-
-# Run an episode using the agent above vs the default random agent.
-env.run([agent, "random"])
-
-# Print schemas from the specification.
-print(env.specification.observation)
-print(env.specification.configuration)
-print(env.specification.action)
-```
-
-## Loading Agents
-
-Agents are always functions, however there are some shorthand syntax options to make generating/using them easier.
-
-```python
-# Agent def accepting an observation and returning an action.
-def agent1(obs):
-  return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]
-
-# Load a default agent called "random".
-agent2 = "random"
-
-# Load an agent from source.
-agent3 = """
-def act(obs):
-  return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]
-"""
-
-# Load an agent from a file.
-agent4 = "C:\path\file.py"
-
-# Return a fixed action.
-agent5 = 3
-
-# Return an action from a url.
-agent6 = "http://localhost:8000/run/agent"
-```
-
-## Default Agents
-
-Most environments contain default agents to play against. To see the list of available agents for a specific environment run:
-
-```python
-from kaggle_simulations import make
-env = make("tictactoe")
-
-# The list of available default agents.
-print(*env.agents)
-
-# Run random agent vs reaction agent.
-env.run(["random", "reaction"])
-```
-
-## Training
-
-Open AI Gym interface is used to assist with training agents. The `None` keyword is used below to denote which agent to train (i.e. train as first or second player of connectx).
-
-```python
-from kaggle_environments import make
-
-env = make("connectx", debug=True)
-
-# Training agent in first position (player 1) against the default random agent.
-trainer = env.train([None, "random"])
-
-obs = trainer.reset()
-for _ in range(100):
-    env.render()
-    action = 0 # Action for the agent being trained.
-    obs, reward, done, info = trainer.step(action)
-    if done:
-        obs = trainer.reset()
-```
-
-## Debugging
-
-There are 3 types of errors which can occur from agent execution:
-
-1. **Timeout** - the agent runtime exceeded the allowed limit. There are 2 timeouts:
-   1. `agentTimeout` - Used for initialization of an agent on first "act".
-   2. `actTimeout` - Used for obtaining an action.
-2. **Error** - the agent raised and error during execution.
-3. **Invalid** - the agent action response didn't match the action specification or the environment deemed it invalid (i.e. playing twice in the same cell in tictactoe).
-
-To help debug your agent and why it threw the errors above, add the `debug` flag when setting up the environment.
-
-```python
-from kaggle_simulations import make
-
-def agent():
-  return "Something Bad"
-
-env = make("tictactoe", debug=True)
-
-env.run([agent, "random"])
-# Prints: "Invalid Action: Something Bad"
-```
-
-# Environments
-
-> A function which given a state and agent actions generates a new state.
-
-| Name      | Description                          | Make                      |
-| --------- | ------------------------------------ | ------------------------- |
-| connectx  | Connect 4 in a row but configurable. | `env = make("connectx")`  |
-| tictactoe | Classic Tic Tac Toe                  | `env = make("tictactoe")` |
-| identity  | For debugging, action is the reward. | `env = make("identity")`  |
-
-## Making
-
-An environment instance can be made from an existing specification (such as those listed above).
-
-```python
-from kaggle_environments import make
-
-# Create an environment instance.
-env = make(
-  # Specification or name to registered specification.
-  "connectx",
-
-  # Override default and environment configuration.
-  configuration={"rows": 9, "columns": 10},
-
-  # Initialize the environment from a prior state (episode resume).
-  steps=[],
-
-  # Enable verbose logging.
-  debug=True
-)
-```
-
-## Configuration
-
-There are two types of configuration: Defaults applying to every environment and those specific to the environment. The following is a list of the default configuration:
-
-| Name         | Description                                                     |
-| ------------ | --------------------------------------------------------------- |
-| episodeSteps | Maximum number of steps in the episode.                         |
-| agentExec    | How the agent is executed alongside the envionment.             |
-| agentTimeout | Maximum runtime (seconds) to initialize an agent.               |
-| actTimeout   | Maximum runtime (seconds) to obtain an action from an agent.    |
-| runTimeout   | Maximum runtime (seconds) of an episode (not necessarily DONE). |
-
-```python
-env = make("connectx", configuration={
-  "columns": 19, # Specific to ConnectX.
-  "actTimeout": 10,
-  "agentExec": "LOCAL"
-})
-```
-
-## Resetting
-
-Environments are reset by default after "make" (unless starting steps are passed in) as well as when calling "run". Reset can be called at anytime to clear the environment.
-
-```python
-num_agents = 2
-reset_state = env.reset(num_agents)
-```
-
-## Running
-
-Execute an episode against the environment using the passed in agents until they are no longer running (i.e. status != ACTIVE).
-
-```python
-steps = env.run([agent1, agent2])
-print(steps)
-```
-
-## Evaluating
-
-Evaluation is used to run an episode (environment + agents) multiple times and just return the rewards.
-
-```python
-from kaggle_simulations import evaluate
-
-# Same definitions as "make" above.
-envrionment = "connectx"
-configuration = {rows: 10, columns: 8, inarow: 5}
-steps = []
-debug = False
-
-# Which agents to run repeatedly.  Same as env.run(agents)
-agents = ["random", agent1]
-
-# How many times to run them.
-num_episodes = 10
-
-rewards = evaluate(environment, agents, configuration, steps, num_episodes, debug)
-```
-
-## Stepping
-
-Running above essentially just steps until no agent is still active. To execute a singular game loop, pass in actions directly for each agent. Note that this is normally used for training agents (most useful in a single agent setup such as using the gym interface).
-
-```python
-agent1_action = agent1(env.state[0].observation)
-agent2_action = agent2(env.state[1].observation)
-state = env.step(agent1_action, agent2_action)
-```
-
-## Playing
-
-A few environments offer an interactive play against agents within jupyter notebooks. An example of this is using connectx:
-
-```python
-from kaggle_simulations import make
-
-env = make("connectx")
-# None indicates which agent will be manually played.
-env.play([None, "random"])
-```
-
-## Rendering
-
-The following rendering modes are supported:
-
-- json - Same as doing a json dump of `env.toJSON()`
-- ansi - Ascii character representation of the environment.
-- human - ansi just printed to stdout
-- html - HTML player representation of the environment.
-- ipython - html just printed to the output of a ipython notebook.
-
-```python
-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
-```
-
-## Adding Middleware
-
-```python
-# middleware.py
-import time
-
-def request(req):
-    time.sleep(30)
-    req.agents = ["random", "random"]
-    return req
-
-def response(req, resp):
-    time.sleep(10)
-    return resp
-```
-
-```bash
-python3 main.py http-server --middleware=/path/to/middleware.py
-```
-
-### 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-0.2.1.dist-info/RECORD

@@ -1,32 +0,0 @@
-kaggle_environments/__init__.py,sha256=MFh91QZuhBPHN7F2heuRQUihrei4oxptbOpGJqg0NwA,1329
-kaggle_environments/agent.py,sha256=Me52NjPueXq4e8dFcdiLlACRnJX5ppDOoOr1Ec2yTSs,5139
-kaggle_environments/core.py,sha256=-UTM7CgyPX1GGI5bgcqBpm68l88d3ZPyDh3jMy0IbDM,22863
-kaggle_environments/errors.py,sha256=gKgOb2_JcOuBMLw3Ol_NZ4arlsvzBm3xV9fqZN3jeeY,3336
-kaggle_environments/schemas.json,sha256=YSHnIhrJ60GjWLminloebVsxQXXINm_Z3Nbew7Wkusc,3070
-kaggle_environments/status_codes.json,sha256=6a8HuS_Vth95W0f2fov21QLdRfA3KbizUvjKmJhYtBc,995
-kaggle_environments/temp.py,sha256=65fHiopG3pvFMhzh2xukJFqj-1O949m_2LrMow5kFng,208
-kaggle_environments/utils.py,sha256=wfeJ4ZZNSA4bOLI0nR383yrcvp2bGvtQPsTfU5jbp5E,6307
-kaggle_environments/envs/battlegeese/battlegeese.js,sha256=ZiuDhbn7EXVfrN-rMl3u5TFw9EdujezAVv21ASS5lYc,35551
-kaggle_environments/envs/battlegeese/battlegeese.json,sha256=4NAvQMp6jtNsF5oIh084w0gohI31E8jCqNBjBcNfOog,2087
-kaggle_environments/envs/battlegeese/battlegeese.py,sha256=4Ot8AOiXz_MdcvE8x6p6OFr7aPY3cyPx8aQE_d9mNzI,6825
-kaggle_environments/envs/connectx/connectx.js,sha256=u3zaqpiBfnAaC-fiT3hrNABXRIVTc4mKS3qOjCgNvvc,9227
-kaggle_environments/envs/connectx/connectx.json,sha256=mdOj-ED1ld3iIcmK3uAs00xFMbxTdGnHkNhyB1XoJUI,1309
-kaggle_environments/envs/connectx/connectx.py,sha256=PeQsALGBUJrUnCvYmc6AE8nIdFFKM5GHs24RrL0-xAU,6928
-kaggle_environments/envs/connectx/test_connectx.py,sha256=WzXjuzEUXPRlOd5m_DxpaEqbMZNimjBNOJGsYDYEjHM,6267
-kaggle_environments/envs/halite/halite.js,sha256=VQdl4Llro4Mp0bWQwIb6Aj887Yuou9nW1qSfqK136ek,14672
-kaggle_environments/envs/halite/halite.json,sha256=Pd2WPtmEpS7UMYVI-FtIddHrDPTFV9L1R603ViXowaA,3795
-kaggle_environments/envs/halite/halite.py,sha256=GtXAV0le5uSaWSh7LqVlROoL8qJqVba6wcUUuOY46sg,15943
-kaggle_environments/envs/halite/test_halite.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kaggle_environments/envs/identity/identity.json,sha256=l5M7GnhhEyeOphXU0nS5VoZuIOrzrL9H6rz3lsR3fFk,947
-kaggle_environments/envs/identity/identity.py,sha256=SEeei1cDG-brC29cLwlOPWYFTWUzmr7uVWLQsqPuiR4,1829
-kaggle_environments/envs/tictactoe/test_tictactoe.py,sha256=PMd6lT1ETNgf4f23teZ6QJ2mJpH9kL1nKyiE8lH-3i8,7770
-kaggle_environments/envs/tictactoe/tictactoe.js,sha256=NZDT-oSG0a6a-rso9Ldh9qkJwVrxrAsjKUC3_tJu3tw,8002
-kaggle_environments/envs/tictactoe/tictactoe.json,sha256=7OAnLZuLfGzQJa_ZWomAh151KS0qwax4XtU6lFQc0rA,859
-kaggle_environments/envs/tictactoe/tictactoe.py,sha256=iLNU5V-lz7Xab-d1vpPMfU5jDM3QtgBUH63Y_SU7I9Y,3639
-kaggle_environments/static/player.html,sha256=Hs_SacmEIkXdcuz8eCnZr-UHkjMqvPHcNTJtg0ESRkU,21633
-kaggle_environments-0.2.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kaggle_environments-0.2.1.dist-info/METADATA,sha256=BjEQf7p6isqwZ0_hfa70vELjoGkwlc7g1PqUUZv5amY,10685
-kaggle_environments-0.2.1.dist-info/WHEEL,sha256=p46_5Uhzqz6AzeSosiOnxK-zmFja1i22CrQCjmYe8ec,92
-kaggle_environments-0.2.1.dist-info/entry_points.txt,sha256=SblqSc9cehdfGIc8QMCJU9vE4oxe7rBctjpm8f9rONw,71
-kaggle_environments-0.2.1.dist-info/top_level.txt,sha256=v3MMWIPMQFcI-WuF_dJngHWe9Bb2yH_6p4wat1x4gAc,20
-kaggle_environments-0.2.1.dist-info/RECORD,,

kaggle_environments-0.2.1.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-kaggle-environments = kaggle_environments.main:main
-

kaggle_environments-0.2.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-kaggle_environments