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

kaggle_environments/core.py

@@ -14,11 +14,16 @@
 
 import copy
 import json
-from time import time
+import traceback
 import uuid
+from contextlib import redirect_stderr, redirect_stdout
+from io import StringIO
+from multiprocessing import Pool
+from time import perf_counter
+
 from .agent import Agent
-from .errors import DeadlineExceeded, FailedPrecondition, Internal, InvalidArgument
-from .utils import get, has, get_player, process_schema, schemas, structify
+from .errors import DeadlineExceeded, FailedPrecondition, InvalidArgument
+from .utils import get, get_player, has, process_schema, schemas, structify
 
 # Registered Environments.
 environments = {}
@@ -33,71 +38,137 @@ def register(name, environment):
      * specification - JSON Schema representing the environment.
      * interpreter - Function(state, environment) -> new_state
      * renderer - Function(state, environment) -> string
-     * html_renderer(optional) - JavaScript HTML renderer function.
+     * html_renderer - Function(environment) -> JavaScript HTML renderer function.
      * agents(optional) - List of default agents [Function(observation, config) -> action]
     """
     environments[name] = environment
 
 
-def evaluate(environment, agents=[], configuration={}, steps=[], num_episodes=1):
+def evaluate(environment, agents=None, configuration=None, steps=None, num_episodes=1, debug=False, state=None):
     """
     Evaluate and return the rewards of one or more episodes (environment and agents combo).
 
     Args:
-        environment (str|Environment): 
+        environment (str|Environment):
         agents (list):
         configuration (dict, optional):
         steps (list, optional):
         num_episodes (int=1, optional): How many episodes to execute (run until done).
+        debug (bool=False, optional): Render print() statments to stdout
+        state (optional)
 
     Returns:
         list of list of int: List of final rewards for all agents for all episodes.
     """
-    e = make(environment, configuration, steps)
-    rewards = [[]] * num_episodes
+    if agents is None:
+        agents = []
+    if configuration is None:
+        configuration = {}
+    if steps is None:
+        steps = []
+
+    e = make(environment, configuration, steps, debug=debug, state=state)
+    rewards = [[] for i in range(num_episodes)]
     for i in range(num_episodes):
         last_state = e.run(agents)[-1]
         rewards[i] = [state.reward for state in last_state]
     return rewards
 
 
-def make(environment, configuration={}, steps=[], debug=False):
+def make(environment, configuration=None, info=None, steps=None, logs=None, debug=False, state=None):
     """
     Creates an instance of an Environment.
 
     Args:
-        environment (str|Environment): 
+        environment (str|Environment):
         configuration (dict, optional):
+        info (dict, optional):
         steps (list, optional):
