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

kaggle_environments/main.py

@@ -15,50 +15,84 @@
 import argparse
 import json
 import traceback
-from kaggle_environments import environments, evaluate, make, utils
+from logging.config import dictConfig
+from typing import Optional
 
+from . import errors, utils
+from .agent import Agent
+from .core import environments, evaluate, make
 
 parser = argparse.ArgumentParser(description="Kaggle Simulations")
 parser.add_argument(
     "action",
-    choices=["list", "evaluate", "run", "step", "load", "http-server"],
+    choices=["list", "evaluate", "run", "step", "load", "act", "dispose", "http-server"],
     help="List environments. Evaluate many episodes. Run a single episode. Step the environment. Load the environment. Start http server.",
 )
-parser.add_argument("--environment", type=str,
-                    help="Environment to run against.")
+parser.add_argument("--environment", type=str, help="Environment to run against.")
 parser.add_argument("--debug", type=bool, help="Print debug statements.")
-parser.add_argument(
-    "--agents", type=str, nargs="*", help="Agent(s) to run with the environment."
-)
+parser.add_argument("--agents", type=str, nargs="*", help="Agent(s) to run with the environment.")
 parser.add_argument(
     "--configuration",
     type=json.loads,
     help="Environment configuration to setup the environment.",
 )
+parser.add_argument(
+    "--info",
+    type=json.loads,
+    help="Information about agents playing.",
+)
 parser.add_argument(
     "--steps",
     type=json.loads,
     help="Environment starting states (default=[resetState]).",
 )
 parser.add_argument(
-    "--episodes", type=int, help="Number of episodes to evaluate (default=1)"
+    "--logs",
+    type=json.loads,
+    help="Environment starting logs (default=[]).",
 )
+parser.add_argument(
+    "--state",
+    type=json.loads,
+    help="Single agent state used for evaluation (default={}).",
+)
+parser.add_argument("--episodes", type=int, help="Number of episodes to evaluate (default=1)")
 parser.add_argument(
     "--render",
     type=json.loads,
-    help="Response from run, step, or load. Calls environment render. (default={mode='json'})",
+    help="Response from run, step, or load. Calls environment render (default={mode='json'}).",
+)
+parser.add_argument(
+    "--display",
+    type=str,
+    help="Shortcut to the --render {mode=''} argument (default json).",
+)
+parser.add_argument("--port", type=int, help="http-server Port (default=8000).")
+parser.add_argument("--host", type=str, help="http-server Host (default=127.0.0.1).")
+parser.add_argument("--in", type=str, help="Episode replay file to load. Only works when the action is load.")
+parser.add_argument(
+    "--out", type=str, help="Output file to write the results of the episode. Does nothing in http-server mode."
+)
+parser.add_argument(
+    "--log",
+    type=str,
+    help="Agent log file to write the std out, resource, and step timing for each agent. Also used to load logs from a file with the load action.",
 )
 
 
 def render(args, env):
-    mode = utils.get(args.render, str, "json", path=["mode"])
-    if mode == "human" or mode == "ansi":
+    mode = args.display if args.display is not None else utils.get(args.render, str, "json", path=["mode"])
+
+    if mode == "human" or mode == "ansi" or mode == "txt":
         args.render["mode"] = "ansi"
     elif mode == "ipython" or mode == "html":
         args.render["mode"] = "html"
+    elif mode == "webm" or mode == "video":
+        args.render["mode"] = "webm"
     else:
         args.render["mode"] = "json"
-    return env.render(**args.render)
+    result = env.render(**args.render)
+    return result
 
 
 def action_list(args):
@@ -66,77 +100,180 @@ def action_list(args):
 
 
 def action_evaluate(args):
-    return json.dumps(
-        evaluate(
-            args.environment, args.agents, args.configuration, args.steps, args.episodes
-        )
-    )
+    return json.dumps(evaluate(args.environment, args.agents, args.configuration, args.steps, args.episodes))
+
+
+cached_agent = None
+
+
+def action_act(args):
+    global cached_agent
+    if len(args.agents) != 1:
+        return {"error": "One agent must be provided."}
+    raw = args.agents[0]
+
+    env = make(args.environment, args.configuration, args.info, state=args.state, debug=args.debug)
+
+    is_first_run = cached_agent is None or cached_agent.raw != raw
+    if is_first_run:
+        cached_agent = Agent(raw, env)
+    observation = utils.get(args.state, dict, {}, ["observation"])
+    action, log = cached_agent.act(observation)
+    if isinstance(action, errors.DeadlineExceeded):
+        action = "DeadlineExceeded"
+    elif isinstance(action, BaseException):
+        action = "BaseException::" + str(action)
+
+    if args.log_path is not None:
+        with open(args.log_path, mode="a") as log_file:
+            if not is_first_run:
+                log_file.write(",\n ")
+            json.dump([log], log_file)
+
+    return {"action": action}
 
 
 def action_step(args):
