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

kaggle_environments/__init__.py

@@ -12,29 +12,65 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 from importlib import import_module
 from os import listdir
 from .agent import Agent
-from .core import *
+from .api import get_episode_replay, list_episodes, list_episodes_for_team, list_episodes_for_submission
+from .core import evaluate, make, register
+from .main import http_request
 from . import errors
 from . import utils
 
-version = "0.2.0"
+__version__ = "1.19.0"
 
-__all__ = ["Agent", "environments", "errors", "evaluate",
-           "make", "register", "utils", "version"]
+__all__ = [
+    "Agent",
+    "environments",
+    "errors",
+    "evaluate",
+    "http_request",
+    "make",
+    "register",
+    "utils",
+    "__version__",
+    "get_episode_replay",
+    "list_episodes",
+    "list_episodes_for_team",
+    "list_episodes_for_submission",
+]
+
+_script_dir = os.path.dirname(os.path.realpath(__file__))
+PROJECT_ROOT = os.path.abspath(os.path.join('..', _script_dir))
 
 # Register Environments.
 
 for name in listdir(utils.envs_path):
     try:
         env = import_module(f".envs.{name}.{name}", __name__)
-        register(name, {
-            "agents": getattr(env, "agents", []),
-            "html_renderer": getattr(env, "html_renderer", None),
-            "interpreter": getattr(env, "interpreter"),
-            "renderer": getattr(env, "renderer"),
-            "specification": getattr(env, "specification"),
-        })
-    except:
-        pass
+        if name == "open_spiel":
+            for env_name, env_dict in env.ENV_REGISTRY.items():
+                register(
+                    env_name,
+                    {
+                        "agents": env_dict.get("agents"),
+                        "html_renderer": env_dict.get("html_renderer"),
+                        "interpreter": env_dict.get("interpreter"),
+                        "renderer": env_dict.get("renderer"),
+                        "specification": env_dict.get("specification"),
+                    },
+                )
+        else:
+            register(
+                name,
+                {
+                    "agents": getattr(env, "agents", []),
+                    "html_renderer": getattr(env, "html_renderer", None),
+                    "interpreter": getattr(env, "interpreter"),
+                    "renderer": getattr(env, "renderer"),
+                    "specification": getattr(env, "specification"),
+                },
+            )
+    except Exception as e:
+        if "football" not in name:
+            print("Loading environment %s failed: %s" % (name, e))

kaggle_environments/agent.py

@@ -12,151 +12,204 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import os
+import sys
+import traceback
+from contextlib import redirect_stderr, redirect_stdout
+from io import StringIO
+from time import perf_counter
+from urllib.parse import urlparse
+
 import requests
-import json
-from multiprocessing import Manager, Process
-from time import time
-import uuid
-from .errors import DeadlineExceeded
-from .utils import get_exec, has, is_url, read_file, structify
+from requests.exceptions import Timeout
+
+from .errors import DeadlineExceeded, InvalidArgument
+from .utils import read_file, structify
+
 