-        debug (bool=False, optional):
+        debug (bool=False, optional): Render print() statments to stdout
+        state (optional):
 
     Returns:
         Environment: Instance of a specific environment.
     """
+    if configuration is None:
+        configuration = {}
+    if info is None:
+        info = {}
+    if steps is None:
+        steps = []
+    if logs is None:
+        logs = []
+
     if has(environment, str) and has(environments, dict, path=[environment]):
-        return Environment(**environments[environment], configuration=configuration, steps=steps, debug=debug)
+        return Environment(
+            **environments[environment],
+            configuration=configuration,
+            info=info,
+            steps=steps,
+            logs=logs,
+            debug=debug,
+            state=state,
+        )
     elif callable(environment):
-        return Environment(interpreter=environment, configuration=configuration, steps=steps, debug=debug)
+        return Environment(
+            interpreter=environment,
+            configuration=configuration,
+            info=info,
+            steps=steps,
+            logs=logs,
+            debug=debug,
+            state=state,
+        )
     elif has(environment, path=["interpreter"], is_callable=True):
-        return Environment(**environment, configuration=configuration, steps=steps, debug=debug)
+        return Environment(
+            **environment, configuration=configuration, info=info, steps=steps, logs=logs, debug=debug, state=state
+        )
     raise InvalidArgument("Unknown Environment Specification")
 
 
-class Environment:
+def act_agent(args):
+    agent, state, configuration, none_action = args
+    if state["status"] != "ACTIVE":
+        return None, {}
+    elif agent is None:
+        return none_action, {}
+    else:
+        return agent.act(state["observation"])
 
+
+class Environment:
     def __init__(
         self,
-        specification={},
-        configuration={},
-        steps=[],
-        agents={},
+        specification=None,
+        configuration=None,
+        info=None,
+        steps=None,
+        logs=None,
+        agents=None,
         interpreter=None,
         renderer=None,
         html_renderer=None,
         debug=False,
+        state=None,
     ):
+        if specification is None:
+            specification = {}
+        if configuration is None:
+            configuration = {}
+        if info is None:
+            info = {}
+        if steps is None:
+            steps = []
+        if logs is None:
+            logs = []
+        if agents is None:
+            agents = {}
+
+        self.logs = logs
         self.id = str(uuid.uuid1())
         self.debug = debug
+        self.info = info
+        self.pool = None
 
         err, specification = self.__process_specification(specification)
         if err:
@@ -106,7 +177,7 @@ class Environment:
 
         err, configuration = process_schema(
             {"type": "object", "properties": self.specification.configuration},
-            {} if configuration == None else configuration,
+            {} if configuration is None else configuration,
         )
         if err:
             raise InvalidArgument("Configuration Invalid: " + err)
@@ -120,30 +191,37 @@ class Environment:
             raise InvalidArgument("Renderer is not Callable.")
         self.renderer = renderer
 
-        if callable(html_renderer):
-            html_renderer = html_renderer()
-        self.html_renderer = get(html_renderer, str, "")
+        if not callable(html_renderer):
+            raise InvalidArgument("Html_renderer is not Callable.")
+        self.html_renderer = html_renderer
 
         if not all([callable(a) for a in agents.values()]):
             raise InvalidArgument("Default agents must be Callable.")
         self.agents = structify(agents)
 
-        if steps == None or len(steps) == 0:
-            self.reset()
-        else:
+        if steps is not None and len(steps) > 0:
             self.__set_state(steps[-1])
             self.steps = steps[0:-1] + self.steps
+        elif state is not None:
+            step = [{}] * self.specification.agents[0]
+            step[0] = state
+            self.__set_state(step)
+        else:
+            self.reset()
 
-    def step(self, actions):
+    def step(self, actions, logs=None):
         """
         Execute the environment interpreter using the current state and a list of actions.
 
         Args:
             actions (list): Actions to pair up with the current agent states.
+            logs (list): Logs to pair up with each agent for the current step.
 
         Returns:
             list of dict: The agents states after the step.
         """
+        if logs is None:
+            logs = []
 
         if self.done:
             raise FailedPrecondition("Environment done, reset required.")
@@ -158,26 +236,27 @@ class Environment:
                 self.debug_print(f"Timeout: {str(action)}")
                 action_state[index]["status"] = "TIMEOUT"
             elif isinstance(action, BaseException):
-                self.debug_print(f"Error: {str(action)}")
+                self.debug_print(f"Error: {traceback.format_exception(None, action, action.__traceback__)}")
                 action_state[index]["status"] = "ERROR"
             else:
-                err, data = process_schema(
-                    self.__state_schema.properties.action, action)
+                err, data = process_schema(self.__state_schema.properties.action, action)
                 if err:
                     self.debug_print(f"Invalid Action: {str(err)}")
                     action_state[index]["status"] = "INVALID"
                 else:
                     action_state[index]["action"] = data
 
-        self.state = self.__run_interpreter(action_state)
+        self.state = self.__run_interpreter(action_state, logs)
 
         # Max Steps reached. Mark ACTIVE/INACTIVE agents as DONE.
-        if len(self.steps) == self.configuration.episodeSteps - 1:
+        if self.state[0].observation.step >= self.configuration.episodeSteps - 1:
             for s in self.state:
                 if s.status == "ACTIVE" or s.status == "INACTIVE":
                     s.status = "DONE"
 
         self.steps.append(self.state)
+        if logs is not None:
+            self.logs.append(logs)
 
         return self.state
 
@@ -189,19 +268,25 @@ class Environment:
             agents (list of any): List of agents to obtain actions from.
 
         Returns:
-            list of list of dict: The agent states of all steps executed.
+            tuple of:
+                list of list of dict: The agent states of all steps executed.
+                list of list of dict: The agent logs of all steps executed.
         """
-        if self.state == None or len(self.steps) == 1 or self.done:
+        if self.state is None or len(self.steps) == 1 or self.done:
             self.reset(len(agents))
         if len(self.state) != len(agents):