-    env = make(args.environment, args.configuration, args.steps, args.debug)
-    env.step(env.__get_actions(args.agents))
+    env = {"logs": args.logs}
+    try:
+        env = make(args.environment, args.configuration, args.info, args.steps, args.logs, args.debug)
+        runner = env.__agent_runner(args.agents)
+        env.step(runner.act())
+    finally:
+        if args.log_path is not None:
+            with open(args.log_path, mode="a") as log_file:
+                json.dump(env.logs[-1], log_file)
+                log_file.write(",")
     return render(args, env)
 
 
 def action_run(args):
-    env = make(args.environment, args.configuration, args.steps, args.debug)
-    env.run(args.agents)
+    # Create a fake env so we can make the real env in our try body
+    env = utils.structify({"logs": args.logs})
+    try:
+        env = make(args.environment, args.configuration, args.info, args.steps, args.logs, args.debug)
+        env.run(args.agents)
+    finally:
+        if args.log_path is not None:
+            with open(args.log_path, mode="w") as log_file:
+                json.dump(env.logs, log_file, indent=2)
     return render(args, env)
 
 
 def action_load(args):
-    env = make(args.environment, args.configuration, args.steps, args.debug)
+    if args.log_path is not None:
+        with open(args.log_path, mode="r") as log_file:
+            args.logs = json.load(log_file)
+
+    if args.in_path is not None:
+        with open(args.in_path, mode="r") as replay_file:
+            json_args = json.load(replay_file)
+        env = make(
+            json_args["name"], json_args["configuration"], json_args["info"], json_args["steps"], args.logs, args.debug
+        )
+    else:
+        env = make(args.environment, args.configuration, args.info, args.steps, args.logs, args.debug)
     return render(args, env)
 
 
-def action_handler(args):
-    args = utils.structify(
+disposed = True
+
+
+# This method is only called at the end of an episode to write the final array brace in the logs file and dispose the cached agent to force reinitialization
+def action_dispose(args):
+    global cached_agent, disposed
+    if disposed:
+        return "Already disposed"
+
+    cached_agent = None
+    if args.log_path is not None:
+        with open(args.log_path, mode="a") as log_file:
+            log_file.write("]")
+    disposed = True
+    return "Successfully disposed"
+
+
+def parse_args(args):
+    return utils.structify(
         {
             "action": utils.get(args, str, "list", ["action"]),
             "agents": utils.get(args, list, [], ["agents"]),
             "configuration": utils.get(args, dict, {}, ["configuration"]),
-            "environment": args.get("environment", None),
+            "environment": args.get("environment", args.get("name", None)),
             "episodes": utils.get(args, int, 1, ["episodes"]),
+            "state": utils.get(args, dict, {}, ["state"]),
             "steps": utils.get(args, list, [], ["steps"]),
+            "logs": utils.get(args, list, [], ["logs"]),
             "render": utils.get(args, dict, {"mode": "json"}, ["render"]),
-            "debug": utils.get(args, bool, False, ["debug"])
+            "display": utils.get(args, str, None, ["display"]),
+            "debug": utils.get(args, bool, False, ["debug"]),
+            "host": utils.get(args, str, "127.0.0.1", ["host"]),
+            "port": utils.get(args, int, 8000, ["port"]),
+            "in_path": utils.get(args, str, None, ["in"]),
+            "out_path": utils.get(args, str, None, ["out"]),
+            "log_path": utils.get(args, str, None, ["log"]),
+            "info": utils.get(args, dict, {}, ["info"]),
         }
     )
 
-    for index, agent in enumerate(args.agents):
-        agent = utils.read_file(agent, agent)
-        args.agents[index] = utils.get_last_callable(agent, agent)
-
-    if args.action == "list":
-        return action_list(args)
-
-    if args.environment == None:
-        return {"error": "Environment required."}
 
+def action_handler(args):
     try:
+        if args.action == "list":
+            return action_list(args)
         if args.action == "http-server":
             return {"error": "Already running a http server."}
-        elif args.action == "evaluate":
+        if args.action == "act":
+            return action_act(args)
+        if args.action == "dispose":
+            return action_dispose(args)
+        if args.action == "load":
+            return action_load(args)
+
+        if args.environment is None:
+            return {"error": "Environment required."}
+
+        if args.action == "evaluate":
             return action_evaluate(args)
-        elif args.action == "step":
+        if args.action == "step":
             return action_step(args)
-        elif args.action == "run":
+        if args.action == "run":
             return action_run(args)
-        elif args.action == "load":
-            return action_load(args)
-        else:
-            return {"error": "Unknown Action"}
+
+        return {"error": "Unknown Action"}
     except Exception as e:
         return {"error": str(e), "trace": traceback.format_exc()}
 
 
+log_path: Optional[str] = None
+
+
 def action_http(args):
     from flask import Flask, request
 
+    if args.log_path is not None:
+        global log_path
+        log_path = args.log_path
+
+    # Setup logging to console for Flask
+    dictConfig(
+        {
+            "version": 1,
+            "formatters": {
+                "default": {
+                    "format": "%(levelname)s: %(message)s",
+                }
+            },
+            "handlers": {
+                "wsgi": {"class": "logging.StreamHandler", "stream": "ext://sys.stdout", "formatter": "default"}
+            },
+            "root": {"level": "INFO", "handlers": ["wsgi"]},
+        }
+    )
+
     app = Flask(__name__, static_url_path="", static_folder="")
     app.route("/", methods=["GET", "POST"])(lambda: http_request(request))
-    app.run("127.0.0.1", 8000, debug=True)
+    app.run(args.host, args.port, debug=args.debug, use_reloader=args.debug)
 
 
 def http_request(request):
@@ -151,10 +288,9 @@ def http_request(request):
             "Access-Control-Max-Age": "3600",
         }
 