+def is_url(url):
+    try:
+        result = urlparse(url)
+        return all([result.scheme, result.netloc])
+    except ValueError:
+        return False
+
+
+def get_last_callable(raw, fallback=None, path=None):
+    orig_out = sys.stdout
+    buffer = StringIO()
+    sys.stdout = buffer
+
+    try:
+        code_object = compile(raw, path, "exec")
+        env = {}
+
+        # append exec_dir so that way python agents can import other files
+        exec_dir = os.path.dirname(path)
+        sys.path.append(exec_dir)
+
+        exec(code_object, env)
+        sys.path.pop()
+        sys.stdout = orig_out
+        output = buffer.getvalue()
+        if output:
+            print(output)
+        return [v for v in env.values() if callable(v)][-1]
+    except Exception as e:
+        sys.stdout = orig_out
+        output = buffer.getvalue()
+        if output:
+            print(output)
+        if fallback is not None:
+            return fallback
+        raise InvalidArgument("Invalid raw Python: " + repr(e))
+
+
+class UrlAgent:
+    def __init__(self, raw, environment_name):
+        self.raw = raw
+        self.environment_name = environment_name
+
+    def __call__(self, observation, configuration):
+        data = {
+            "action": "act",
+            "configuration": configuration,
+            "environment": self.environment_name,
+            "state": {
+                "observation": observation,
+            },
+        }
+        timeout = float(observation.remainingOverageTime) + float(configuration.actTimeout) + 1
+        try:
+            response = requests.post(url=self.raw, data=json.dumps(data), timeout=timeout)
+            response.raise_for_status()
+            response_json = response.json()
+            action = response_json["action"]
+            if action == "DeadlineExceeded":
+                action = DeadlineExceeded()
+            elif isinstance(action, str) and action.startswith("BaseException::"):
+                # Deserialize the exception message
+                parts = action.split("::", 1)
+                action = BaseException(parts[1])
+            return action
+        except Timeout:
+            print(f"Request timed out after {timeout} seconds")
+            return DeadlineExceeded()
+        except requests.exceptions.RequestException as e:
+            print(f"Request error: {e}")
+            return None
+
+
+def build_agent(raw, builtin_agents, environment_name):
+    """
+    Returns the agent and whether the agent is parallelizable.
+    """
+    if raw in builtin_agents:
+        agent = builtin_agents[raw]
+        # TODO: Below is a hack. Assuming an agent is a global callable is not enough to guarantee it is stateless.
+        #  Kaggle environment should allow more scalable agent initialization and proper agent interface design.
+        if hasattr(agent, "reset"):
+            agent.reset()
+        return builtin_agents[raw], False
 
-def build_agent(raw):
     # Already callable.
     if callable(raw):
-        return raw
+        return raw, False
 
     # Not a string, static action.
-    if not has(raw, str):
-        return lambda: raw
+    if not isinstance(raw, str):
+        return lambda: raw, False
 
     # A URL and will be initialized on the calling server.
     if is_url(raw):
-        def url_agent(o, c, r, i):
-            data = {
-                "action": "act",
-                "configuration": {
-                    **c,
-                    "agentExec": "LOCAL"
-                },
-                "state": {
-                    "observation": o,
-                    "reward": r,
-                    "info": i
-                }
-            }
-            action = requests.post(
-                url=raw, data=json.dumps(data)).json()["action"]
-            if action == "DeadlineExceeded":
-                action = DeadlineExceeded()
-            elif action == "BaseException":
-                action = BaseException()
-            return action
-        return url_agent
+        return UrlAgent(raw, environment_name), True
 
     # A path exists and attempt to grab the source (fallback to the original string).
+    raw_agent = raw
     if os.path.exists(raw):
-        raw = read_file(raw, raw)
+        raw_agent = read_file(raw, raw)
+    elif (len(raw) < 100 and ("/" in raw or "\\" in raw)) or len(raw) < 20:
+        raise FileNotFoundError("Could not find : " + raw)
 
     # Attempt to execute the last callable or just return the string.
-    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:
-        return lambda: raw
-
-
-def run_agent(agent, message):
-    if message.state != None and message:
-        args = [
-            structify(message.state["observation"]),
-            structify(message.configuration),
-            message.state["reward"],
-            structify(message.state["info"])
-        ][:agent.__code__.co_argcount]
-        try:
-            message.action = agent(*args)
-        except Exception as e:
-            message.action = e
-        message.state = None
-
-
-def runner(raw, message):
-    try:
-        agent = build_agent(raw)
-    except Exception as e:
-        message.action = e
-    while True:
-        run_agent(agent, message)
-
-
-class Agent():
-
-    def __init__(self, raw, configuration, id=None):
-        self.id = id or str(uuid.uuid1())
-        self.configuration = configuration
+    agent = None
+
+    def callable_agent(observation, configuration):
+        nonlocal agent
+        if agent is None:
+            agent = get_last_callable(raw_agent, path=raw) or raw_agent
+        configuration["__raw_path__"] = raw
+        args = [observation, configuration]
+        args = args[: agent.__code__.co_argcount]
+        return agent(*args) if callable(agent) else agent
+
+    return callable_agent, False
+
+
+class Agent:
+    def __init__(self, raw, environment):
+        self.builtin_agents = environment.agents
+        self.configuration = environment.configuration
+        self.debug = environment.debug
+        self.environment_name = environment.name
         self.raw = raw