-            raise InvalidArgument(
-                f"{len(self.state)} agents were expected, but {len(agents)} was given.")
+            raise InvalidArgument(f"{len(self.state)} agents were expected, but {len(agents)} was given.")
 
         runner = self.__agent_runner(agents)
-        start = time()
-        while not self.done and time() - start < self.configuration.runTimeout:
-            self.step(runner.act())
-        runner.destroy()
+        start = perf_counter()
+        while not self.done and perf_counter() - start < self.configuration.runTimeout:
+            actions, logs = runner.act()
+            self.step(actions, logs)
+        if not self.done and perf_counter() - start >= self.configuration.runTimeout:
+            raise DeadlineExceeded(
+                f"runtime of {perf_counter() - start} exceeded the runTimeout of {self.configuration.runTimeout}"
+            )
+
         return self.steps
 
     def reset(self, num_agents=None):
@@ -215,7 +300,7 @@ class Environment:
             list of dict: The agents states after the reset.
         """
 
-        if num_agents == None:
+        if num_agents is None:
             num_agents = self.specification.agents[0]
 
         # Get configuration default state.
@@ -225,7 +310,9 @@ class Environment:
         for agent in self.state:
             agent.status = "INACTIVE"
         # Give the interpreter an opportunity to make any initializations.
-        self.__set_state(self.__run_interpreter(self.state))
+        logs = []
+        self.__set_state(self.__run_interpreter(self.state, logs))
+        self.logs.append(logs)
         # Replace the starting "status" if still "done".
         if self.done and len(self.state) == len(statuses):
             for i in range(len(self.state)):
@@ -247,35 +334,40 @@ class Environment:
         mode = get(kwargs, str, "human", path=["mode"])
         if mode == "ansi" or mode == "human":
             args = [self.state, self]
-            out = self.renderer(*args[:self.renderer.__code__.co_argcount])
+            out = self.renderer(*args[: self.renderer.__code__.co_argcount])
             if mode == "ansi":
                 return out
-            print(out)
         elif mode == "html" or mode == "ipython":
+            is_playing = get(kwargs, bool, self.done, path=["playing"])
             window_kaggle = {
                 "debug": get(kwargs, bool, self.debug, path=["debug"]),
-                "autoplay": get(kwargs, bool, self.done, path=["autoplay"]),
-                "step": 0 if get(kwargs, bool, self.done, path=["autoplay"]) else (len(self.steps) - 1),
+                "playing": is_playing,
+                "step": 0 if is_playing else len(self.steps) - 1,
                 "controls": get(kwargs, bool, self.done, path=["controls"]),
                 "environment": self.toJSON(),
+                "logs": self.logs,
                 **kwargs,
             }
-            player_html = get_player(window_kaggle, self.html_renderer)
+            args = [self]
+            player_html = get_player(
+                window_kaggle, self.html_renderer(*args[: self.html_renderer.__code__.co_argcount])
+            )
             if mode == "html":
                 return player_html
-            from IPython.display import display, HTML
-            player_html = player_html.replace('"', '&quot;')
+
+            from IPython.display import HTML, display
+
+            player_html = player_html.replace('"', "&quot;")
             width = get(kwargs, int, 300, path=["width"])
             height = get(kwargs, int, 300, path=["height"])
             html = f'<iframe srcdoc="{player_html}" width="{width}" height="{height}" frameborder="0"></iframe> '
             display(HTML(html))
         elif mode == "json":
-            return json.dumps(self.toJSON(), sort_keys=True)
+            return json.dumps(self.toJSON(), sort_keys=True, indent=2 if self.debug else None)
         else:
-            raise InvalidArgument(
-                "Available render modes: human, ansi, html, ipython")
+            raise InvalidArgument("Available render modes: human, ansi, html, ipython")
 
-    def play(self, agents=[], **kwargs):
+    def play(self, agents=None, **kwargs):
         """
         Renders a visual representation of the environment and allows interactive action selection.
 
@@ -285,12 +377,15 @@ class Environment:
         Returns:
             None: prints directly to an IPython notebook
         """
+        if agents is None:
+            agents = []
+
         env = self.clone()
         trainer = env.train(agents)
         interactives[env.id] = (env, trainer)
         env.render(mode="ipython", interactive=True, **kwargs)
 
-    def train(self, agents=[]):
+    def train(self, agents=None):
         """
         Setup a lightweight training environment for a single agent.
         Note: This is designed to be a lightweight starting point which can
