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

kaggle_environments-1.20.0/.gcloudignore

@@ -0,0 +1,17 @@
+# This file specifies files that are *not* uploaded to Google Cloud Platform
+# using gcloud. It follows the same syntax as .gitignore, with the addition of
+# "#!include" directives (which insert the entries of the given .gitignore-style
+# file at that point).
+#
+# For more information, run:
+#   $ gcloud topic gcloudignore
+#
+.gcloudignore
+# If you would like to upload your .git directory, .gitignore file or files
+# from your .gitignore file, remove the corresponding line
+# below:
+.git
+.gitignore
+
+node_modules
+#!include:.gitignore

kaggle_environments-1.20.0/.gitignore

@@ -0,0 +1,157 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# pyenv
+bin/
+lib64
+pyvenv.cfg
+share/
+
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+!docker/envs/football/egl/gfootball/env/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Temp Files
+temp.*
+
+.idea/
+
+# Git merge artifacts
+*.orig
+
+# node.js files
+node_modules
+
+# Java class files
+*.class
+
+.vscode
+
+submission.tar.gz
+
+replay.html

kaggle_environments-1.20.0/.prettierrc.js

@@ -0,0 +1,16 @@
+module.exports = {
+    overrides: [
+        {
+            // Target all JavaScript and TypeScript files
+            files: ['*.js', '*.jsx', '*.ts', '*.tsx'],
+            options: {
+                tabWidth: 4,
+                singleQuote: true,
+                trailingComma: 'none',
+                quoteProps: 'preserve',
+                semi: true,
+                printWidth: 120
+            }
+        }
+    ]
+};

kaggle_environments-1.20.0/CONTRIBUTING.md

@@ -0,0 +1,28 @@
+# How to Contribute
+
+We'd love to accept your patches and contributions to this project. There are
+just a few small guidelines you need to follow.
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement. You (or your employer) retain the copyright to your contribution;
+this simply gives us permission to use and redistribute your contributions as
+part of the project. Head over to <https://cla.developers.google.com/> to see
+your current agreements on file or to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Code reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult
+[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
+information on using pull requests.
+
+## Community Guidelines
+
+This project follows
+[Google's Open Source Community Guidelines](https://opensource.google/conduct/).

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

@@ -4,4 +4,7 @@ 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 *.jsonl
+recursive-include kaggle_environments/envs/cabt *.so
+recursive-include kaggle_environments/envs/cabt *.dll

kaggle_environments-1.20.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: kaggle-environments
+Version: 1.20.0
+Summary: Kaggle Environments
+Author-email: Kaggle <support@kaggle.com>
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: accelerate
+Requires-Dist: bitsandbytes
+Requires-Dist: Chessnut >= 0.4.1
+Requires-Dist: Flask >= 1.1.2
+Requires-Dist: gymnasium == 1.2.0
+Requires-Dist: gymnax==0.0.8
+Requires-Dist: jax
+Requires-Dist: jsonschema >= 3.0.1
+Requires-Dist: litellm
+Requires-Dist: numpy >= 2.2.6
+Requires-Dist: open_spiel >= 1.6.2
+Requires-Dist: pettingzoo == 1.24.0
+Requires-Dist: requests >= 2.25.1
+Requires-Dist: scipy >= 1.15.3
+Requires-Dist: shimmy >= 1.2.1
+Requires-Dist: stable-baselines3 == 2.7.0
+Requires-Dist: transformers >= 4.33.1
+Project-URL: Homepage, https://github.com/Kaggle/kaggle-environments

{kaggle_environments-1.17.12 → kaggle_environments-1.20.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/envs → kaggle_environments-1.20.0/deprecated_envs}/llm_20_questions/llm_20_questions.py

@@ -1,17 +1,13 @@
 import json
 import os
-import pandas as pd
 import random
 import string
+from os import path
+
 import torch
+from transformers import T5ForConditionalGeneration, T5Tokenizer
 
 from .keywords import KEYWORDS_JSON
-from os import path
-from pathlib import Path
-from random import choice
-from string import Template
-from transformers import T5Tokenizer, T5ForConditionalGeneration
-
 
 llm_parent_dir = "/kaggle/input/flan-t5/pytorch/large"
 
@@ -34,13 +30,17 @@ ANSWERER = "answerer"
 RANDOM_GUESSER = "random_guesser"
 RANDOM_ANSWERER = "random_answerer"
 
+
 def weighted_random_category(keywords_list):
     try:
-        return random.choices(population=keywords_list, weights=[len(entry["words"]) for entry in keywords_list], k=1)[0]
+        return random.choices(population=keywords_list, weights=[len(entry["words"]) for entry in keywords_list], k=1)[
+            0
+        ]
     except:
         pass
     return random.choice(keywords_list)
 
+
 keywords_list = json.loads(KEYWORDS_JSON)
 keyword_cat = weighted_random_category(keywords_list)
 category = keyword_cat["category"]
@@ -68,14 +68,15 @@ except:
 def random_guesser(obs):
     if obs.turnType == GUESS:
         return "banana"
-    if random.random() < .5:
+    if random.random() < 0.5:
         return "Is is a person?"
-    if random.random() < .5:
+    if random.random() < 0.5:
         return "Is it a place?"
     return "Is it a thing?"
 
+
 def random_answerer():
-    if random.random() > .5:
+    if random.random() > 0.5:
         return "yes"
     return "no"
 
@@ -87,29 +88,18 @@ def guesser_agent(obs):
 
     q_a_thread = ""
     for i in range(0, len(obs.answers)):
-        q_a_thread = "{}Q: {} A: {}\n".format(
-            q_a_thread,
-            obs.questions[i],
-            obs.answers[i]
-        )
+        q_a_thread = "{}Q: {} A: {}\n".format(q_a_thread, obs.questions[i], obs.answers[i])
 
     prompt = ""
     if obs.turnType == ASK:
-        prompt = "{}{}".format(
-            info_prompt.format(q_a_thread=q_a_thread),
-            questions_prompt
-        )
+        prompt = "{}{}".format(info_prompt.format(q_a_thread=q_a_thread), questions_prompt)
     elif obs.turnType == GUESS:
-        prompt = "{}{}".format(
-            info_prompt.format(q_a_thread=q_a_thread),
-            guess_prompt
-        )
+        prompt = "{}{}".format(info_prompt.format(q_a_thread=q_a_thread), guess_prompt)
     else:
         return ""
-    
+
     return call_llm(prompt)
 
-    
 
 def answerer_agent(obs):
     info_prompt = """You are a very precise answerer in a game of 20 questions. The keyword that the questioner is trying to guess is [the {category} {keyword}]. """
@@ -117,15 +107,21 @@ def answerer_agent(obs):
 
     if obs.turnType == "answer":
         prompt = "{}{}".format(
-            info_prompt.format(category=category,keyword=keyword),
-            answer_question_prompt.format(question=obs.questions[-1])
+            info_prompt.format(category=category, keyword=keyword),
+            answer_question_prompt.format(question=obs.questions[-1]),
         )
         return call_llm(prompt)
-    else: 
+    else:
         return ""
 
 
-agents = {GUESSER: guesser_agent, ANSWERER: answerer_agent, RANDOM_ANSWERER: random_answerer, RANDOM_GUESSER: random_guesser}
+agents = {
+    GUESSER: guesser_agent,
+    ANSWERER: answerer_agent,
+    RANDOM_ANSWERER: random_answerer,
+    RANDOM_GUESSER: random_guesser,
+}
+
 
 def guesser_action(active, inactive, step):
     inactive.observation.keyword = keyword
@@ -150,12 +146,14 @@ def guesser_action(active, inactive, step):
         end_game(inactive, score, DONE)
     return [guessed, bad_guess]
 
+
 def end_game(agent, reward, status):
     agent.observation.keyword = keyword
     agent.observation.category = category
     agent.reward = reward
     agent.status = status
 
+
 def answerer_action(active, inactive):
     active.observation.keyword = keyword
     active.observation.category = category
@@ -179,6 +177,7 @@ def answerer_action(active, inactive):
     inactive.observation.answers.append(response)
     return bad_response
 
+
 def increment_turn(active, inactive, step, guessed):
     if step == 59 and not guessed:
         end_game(active, -1, DONE)
@@ -243,7 +242,7 @@ def interpreter(state, env):
         end_game(inactive1, 1, DONE)
     else:
         increment_turn(active1, inactive1, step, one_guessed)
-    
+
     if active2.status in (TIMEOUT, ERROR) or two_bad_response or two_bad_guess:
         end_game(active2, -1, active2.status)
         end_game(inactive2, 1, DONE)
@@ -252,7 +251,7 @@ def interpreter(state, env):
         end_game(inactive2, 1, DONE)
     else:
         increment_turn(active2, inactive2, step, two_guessed)
-    
+
     # make sure to end the game if only one team guessed correctly this round
     if one_guessed and not two_guessed:
         end_game(active2, 0, DONE)
@@ -260,21 +259,18 @@ def interpreter(state, env):
     elif two_guessed and not one_guessed:
         end_game(active1, 0, DONE)
         end_game(inactive1, 0, DONE)
-    
+
     return state
 
 
 def renderer(state, env):
-
     for s in state:
         print("role: ", s.observation.role)
         if s.observation.role == GUESSER:
             transcript = ""
             for i in range(0, len(s.observation.guesses)):
                 transcript = "{}Q: {} A: {}\nG: {}\n".format(
-                    transcript, s.observation.questions[i],
-                    s.observation.answers[i],
-                    s.observation.guesses[i]
+                    transcript, s.observation.questions[i], s.observation.answers[i], s.observation.guesses[i]
                 )
             print(transcript)
 
@@ -291,6 +287,7 @@ jsonpath = path.abspath(path.join(path.dirname(__file__), "llm_20_questions.json
 with open(jsonpath) as f:
     specification = json.load(f)
 
+
 def html_renderer():
     jspath = path.abspath(path.join(path.dirname(__file__), "llm_20_questions.js"))
     with open(jspath, encoding="utf-8") as f:
@@ -301,6 +298,7 @@ def normalize(s: str) -> str:
     t = str.maketrans("", "", string.punctuation)
     return s.lower().replace("the", "").replace(" ", "").translate(t)
 
+
 def compare_words(a, b) -> bool:
     a = normalize(a)
     b = normalize(b)
@@ -320,12 +318,13 @@ def compare_words(a, b) -> bool:
         return True
     return False
 
+
 def keyword_guessed(guess: str) -> bool:
     if compare_words(guess, keyword):
-      return True
-    for s in alts:
-      if compare_words(s, guess):
         return True
+    for s in alts:
+        if compare_words(s, guess):
+            return True
     return False
 
 

{kaggle_environments-1.17.12/kaggle_environments/envs → kaggle_environments-1.20.0/deprecated_envs}/llm_20_questions/test_llm_20_questions.py

@@ -1,38 +1,44 @@
-
 from kaggle_environments import make
 
+
 def custom_questioner(obs):
     if obs.turnType == "guess":
         return "banana"
     return "Is it a banana?"
 
+
 def last_round_guesser_error(obs):
     if obs.turnType == "guess" and len(obs.questions) == 20:
-         a = 1
-         b = 0
-         return a / b
+        a = 1
+        b = 0
+        return a / b
     if obs.turnType == "guess":
         return "banana"
     return "Is it a banana?"
 
+
 def custom_answerer():
     return "no"
 
+
 def bad_answerer():
     return "maybe?"
 
+
 def error_agent():
     raise ValueError
 
+
 def test_llm_20_q_completes():
-    env = make("llm_20_questions", debug=True)
+    env = make("llm_20_questions", debug=False)
     env.run([custom_questioner, custom_answerer, custom_questioner, custom_answerer])
     json = env.toJSON()
     assert json["name"] == "llm_20_questions"
     assert json["statuses"] == ["DONE", "DONE", "DONE", "DONE"]
 
+
 def test_llm_20_q_errors_on_bad_answer():
-    env = make("llm_20_questions", debug=True)
+    env = make("llm_20_questions", debug=False)
     env.run([custom_questioner, custom_answerer, custom_questioner, bad_answerer])
     json = env.toJSON()
     assert json["name"] == "llm_20_questions"
@@ -41,8 +47,9 @@ def test_llm_20_q_errors_on_bad_answer():
     print(len(json["steps"]))
     assert len(json["steps"]) == 3
 
+
 def test_llm_20_q_errors_on_error_answer():
-    env = make("llm_20_questions", debug=True)
+    env = make("llm_20_questions", debug=False)
     env.run([custom_questioner, custom_answerer, custom_questioner, error_agent])
     json = env.toJSON()
     assert json["name"] == "llm_20_questions"
@@ -50,8 +57,9 @@ def test_llm_20_q_errors_on_error_answer():
     assert json["statuses"] == ["DONE", "DONE", "DONE", "ERROR"]
     assert len(json["steps"]) == 3
 
+
 def test_llm_20_q_errors_on_error_question():
-    env = make("llm_20_questions", debug=True)
+    env = make("llm_20_questions", debug=False)
     env.run([custom_questioner, custom_answerer, error_agent, custom_answerer])
     json = env.toJSON()
     assert json["name"] == "llm_20_questions"
@@ -59,10 +67,11 @@ def test_llm_20_q_errors_on_error_question():
     assert json["statuses"] == ["DONE", "DONE", "ERROR", "DONE"]
     assert len(json["steps"]) == 2
 
+
 def test_llm_20_q_errors_on_error_last_guess():
-    env = make("llm_20_questions", debug=True)
+    env = make("llm_20_questions", debug=False)
     env.run([custom_questioner, custom_answerer, last_round_guesser_error, custom_answerer])
     json = env.toJSON()
     assert json["name"] == "llm_20_questions"
     assert json["rewards"] == [1, 1, None, 1]
-    assert json["statuses"] == ["DONE", "DONE", "ERROR", "DONE"]
+    assert json["statuses"] == ["DONE", "DONE", "ERROR", "DONE"]

kaggle_environments-1.20.0/deprecated_envs/lux_ai_s2/.gitignore

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

kaggle_environments-1.20.0/deprecated_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-1.17.12/kaggle_environments/envs/lux_ai_s3 → kaggle_environments-1.20.0/deprecated_envs/lux_ai_s2}/agents.py

@@ -1,4 +1,5 @@
 from .test_agents.python.main import agent_fn as random_agent
+
 all_agents = {
     "random_agent": random_agent,
-}
+}