-        self.use_process = configuration["agentExec"] == "PROCESS"
-
-        if self.use_process:
-            self.manager = Manager()
-            self.message = self.manager.Namespace()
-            self.message.action = None
-            self.message.state = None
-            self.message.configuration = configuration
-            self.process = Process(target=runner, args=(raw, self.message))
-            self.process.daemon = True
-            self.process.start()
-        else:
-            self.message = structify(
-                {"action": None, "state": None, "configuration": configuration})
-            self.agent = None
+        self.agent, self.is_parallelizable = build_agent(self.raw, self.builtin_agents, self.environment_name)
 
-    def act(self, state, timeout=10):
-        # Start the timer.
-        start = time()
+    def act(self, observation):
+        args = [structify(observation), structify(self.configuration)]
 
-        # If an action is already set (uncleared), there is an error.
-        if self.message.action != None:
-            return self.message.action
+        if hasattr(self.agent, "__code__"):
+            args = args[: self.agent.__code__.co_argcount]
 
-        # Inform the agent an action is requested.
-        self.message.state = state
+        # Start the timer.
 
-        if self.use_process:
-            # Timeout or Action Returned (will be processed below).
-            while True:
-                if time() - start > timeout or self.message.action != None:
-                    break
+        if self.debug:
+            # Adding a debugging branch here, since the context manager and try except would prevent
+            # debugger from functioning properly.
+            start = perf_counter()
+            action = self.agent(*args)
+            out = ""
+            err = ""
         else:
-            if self.agent is None:
+            with (
+                StringIO() as out_buffer,
+                StringIO() as err_buffer,
+                redirect_stdout(out_buffer),
+                redirect_stderr(err_buffer),
+            ):
                 try:
-                    self.agent = build_agent(self.raw)
-                    # Update the timeout to add the agentTimeout (incase set to "act").
-                    timeout = self.configuration.agentTimeout + self.configuration.actTimeout
+                    start = perf_counter()
+                    action = self.agent(*args)
                 except Exception as e:
-                    return e
-            run_agent(self.agent, self.message)
-
-        # Timeout reached, destroy the agent, and throw an error.
-        if time() - start > timeout:
-            self.destroy()
-            return DeadlineExceeded()
-
-        # Return and clear the action.
-        action = self.message.action
-        self.message.action = None
-        return action
-
-    def destroy(self):
-        if self.id == None:
-            return
-        self.id = None
-        if self.use_process:
-            self.process.join(0.1)
-            self.process.terminate()
-            self.manager.shutdown()
+                    traceback.print_exc(file=err_buffer)
+                    action = e
+                out = out_buffer.getvalue()
+                err = err_buffer.getvalue()
+            # Get the maximum log length
+            # Allow up to 10k (default) log characters per step which is ~10MB per 600 step episode
+            max_log_length = self.configuration.get("maxLogLength", 10000)
+
+            # truncate if max_log_length is set to None, do not truncate
+            if max_log_length is not None:
+                out = out[0:max_log_length]
+                err = err[0:max_log_length]
+
+        duration = perf_counter() - start
+        log = {
+            "duration": round(duration, 6),
+            "stdout": out,
+            "stderr": err,
+        }
+
+        if self.debug:
+            if not log["stdout"].isspace():
+                print(log["stdout"], end="")
+            if not log["stderr"].isspace():
+                print(log["stderr"], end="")
+
+        if duration - self.configuration.actTimeout > observation.remainingOverageTime:
+            # No overage time left, timeout agent
+            action = DeadlineExceeded()
+
+        return action, log

kaggle_environments/api.py

@@ -0,0 +1,31 @@
+from typing import List
+
+import requests
+
+base_url = "https://www.kaggle.com/requests/EpisodeService/"
+get_url = base_url + "GetEpisodeReplay"
+list_url = base_url + "ListEpisodes"
+
+
+def get_episode_replay(episode_id: int):
+    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})
+
+
+def list_episodes_for_team(team_id: int):
+    return __list_episodes({"TeamId": team_id})
+
+
+def list_episodes_for_submission(submission_id: int):
+    return __list_episodes({"SubmissionId": submission_id})
+
+
+def __list_episodes(body):
+    response = requests.post(list_url, json=body)
+    return response.json()