@@ -318,43 +413,41 @@ class Environment:
             `dict`.reset: Reset def that reset the environment, then advances until the agents turn.
             `dict`.step: Steps using the agent action, then advance until agents turn again.
         """
+        if agents is None:
+            agents = []
+
         runner = None
         position = None
         for index, agent in enumerate(agents):
-            if agent == None:
-                if position != None:
-                    raise InvalidArgument(
-                        "Only one agent can be marked 'None'")
+            if agent is None:
+                if position is not None:
+                    raise InvalidArgument("Only one agent can be marked 'None'")
                 position = index
 
-        if position == None:
+        if position is None:
             raise InvalidArgument("One agent must be marked 'None' to train.")
 
         def advance():
             while not self.done and self.state[position].status == "INACTIVE":
-                self.step(runner.act())
+                actions, logs = runner.act()
+                self.step(actions, logs)
 
         def reset():
             nonlocal runner
             self.reset(len(agents))
-            if runner != None:
-                runner.destroy()
             runner = self.__agent_runner(agents)
             advance()
-            return self.state[position].observation
+            return self.__get_shared_state(position).observation
 
         def step(action):
-            self.step(runner.act(action))
+            actions, logs = runner.act(action)
+            self.step(actions, logs)
             advance()
-            agent = self.state[position]
+            agent = self.__get_shared_state(position)
             reward = agent.reward
-            if len(self.steps) > 1 and reward != None:
+            if len(self.steps) > 1 and reward is not None:
                 reward -= self.steps[-2][position].reward
-            if self.done:
-                runner.destroy()
-            return [
-                agent.observation, reward, agent.status != "ACTIVE", agent.info
-            ]
+            return [agent.observation, reward, agent.status != "ACTIVE", agent.info]
 
         reset()
 
@@ -395,12 +488,13 @@ class Environment:
                     "configuration": spec.configuration,
                     "info": spec.info,
                     "observation": spec.observation,
-                    "reward": spec.reward
+                    "reward": spec.reward,
                 },
                 "steps": self.steps,
                 "rewards": [state.reward for state in self.steps[-1]],
                 "statuses": [state.status for state in self.steps[-1]],
                 "schema_version": 1,
+                "info": self.info,
             }
         )
 
@@ -427,44 +521,35 @@ class Environment:
             self.__state_schema_value = {
                 **schemas["state"],
                 "properties": {
-                    "action": {
-                        **schemas.state.properties.action,
-                        **get(spec, dict, path=["action"], fallback={})
-                    },
-                    "reward": {
-                        **schemas.state.properties.reward,
-                        **get(spec, dict, path=["reward"], fallback={})
-                    },
+                    "action": {**schemas.state.properties.action, **get(spec, dict, path=["action"], fallback={})},
+                    "reward": {**schemas.state.properties.reward, **get(spec, dict, path=["reward"], fallback={})},
                     "info": {
                         **schemas.state.properties.info,
-                        "properties": get(spec, dict, path=["info"], fallback={})
+                        "properties": get(spec, dict, path=["info"], fallback={}),
                     },
                     "observation": {
                         **schemas.state.properties.observation,
-                        "properties": get(spec, dict, path=["observation"], fallback={})
-                    },
-                    "status": {
-                        **schemas.state.properties.status,
-                        **get(spec, dict, path=["status"], fallback={})
+                        "properties": get(spec, dict, path=["observation"], fallback={}),
                     },
+                    "status": {**schemas.state.properties.status, **get(spec, dict, path=["status"], fallback={})},
                 },
             }
         return structify(self.__state_schema_value)
 
-    def __set_state(self, state=[]):
+    def __set_state(self, state=None):
+        if state is None:
+            state = []
+
         if len(state) not in self.specification.agents:
-            raise InvalidArgument(
-                f"{len(state)} is not a valid number of agent(s).")
+            raise InvalidArgument(f"{len(state)} is not a valid number of agent(s).")
 
-        self.state = structify([self.__get_state(index, s)
-                                for index, s in enumerate(state)])
+        self.state = structify([self.__get_state(index, s) for index, s in enumerate(state)])
         self.steps = [self.state]
         return self.state
 
     def __get_state(self, position, state):
         key = f"__state_schema_{position}"
         if not hasattr(self, key):
-
             # Update a property default value based on position in defaults.
             # Remove shared properties from non-first agents.
             def update_props(props):
@@ -479,32 +564,79 @@ class Environment:
                         update_props(prop["properties"])
                 return props
 
-            props = structify(update_props(
-                copy.deepcopy(self.__state_schema.properties)))
+            props = structify(update_props(copy.deepcopy(self.__state_schema.properties)))
 
             setattr(self, key, {**self.__state_schema, "properties": props})
 
         err, data = process_schema(getattr(self, key), state)
         if err:
-            raise InvalidArgument(
-                f"Default state generation failed for #{position}: " + err
-            )
+            raise InvalidArgument(f"Default state generation failed for #{position}: " + err)
         return data
 
-    def __run_interpreter(self, state):
+    def __loop_through_interpreter(self, state, logs):
+        args = [structify(state), self, logs]
+        new_state = structify(self.interpreter(*args[: self.interpreter.__code__.co_argcount]))
+        new_state[0].observation.step = 0 if self.done else len(self.steps)
+
+        for index, agent in enumerate(new_state):
+            if index < len(logs) and "duration" in logs[index]:
+                duration = logs[index]["duration"]
+                overage_time_consumed = max(0, duration - self.configuration.actTimeout)
+                agent.observation.remainingOverageTime -= overage_time_consumed
+            if agent.status not in self.__state_schema.properties.status.enum:
+                self.debug_print(f"Invalid Action: {agent.status}")
+                agent.status = "INVALID"
+            if agent.status in ["ERROR", "INVALID", "TIMEOUT"]:
+                agent.reward = None
+        return new_state
+
+    def __run_interpreter_prod(self, state, logs):
+        out = None
+        err = None
         try:
-            args = [structify(state), self]
-            new_state = structify(self.interpreter(
-                *args[:self.interpreter.__code__.co_argcount]))
-            for agent in new_state:
-                if agent.status not in self.__state_schema.properties.status.enum:
-                    self.debug_print(f"Invalid Action: {agent.status}")
-                    agent.status = "INVALID"
-                if agent.status in ["ERROR", "INVALID", "TIMEOUT"]:
-                    agent.reward = None
-            return new_state
-        except Exception as err:
-            raise Internal("Error running environment: " + str(err))
+            with (
+                StringIO() as out_buffer,
+                StringIO() as err_buffer,
+                redirect_stdout(out_buffer),
+                redirect_stderr(err_buffer),
+            ):
+                try:
+                    new_state = self.__loop_through_interpreter(state, logs)
+                    return new_state
+                except Exception as e:
+                    # Print the exception stack trace to our log
+                    traceback.print_exc(file=err_buffer)
+                    # Reraise e to ensure that the program exits
+                    raise e
+                finally:
+                    out = out_buffer.getvalue()
+                    err = err_buffer.getvalue()
+
+                    # strip if needed
+                    # Allow up to 10k (default) log characters per step which is ~10MB per 600 step episode
+                    max_log_length = self.configuration.get("maxLogLength", 10000)
+                    if max_log_length is not None:
+                        out = out[0:max_log_length]
+                        err = err[0:max_log_length]
+
+                    if out or err:
+                        logs.append({"stdout": out, "stderr": err})
+        finally:
+            if out:
+                while out.endswith("\n"):
+                    out = out[:-1]
+                self.debug_print(out)
+            if err:
+                while err.endswith("\n"):
+                    err = err[:-1]
+                self.debug_print(err)
+
+    def __run_interpreter(self, state, logs):
+        # Append any environmental logs to any agent logs we collected.
+        if self.debug:
+            return self.__loop_through_interpreter(state, logs)
+        else:
+            return self.__run_interpreter_prod(state, logs)
 
     def __process_specification(self, spec):
         if has(spec, path=["reward"]):
@@ -514,86 +646,79 @@ class Environment:
                 return ("type must be an integer or number", None)
             reward["type"] = [reward_type, "null"]
 
-        # Allow environments to extend the default configuration.
-        configuration = copy.deepcopy(
-            schemas["configuration"]["properties"])
-
-        for k, v in get(spec, dict, {}, ["configuration"]).items():
-            # Set a new default value.
-            if not isinstance(v, dict):
-                if not has(configuration, path=[k]):
-                    raise InvalidArgument(
-                        f"Configuration was unable to set default of missing property: {k}")
-                configuration[k]["default"] = v
-            # Add a new configuration.
-            elif not has(configuration, path=[k]):
-                configuration[k] = v
-            # Override an existing configuration if types match.
-            elif configuration[k]["type"] == get(v, path=["type"]):
-                configuration[k] = v
-            # Types don't match - unable to extend.
-            else:
-                raise InvalidArgument(
-                    f"Configuration was unable to extend: {k}")
+        # Allow environments to extend various parts of the specification.
+        def extend_specification(source, field_name):
+            field = copy.deepcopy(source[field_name]["properties"])
+            for k, v in get(spec, dict, {}, [field_name]).items():
+                # Set a new default value.
+                if not isinstance(v, dict):
+                    if not has(field, path=[k]):
+                        raise InvalidArgument(f"Field {field} was unable to set default of missing property: {k}")
+                    field[k]["default"] = v
+                # Add a new field.
+                elif not has(field, path=[k]):
+                    field[k] = v
+                # Override an existing field if types match.
+                elif field[k]["type"] == get(v, path=["type"]):
+                    field[k] = v
+                # Types don't match - unable to extend.
+                else:
+                    raise InvalidArgument(f"Field {field} was unable to extend: {k}")
+
+            spec[field_name] = field
+
+        extend_specification(schemas, "configuration")
+        extend_specification(schemas["state"]["properties"], "observation")
 
-        spec["configuration"] = configuration
         return process_schema(schemas.specification, spec)
 
     def __agent_runner(self, agents):
-        # Replace default agents with their source.
-        for i, agent in enumerate(agents):
-            if has(self.agents, path=[agent]):
-                agents[i] = self.agents[agent]
-
         # Generate the agents.
-        agents = [Agent(a, self.configuration) if a !=
-                  None else None for a in agents]
-
-        # Have the agents had a chance to initialize (first non-empty act).
-        initialized = [False] * len(agents)
+        agents = [Agent(agent, self) if agent is not None else None for agent in agents]
 
         def act(none_action=None):
             if len(agents) != len(self.state):
-                raise InvalidArgument(
-                    "Number of agents must match the state length")
-
-            actions = [0] * len(agents)
-            for i, agent in enumerate(agents):
-                if self.state[i]["status"] != "ACTIVE":
-                    actions[i] = None
-                elif agent == None:
-                    actions[i] = none_action
-                else:
-                    timeout = self.configuration.actTimeout
-                    if not initialized[i]:
-                        initialized[i] = True
-                        timeout += self.configuration.agentTimeout
-                    state = self.__get_shared_state(i)
-                    actions[i] = agent.act(state, timeout)
-            return actions
+                raise InvalidArgument("Number of agents must match the state length")
+
+            act_args = [
+                (
+                    agent,
+                    self.__get_shared_state(i),
+                    self.configuration,
+                    none_action,
+                )
+                for i, agent in enumerate(agents)
+            ]
 
-        def destroy():
-            for a in agents:
-                if a != None:
-                    a.destroy()
+            if all((agent is None or agent.is_parallelizable) for agent in agents):
+                if self.pool is None:
+                    self.pool = Pool(processes=len(agents))
+                results = self.pool.map(act_agent, act_args)
+            else:
+                results = list(map(act_agent, act_args))
 
-        return structify({"act": act, "destroy": destroy})
+            # results is a list of tuples where the first element is an agent action and the second is the agent log
+            # This destructures into two lists, a list of actions and a list of logs.
+            actions, logs = zip(*results)
+            return list(actions), list(logs)
 
-    def __get_shared_state(self, position):
-        if position == 0:
-            return self.state[0]
-        state = copy.deepcopy(self.state[position])
+        return structify({"act": act})
 
+    def __get_shared_state(self, position):
         # Note: state and schema are required to be in sync (apart from shared ones).
         def update_props(shared_state, state, schema_props):
             for k, prop in schema_props.items():
-                if get(prop, bool, path=["shared"], fallback=False):
+                # Hidden fields are tracked in the episode replay but are not provided to the agent at runtime
+                if get(prop, bool, path=["hidden"], fallback=False):
+                    if k in state:
+                        del state[k]
+                elif get(prop, bool, path=["shared"], fallback=False):
                     state[k] = shared_state[k]
                 elif has(prop, dict, path=["properties"]):
                     update_props(shared_state[k], state[k], prop["properties"])
             return state
 
-        return update_props(self.state[0], state, self.__state_schema.properties)
+        return update_props(self.state[0], copy.deepcopy(self.state[position]), self.__state_schema.properties)
 
     def debug_print(self, message):
         if self.debug: