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

kaggle_environments/utils.py

@@ -13,23 +13,23 @@
 # limitations under the License.
 
 import json
-import jsonschema
-import sys
 from copy import deepcopy
-from io import StringIO
 from pathlib import Path
-from urllib.parse import urlparse
-from .errors import InvalidArgument, NotFound
 
+import jsonschema
+
+from .errors import InvalidArgument, NotFound
 
 # Path Utilities.
 root_path = Path(__file__).parent.resolve()
 envs_path = Path.joinpath(root_path, "envs")
 
 
-# Primative Utilities.
-def get(o, classinfo=None, default=None, path=[], is_callable=None, fallback=None):
-    if o == None and default != None:
+# Primitive Utilities.
+def get(o, classinfo=None, default=None, path=None, is_callable=None, fallback=None):
+    if path is None:
+        path = []
+    if o is None and default is not None:
         o = default
     if has(o, classinfo, default, path, is_callable):
         cur = o
@@ -37,25 +37,27 @@ def get(o, classinfo=None, default=None, path=[], is_callable=None, fallback=Non
             cur = cur[p]
         return cur
     else:
-        if default != None:
+        if default is not None:
             return default
         return fallback
 
 
-def has(o, classinfo=None, default=None, path=[], is_callable=None):
+def has(o, classinfo=None, default=None, path=None, is_callable=None):
+    if path is None:
+        path = []
     try:
         cur = o
         for p in path:
             cur = cur[p]
-        if classinfo != None and not isinstance(cur, classinfo):
-            raise "Not a match"
-        if is_callable == True and not callable(cur):
-            raise "Not callable"
-        if is_callable == False and callable(cur):
-            raise "Is callable"
+        if classinfo is not None and not isinstance(cur, classinfo):
+            raise ValueError("Not a match")
+        if is_callable and not callable(cur):
+            raise ValueError("Not callable")
+        if not is_callable and callable(cur):
+            raise ValueError("Is callable")
         return True
     except:
-        if default != None and o != None and len(path) > 0:
+        if default is not None and o is not None and len(path) > 0:
             cur = o
             for p in path[:-1]:
                 if not has(cur, dict, path=[p]):
@@ -65,9 +67,15 @@ def has(o, classinfo=None, default=None, path=[], is_callable=None):
         return False
 
 
-def call(o, default=None, path=[], args=[], kwargs={}):
+def call(o, default=None, path=None, args=None, kwargs=None):
+    if path is None:
+        path = []
+    if args is None:
+        args = []
+    if kwargs is None:
+        kwargs = {}
     o = get(o, default=False, path=path, is_callable=True)
-    if o != False:
+    if o is not False:
         return o(*args, **kwargs)
     else:
         return default
@@ -84,7 +92,7 @@ class Struct(dict):
         self[attr] = value
 
 
-# Added benifit of cloning lists and dicts.
+# Added benefit of cloning lists and dicts.
 def structify(o):
     if isinstance(o, list):
         return [structify(o[i]) for i in range(len(o))]
@@ -99,49 +107,17 @@ def read_file(path, fallback=None):
         with open(path, "r", encoding="utf-8") as file:
             return file.read()
     except:
-        if fallback != None:
+        if fallback is not None:
             return fallback
         raise NotFound(f"{path} not found")
 
 
-def get_exec(raw, fallback=None):
-    orig_out = sys.stdout
-    buffer = StringIO()
-    sys.stdout = buffer
-    try:
-        code_object = compile(raw, "<string>", "exec")
-        env = {}
-        exec(code_object, env)
-        sys.stdout = orig_out
-        print(buffer.getvalue())
-        return env
-    except Exception as e:
-        sys.stdout = orig_out
-        print(buffer.getvalue())
-        if fallback != None:
-            return fallback
-        raise InvalidArgument("Invalid raw Python: " + str(e))
-
-
-def get_last_callable(raw, fallback=None):
-    try:
-        local = get_exec(raw)
-        callables = [v for v in local.values() if callable(v)]
-        if len(callables) > 0:
-            return callables[-1]
-        raise "Nope"
-    except:
-        if fallback != None:
-            return fallback
-        raise InvalidArgument("No callable found")
-
-
 def get_file_json(path, fallback=None):
     try:
         with open(path, "r") as json_file:
             return json.load(json_file)
     except:
-        if fallback != None:
+        if fallback is not None:
             return fallback
         raise InvalidArgument(f"{path} does not contain valid JSON")
 
@@ -152,22 +128,22 @@ schemas = structify(get_file_json(Path.joinpath(root_path, "schemas.json")))
 
 def default_schema(schema, data):
     default = get(schema, path=["default"])
-    if default == None and data == None:
+    if default is None and data is None:
         return
 
     if get(schema, path=["type"]) == "object":
         default = deepcopy(get(default, dict, {}))
-        if data == None or not has(data, dict):
+        if data is None or not has(data, dict):
             obj = default
         else:
             obj = data
             for k, v in default.items():
-                if not k in obj:
+                if k not in obj:
                     obj[k] = v
         properties = get(schema, dict, {}, ["properties"])
         for key, prop_schema in properties.items():
             new_value = default_schema(prop_schema, get(obj, path=[key]))
-            if new_value != None:
+            if new_value is not None:
                 obj[key] = new_value
         return obj
 
@@ -176,20 +152,20 @@ def default_schema(schema, data):
         arr = get(data, list, default)
         item_schema = get(schema, dict, {}, ["items"])
         for index, value in enumerate(arr):
-            if value == None and len(default) > index:
+            if value is None and len(default) > index:
                 new_value = default[index]
             else:
                 new_value = default_schema(item_schema, value)
-            if new_value != None:
+            if new_value is not None:
                 arr[index] = new_value
         return arr
 
-    return data if data != None else default
+    return data if data is not None else default
 
 
 def process_schema(schema, data, use_default=True):
     error = None
-    if use_default == True:
+    if use_default is True:
         data = default_schema(schema, deepcopy(data))
     try:
         jsonschema.validate(data, schema)
@@ -198,21 +174,18 @@ def process_schema(schema, data, use_default=True):
     return error, data
 
 
-def is_url(url):
-    try:
-        result = urlparse(url)
-        return all([result.scheme, result.netloc])
-    except ValueError:
-        return False
-
-
 # Player utilities
 def get_player(window_kaggle, renderer):
+    if renderer[0] == "html_path":
+        key = "/*window.kaggle*/"
+        value = f"""
+window.kaggle = {json.dumps(window_kaggle, indent=2)};\n\n
+        """
+        return read_file(renderer[1]).replace(key, value)
+
     key = "/*window.kaggle*/"
     value = f"""
 window.kaggle = {json.dumps(window_kaggle, indent=2)};\n\n
 window.kaggle.renderer = {renderer.strip()};\n\n
     """
-    return read_file(Path.joinpath(root_path, "static", "player.html")).replace(
-        key, value
-    )
+    return read_file(Path.joinpath(root_path, "static", "player.html")).replace(key, value)

{kaggle_environments-0.2.1.dist-info → kaggle_environments-1.20.1.dist-info}/METADATA

@@ -1,21 +1,35 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: kaggle-environments
-Version: 0.2.1
+Version: 1.20.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
+Author-email: Kaggle <support@kaggle.com>
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: jsonschema (>=3.0.1)
+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
 
 # [<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;
@@ -66,10 +80,10 @@ help(env.reset)
 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})
