kaggle-environments 1.14.1__tar.gz → 1.14.5__tar.gz

{kaggle-environments-1.14.1/kaggle_environments.egg-info → kaggle-environments-1.14.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaggle-environments
-Version: 1.14.1
+Version: 1.14.5
 Summary: Kaggle Environments
 Home-page: https://github.com/Kaggle/kaggle-environments
 Author: Kaggle

{kaggle-environments-1.14.1 → kaggle-environments-1.14.5}/kaggle_environments/__init__.py

@@ -21,7 +21,7 @@ from .main import http_request
 from . import errors
 from . import utils
 
-__version__ = "1.14.1"
+__version__ = "1.14.5"
 
 __all__ = ["Agent", "environments", "errors", "evaluate", "http_request",
            "make", "register", "utils", "__version__",

{kaggle-environments-1.14.1 → kaggle-environments-1.14.5}/kaggle_environments/envs/llm_20_questions/llm_20_questions.json

@@ -7,6 +7,7 @@
     "configuration": {
       "episodeSteps": 61,
       "actTimeout": 60,
+      "runTimeout": 9600,
       "agentTimeout": {
         "description": "Obsolete field kept for backwards compatibility, please use observation.remainingOverageTime.",
         "type": "number",
@@ -68,4 +69,4 @@
       "defaults": ["ACTIVE", "INACTIVE", "ACTIVE", "INACTIVE"]
     }
   }
-  
+  

{kaggle-environments-1.14.1 → kaggle-environments-1.14.5}/kaggle_environments/envs/llm_20_questions/llm_20_questions.py

@@ -20,6 +20,17 @@ model = None
 tokenizer = None
 model_initialized = False
 
+ERROR = "ERROR"
+DONE = "DONE"
+INACTIVE = "INACTIVE"
+ACTIVE = "ACTIVE"
+TIMEOUT = "TIMEOUT"
+
+GUESS = "guess"
+ASK = "ask"
+GUESSER = "guesser"
+ANSWERER = "guesser"
+
 keywords_list = json.loads(KEYWORDS_JSON)
 keyword_cat = random.choice(keywords_list)
 category = keyword_cat["category"]
@@ -42,12 +53,12 @@ def guesser_agent(obs):
         )
 
     prompt = ""
-    if obs.turnType == "ask":
+    if obs.turnType == ASK:
         prompt = "{}{}".format(
             info_prompt.format(q_a_thread=q_a_thread),
             questions_prompt
         )
-    elif obs.turnType == "guess":
+    elif obs.turnType == GUESS:
         prompt = "{}{}".format(
             info_prompt.format(q_a_thread=q_a_thread),
             guess_prompt
@@ -73,7 +84,66 @@ def answerer_agent(obs):
         return ""
 
 
-agents = {"guesser": guesser_agent, "answerer": answerer_agent}
+agents = {GUESSER: guesser_agent, ANSWERER: answerer_agent}
+
+def guesser_action(active, inactive, step):
+    guessed = False
+    if not active.action:
+        active.status = ERROR
+    elif active.observation.turnType == ASK:
+        question = active.action[:2000]
+        active.observation.questions.append(question)
+        inactive.observation.questions.append(question)
+    elif active.observation.turnType == GUESS:
+        guess = active.action[:100]
+        active.observation.guesses.append(guess)
+        inactive.observation.guesses.append(guess)
+    if active.action and keyword_guessed(active.action):
+        guessed = True
+        score = 20 - int(step / 3)
+        end_game(active, inactive, score, DONE, DONE)
+    return guessed
+
+def end_game(active, inactive, reward, status, inactive_status):
+    active.observation.keyword = keyword
+    active.observation.category = category
+    inactive.observation.keyword = keyword
+    inactive.observation.category = category
+    active.reward = reward
+    inactive.reward = reward
+    active.status = status
+    inactive.status = inactive_status
+
+
+def answerer_action(active, inactive):
+    active.observation.keyword = keyword
+    active.observation.category = category
+    response = active.action
+    if not response:
+        response = "none"
+        end_game(active, inactive, -1, ERROR, DONE)
+    elif "yes" in response.lower():
+        response = "yes"
+    elif "no" in response.lower():
+        response = "no"
+    else:
+        response = "maybe"
+        end_game(active, inactive, -1, ERROR, DONE)
+    active.observation.answers.append(response)
+    inactive.observation.answers.append(response)
+
+def increment_turn(active, inactive, step, guessed):
+    if step == 59 and not guessed:
+        end_game(active, inactive, -1, DONE, DONE)
+    elif active.observation.turnType == "guess":
+        active.observation.turnType = "ask"
+    elif active.observation.turnType == "ask":
+        active.observation.turnType = "guess"
+        active.status = INACTIVE
+        inactive.status = ACTIVE
+    else:
+        active.status = INACTIVE
+        inactive.status = ACTIVE
 
 
 def interpreter(state, env):
@@ -81,14 +151,14 @@ def interpreter(state, env):
         return state
 
     # Isolate the active and inactive agents.
-    active1 = state[0] if state[0].status == "ACTIVE" else state[1]
-    inactive1 = state[0] if state[0].status == "INACTIVE" else state[1]
-    active2 = state[2] if state[2].status == "ACTIVE" else state[3]
-    inactive2 = state[2] if state[2].status == "INACTIVE" else state[3]
-    if active1.status == "DONE" and inactive1.status == "DONE":
+    active1 = state[0] if state[0].status == ACTIVE else state[1]
+    inactive1 = state[0] if state[0].status == INACTIVE else state[1]
+    active2 = state[2] if state[2].status == ACTIVE else state[3]
+    inactive2 = state[2] if state[2].status == INACTIVE else state[3]
+    if active1.status == DONE and inactive1.status == DONE:
         active1 = None
         inactive1 = None
-    if active2.status == "DONE" or inactive2.status == "DONE":
+    if active2.status == DONE or inactive2.status == DONE:
         active2 = None
         inactive2 = None
     if active1 is None and inactive1 is None and active2 is None and inactive2 is None:
@@ -96,110 +166,37 @@ def interpreter(state, env):
 
     step = state[0].observation.step
 
+    end_early = (active1 and active1.status) in (TIMEOUT, ERROR) or (active2 and active2.status in (TIMEOUT, ERROR))
+    either_guessed = False
+
     if active1 is not None:
         guessed = False
-        if active1.observation.role == "guesser":
-            if active1.observation.turnType == "ask":
-                active1.observation.questions.append(active1.action)
-                inactive1.observation.questions.append(active1.action)
-            elif active1.observation.turnType == "guess":
-                active1.observation.guesses.append(active1.action)
-                inactive1.observation.guesses.append(active1.action)
-            if keyword_guessed(active1.action):
-                guessed = True
-                score = 20 - int(step / 3)
-                active1.reward = score
-                inactive1.reward = score
-                active1.status = "DONE"
-                inactive1.status = "DONE"
-                active1.observation.keyword = keyword
-                active1.observation.category = category
-            inactive1.observation.keyword = keyword
-            inactive1.observation.category = category
+        if active1.observation.role == GUESSER:
+            guessed = guesser_action(active1, inactive1, step)
+            either_guessed = guessed
         else:
-            active1.observation.keyword = keyword
-            active1.observation.category = category
-            response = active1.action
-            if response.lower().__contains__("yes"):
-                response = "yes"
-            elif response.lower().__contains__("no"):
-                response = "no"
-            else:
-                response = "maybe"
-            active1.observation.answers.append(response)
-            inactive1.observation.answers.append(response)
-
-        if step == 59 and not guessed:
-            active1.observation.keyword = keyword
-            active1.observation.category = category
-            inactive1.observation.keyword = keyword
-            inactive1.observation.category = category
-            active1.reward = -1
-            inactive1.reward = -1
-            active1.status = "DONE"
-            inactive1.status = "DONE"
-        elif active1.observation.turnType == "guess":
-            active1.observation.turnType = "ask"
-        elif active1.observation.turnType == "ask":
-            active1.observation.turnType = "guess"
-            active1.status = "INACTIVE"
-            inactive1.status = "ACTIVE"
+            answerer_action(active1, inactive1)
+        if active1.status in (TIMEOUT, ERROR):
+            end_game(active1, inactive1, 0, active1.status, DONE)
+        elif end_early:
+            end_game(active1, inactive1, 0, DONE, DONE)
         else:
-            active1.status = "INACTIVE"
-            inactive1.status = "ACTIVE"
+            increment_turn(active1, inactive1, step, guessed)
     
     if active2 is not None:
         guessed = False
-        if active2.observation.role == "guesser":
-            if active2.observation.turnType == "ask":
-                active2.observation.questions.append(active2.action)
-                inactive2.observation.questions.append(active2.action)
-            elif active2.observation.turnType == "guess":
-                active2.observation.guesses.append(active2.action)
-                inactive2.observation.guesses.append(active2.action)
-            if keyword_guessed(active2.action):
-                guessed = True
-                score = 20 - int(step / 3)
-                active2.reward = score
-                inactive2.reward = score
-                active2.status = "DONE"
-                inactive2.status = "DONE"
-                active2.observation.keyword = keyword
-                active2.observation.category = category
-            inactive2.observation.keyword = keyword
-            inactive2.observation.category = category
+        if active2.observation.role == GUESSER:
+            guessed = guesser_action(active2, inactive2, step)
+            either_guessed = either_guessed or guessed
         else:
-            active2.observation.keyword = keyword
-            active2.observation.category = category
-            response = active2.action
-            if response.lower().__contains__("yes"):
-                response = "yes"
-            elif response.lower().__contains__("no"):
-                response = "no"
-            else:
-                response = "maybe"
-            active2.observation.answers.append(response)
-            inactive2.observation.answers.append(response)
-
-        if step == 59 and not guessed:
-            active2.observation.keyword = keyword
-            active2.observation.category = category
-            inactive2.observation.keyword = keyword
-            inactive2.observation.category = category
-            active2.reward = -1
-            inactive2.reward = -1
-            active2.status = "DONE"
-            inactive2.status = "DONE"
-        elif active2.observation.turnType == "guess":
-            active2.observation.turnType = "ask"
-        elif active2.observation.turnType == "ask":
-            active2.observation.turnType = "guess"
-            active2.status = "INACTIVE"
-            inactive2.status = "ACTIVE"
+            answerer_action(active2, inactive2)
+        if active2.status in (TIMEOUT, ERROR):
+            end_game(active2, inactive2, 0, active2.status, DONE)
+        elif end_early:
+            end_game(active2, inactive2, 0, DONE, DONE)
         else:
-            active2.status = "INACTIVE"
-            inactive2.status = "ACTIVE"
-
+            increment_turn(active2, inactive2, step, guessed)
+    
     return state
 
 
@@ -207,7 +204,7 @@ def renderer(state, env):
 
     for s in state:
         print("role: ", s.observation.role)
-        if s.observation.role == "guesser":
+        if s.observation.role == GUESSER:
             transcript = ""
             for i in range(0, len(s.observation.guesses)):
                 transcript = "{}Q: {} A: {}\nG: {}\n".format(

{kaggle-environments-1.14.1 → kaggle-environments-1.14.5}/kaggle_environments/envs/lux_ai_s2/lux_ai_s2.py

@@ -39,16 +39,13 @@ prev_step = 0
 luxenv: LuxAI_S2 = LuxAI_S2(verbose=0, validate_action_space=True, collect_stats=True)
 prev_obs = None
 state_obs = None
-def cleanup_dimensions():
-    global dimension_process
-    if dimension_process is not None:
-        dimension_process.kill()
+default_env_cfg = None
 def enqueue_output(out, queue):
     for line in iter(out.readline, b''):
         queue.put(line)
     out.close()
 def interpreter(state, env):
-    global luxenv, prev_obs, state_obs
+    global luxenv, prev_obs, state_obs, default_env_cfg
     player_0 = state[0]
     player_1 = state[1]
     # filter out actions such as debug annotations so they aren't saved
@@ -65,18 +62,29 @@ def interpreter(state, env):
         else:
             max_episode_length = 1000
 
-        parsed_env_config = copy.deepcopy(env.configuration)
-        parsed_env_config["max_episode_length"] = max_episode_length
-        delete_keys = ["seed", "episodeSteps", "actTimeout", "runTimeout", "env_cfg"]
         
-        for k in delete_keys:
-            if k in parsed_env_config: del parsed_env_config[k]
+        if default_env_cfg is None:
+            # if this is the first time creating the environment, env.configuration contains the kaggle competition configurations used to override 
+            # the default env config in LuxAI_S2. env.configuration is later populated by the merge of the kaggle competition configs with the 
+            # env config in LuxAI_S2 so we only run this branch once and save the result.
+            parsed_env_config = copy.deepcopy(env.configuration)
+            parsed_env_config["max_episode_length"] = max_episode_length
+            delete_keys = ["seed", "episodeSteps", "actTimeout", "runTimeout", "env_cfg"]
+            env_cfg_override = dict()
+            if "env_cfg" in parsed_env_config:
+                env_cfg_override = copy.deepcopy(parsed_env_config["env_cfg"])
+            for k in delete_keys:
+                if k in parsed_env_config: del parsed_env_config[k]
+            parsed_env_config = {**parsed_env_config, **env_cfg_override}
+            default_env_cfg = parsed_env_config
+        else:
+            parsed_env_config = default_env_cfg
         luxenv = LuxAI_S2(validate_action_space=True, collect_stats=True, **parsed_env_config)
         _, _ = luxenv.reset(seed=seed)
         state_obs = luxenv.state.get_compressed_obs()
 
         env_cfg_json = dataclasses.asdict(luxenv.env_cfg)
-        # del env_cfg_json["WEATHER_ID_TO_NAME"]
+
         env.configuration.env_cfg = env_cfg_json
         
         player_0.observation.player = "player_0"

{kaggle-environments-1.14.1 → kaggle-environments-1.14.5/kaggle_environments.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaggle-environments
-Version: 1.14.1
+Version: 1.14.5
 Summary: Kaggle Environments
 Home-page: https://github.com/Kaggle/kaggle-environments
 Author: Kaggle

{kaggle-environments-1.14.1 → kaggle-environments-1.14.5}/kaggle_environments.egg-info/requires.txt

@@ -4,5 +4,8 @@ jsonschema>=3.0.1
 numpy>=1.19.5
 pettingzoo==1.24.0
 requests>=2.25.1
+scipy>=1.11.2
+shimmy>=1.2.1
 stable-baselines3==2.1.0
+transformers>=4.33.1
 vec-noise>=1.1.4

{kaggle-environments-1.14.1 → kaggle-environments-1.14.5}/setup.py

@@ -55,6 +55,9 @@ setup(
         "pettingzoo == 1.24.0",
         "gymnasium == 0.29.0",
         "stable-baselines3 == 2.1.0",
+        "transformers >= 4.33.1",
+        "scipy >= 1.11.2",
+        "shimmy >= 1.2.1",
     ],
     packages=find_packages(),
     include_package_data=True,