-        return ("", 204, headers)
+        return "", 204, headers
 
     headers = {"Access-Control-Allow-Origin": "*"}
-
     params = request.args.to_dict()
     for key in list(params.keys()):
         if key.endswith("[]"):
@@ -166,11 +302,39 @@ def http_request(request):
 
     body = request.get_json(silent=True, force=True) or {}
     args = {**params, **body}
-    return (action_handler(args), 200, headers)
+    if "render" in args and isinstance(args["render"], str):
+        # Manually deserialize render argument
+        # We should eventually refactor this to use the same deserializer as the cmd line arg parser
+        args["render"] = json.loads(args["render"])
+    args = parse_args(args)
+    if args.log_path is None:
+        args.log_path = log_path
+
+    global disposed
+    # Write the opening array brace for the logs file if there is a logs file.
+    if disposed and args["action"] != "dispose" and args.log_path is not None:
+        with open(args.log_path, mode="w") as log_file:
+            log_file.write("[")
+        disposed = False
+
+    resp = action_handler(args)
+    return resp, 200, headers
+
+
+def main():
+    args = parse_args(vars(parser.parse_args()))
+    if args.action == "http-server":
+        action_http(args)
+    else:
+        result = action_handler(args)
+        if args.out_path is None:
+            print(result)
+        else:
+            with open(args.out_path, encoding="utf-8", mode="w") as out_file:
+                out_file.write(str(result))
+
+        return 0
 
 
 if __name__ == "__main__":
-    args = parser.parse_args()
-    if args.action == "http-server":
-        action_http(args)
-    print(action_handler(vars(args)))
+    main()

kaggle_environments/schemas.json

@@ -62,29 +62,17 @@
         "minimum": 1,
         "default": 1000
       },
-      "agentExec": {
-        "description": "How the agent is executed alongside the running envionment.",
-        "type": "string",
-        "default": "PROCESS",
-        "enum": ["LOCAL", "PROCESS"]
-      },
-      "agentTimeout": {
-        "description": "Maximum runtime (seconds) to initialize an agent.",
-        "type": "integer",
-        "minimum": 1,
-        "default": 10
-      },
       "actTimeout": {
         "description": "Maximum runtime (seconds) to obtain an action from an agent.",
-        "type": "integer",
-        "minimum": 1,
-        "default": 2
+        "type": "number",
+        "minimum": 0,
+        "default": 6
       },
       "runTimeout": {
         "description": "Maximum runtime (seconds) of an episode (not necessarily DONE).",
-        "type": "integer",
-        "minimum": 1,
-        "default": 600
+        "type": "number",
+        "minimum": 0,
+        "default": 1200
       }
     }
   },
@@ -110,6 +98,23 @@
       "observation": {
         "description": "Observation to create an action based upon.",
         "type": "object",
+        "additionalProperties": true,
+        "properties": {
+          "remainingOverageTime": {
+            "description": "Total remaining banked time (seconds) that can be used in excess of per-step actTimeouts -- agent is disqualified with TIMEOUT status when this drops below 0.",
+            "shared": false,
+            "type": "number",
+            "minimum": 0,
+            "default": 12
+          },
+          "step": {
+            "description": "Current step within the episode.",
+            "type": "integer",
+            "shared": true,
+            "minimum": 0,
+            "default": 0
+          }
+        },
         "default": {}
       },
       "status": {