+from kaggle_environments import make
+env = make("connectx", {"rows": 10, "columns": 8, "inarow": 5})
 
-def agent(observation, configration):
+def agent(observation, configuration):
   print(observation) # {board: [...], mark: 1}
   print(configuration) # {rows: 10, columns: 8, inarow: 5}
   return 3 # Action: always place a mark in the 3rd column.
@@ -116,7 +130,7 @@ agent6 = "http://localhost:8000/run/agent"
 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
+from kaggle_environments import make
 env = make("tictactoe")
 
 # The list of available default agents.
@@ -160,7 +174,7 @@ There are 3 types of errors which can occur from agent execution:
 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
+from kaggle_environments import make
 
 def agent():
   return "Something Bad"
@@ -211,16 +225,15 @@ There are two types of configuration: Defaults applying to every environment and
 | 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). |
+| maxLogLength | Maximum log length (number of characters, `None` -> no limit)   |
 
 ```python
 env = make("connectx", configuration={
   "columns": 19, # Specific to ConnectX.
   "actTimeout": 10,
-  "agentExec": "LOCAL"
 })
 ```
 
@@ -247,13 +260,12 @@ print(steps)
 Evaluation is used to run an episode (environment + agents) multiple times and just return the rewards.
 
 ```python
-from kaggle_simulations import evaluate
+from kaggle_environments import evaluate
 
 # Same definitions as "make" above.
-envrionment = "connectx"
-configuration = {rows: 10, columns: 8, inarow: 5}
+environment = "connectx"
+configuration = {"rows": 10, "columns": 8, "inarow": 5}
 steps = []
-debug = False
 
 # Which agents to run repeatedly.  Same as env.run(agents)
 agents = ["random", agent1]
@@ -261,7 +273,7 @@ agents = ["random", agent1]
 # How many times to run them.
 num_episodes = 10
 
-rewards = evaluate(environment, agents, configuration, steps, num_episodes, debug)
+rewards = evaluate(environment, agents, configuration, steps, num_episodes)
 ```
 
 ## Stepping
@@ -271,7 +283,7 @@ Running above essentially just steps until no agent is still active. To execute
 ```python
 agent1_action = agent1(env.state[0].observation)
 agent2_action = agent2(env.state[1].observation)
-state = env.step(agent1_action, agent2_action)
+state = env.step([agent1_action, agent2_action])
 ```
 
 ## Playing
@@ -279,7 +291,7 @@ state = env.step(agent1_action, agent2_action)
 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
+from kaggle_environments import make
 
 env = make("connectx")
 # None indicates which agent will be manually played.
@@ -301,93 +313,3 @@ 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)
-```
-
-