unienv 0.0.1b1__py3-none-any.whl → 0.0.1b3__py3-none-any.whl

unienv_interface/world/combined_node.py

@@ -0,0 +1,232 @@
+from typing import Optional, Dict, Mapping, Any, Tuple, Union, Iterable
+from unienv_interface.backends import ComputeBackend, BArrayType, BDeviceType, BDtypeType, BRNGType
+from unienv_interface.space import Space, DictSpace
+from unienv_interface.utils.control_util import find_best_timestep
+
+from .world import World
+from .node import WorldNode, ContextType, ObsType, ActType
+
+CombinedDataT = Union[Dict[str, Any], BArrayType]
+
+class CombinedWorldNode(WorldNode[
+    Optional[CombinedDataT], CombinedDataT, CombinedDataT,
+    BArrayType, BDeviceType, BDtypeType, BRNGType
+]):
+    """
+    A WorldNode that combines multiple WorldNodes into one node, using a dictionary to store the data from each node.
+    The observation, reward, termination, truncation, and info are combined from all child nodes.
+    The keys in the dictionary are the names of the child nodes.
+    If there is only one child node that supports value and `direct_return` is set to True, the value is returned directly instead of a dictionary.
+    """
+
+    def __init__(
+        self,
+        name : str,
+        nodes : Iterable[WorldNode[WorldNode[Any, Any, Any, BArrayType, BDeviceType, BDtypeType, BRNGType], Any, Any, BArrayType, BDeviceType, BDtypeType, BRNGType]],
+        direct_return : bool = True,
+    ):
+        nodes = list(nodes)
+        if len(nodes) == 0:
+            raise ValueError("At least one node is required to create a CombinedWorldNode.")
+        
+        # Check that all nodes have the same world
+        first_node = nodes[0]
+        for node in nodes[1:]:
+            assert node.world is first_node.world, "All nodes must belong to the same world."
+            assert node.control_timestep == first_node.control_timestep, "All nodes must have the same control timestep."
+        # Check that all nodes have unique names
+        names = [node.name for node in nodes]
+        if len(names) != len(set(names)):
+            raise ValueError("All nodes must have unique names.")
+        self.nodes = nodes
+
+        # Aggregate Spaces
+        _, self.context_space = self.aggregate_spaces(
+            {node.name: node.context_space for node in nodes if node.context_space is not None},
+            direct_return=direct_return,
+        )
+        _, self.observation_space = self.aggregate_spaces(
+            {node.name: node.observation_space for node in nodes if node.observation_space is not None},
+            direct_return=direct_return,
+        )
+        self._action_node_name_direct, self.action_space = self.aggregate_spaces(
+            {node.name: node.action_space for node in nodes if node.action_space is not None},
+            direct_return=direct_return,
+        )
+        self.has_reward = any(node.has_reward for node in nodes)
+        self.has_termination_signal = any(node.has_termination_signal for node in nodes)
+        self.has_truncation_signal = any(node.has_truncation_signal for node in nodes)
+
+        # Save attributes
+        self.name = name
+        self.direct_return = direct_return
+
+    @staticmethod
+    def aggregate_spaces(
+        spaces : Dict[str, Optional[Space[Any, BDeviceType, BDtypeType, BRNGType]]],
+        direct_return : bool = True,
+    ) -> Tuple[
+        Optional[str],
+        Optional[DictSpace[BDeviceType, BDtypeType, BRNGType]]
+    ]:
+        if len(spaces) == 0:
+            return None, None
+        elif len(spaces) == 1 and direct_return:
+            return next(iter(spaces.items()))
+        else:
+            backend = next(iter(spaces.values())).backend
+            return None, DictSpace(
+                backend,
+                {
+                    name: space for name, space in spaces.items() if space is not None
+                }
+            )
+
+    @staticmethod
+    def aggregate_data(
+        data : Dict[str, Any],
+        direct_return : bool = True,
+    ) -> Optional[Union[Dict[str, Any], Any]]:
+        if len(data) == 0:
+            return None
+        elif len(data) == 1 and direct_return:
+            return next(iter(data.values()))
+        else:
+            return data
+
+    @property
+    def world(self) -> World[BArrayType, BDeviceType, BDtypeType, BRNGType]:
+        return self.nodes[0].world
+    
+    @property
+    def control_timestep(self) -> Optional[float]:
+        return self.nodes[0].control_timestep
+    
+    def pre_environment_step(self, dt):
+        for node in self.nodes:
+            node.pre_environment_step(dt)
+    
+    def get_observation(self):
+        assert self.observation_space is not None, "Observation space is None, cannot get observation."
+        return self.aggregate_data(
+            {
+                node.name: node.get_observation() 
+                for node in self.nodes 
+                if node.observation_space is not None
+            },
+            direct_return=self.direct_return,
+        )
+    
+    def get_reward(self):
+        assert self.has_reward, "This node does not provide a reward."
+        if self.world.batch_size is None:
+            return sum(
+                node.get_reward() 
+                for node in self.nodes 
+                if node.has_reward
+            )
+        else:
+            rewards = self.backend.zeros((self.world.batch_size,), dtype=self.backend.default_floating_dtype, device=self.device)
+            for node in self.nodes:
+                if node.has_reward:
+                    rewards = rewards + node.get_reward()
+            return rewards
+    
+    def get_termination(self):
+        assert self.has_termination_signal, "This node does not provide a termination signal."
+        if self.world.batch_size is None:
+            return any(
+                node.get_termination() 
+                for node in self.nodes 
+                if node.has_termination_signal
+            )
+        else:
+            terminations = self.backend.zeros((self.world.batch_size,), dtype=self.backend.default_bool_dtype, device=self.device)
+            for node in self.nodes:
+                if node.has_termination_signal:
+                    terminations = self.backend.logical_or(terminations, node.get_termination())
+            return terminations
+        
+    def get_truncation(self):
+        assert self.has_truncation_signal, "This node does not provide a truncation signal."
+        if self.world.batch_size is None:
+            return any(
+                node.get_truncation() 
+                for node in self.nodes 
+                if node.has_truncation_signal
+            )
+        else:
+            truncations = self.backend.zeros((self.world.batch_size,), dtype=self.backend.default_bool_dtype, device=self.device)
+            for node in self.nodes:
+                if node.has_truncation_signal:
+                    truncations = self.backend.logical_or(truncations, node.get_truncation())
+            return truncations
+    
+    def get_info(self) -> Optional[Dict[str, Any]]:
+        infos = {}
+        for node in self.nodes:
+            info = node.get_info()
+            if info is not None:
+                infos[node.name] = info
+            
+        return self.aggregate_data(
+            infos,
+            direct_return=False
+        )
+    
+    def set_next_action(self, action):
+        assert self.action_space is not None, "Action space is None, cannot set action."
+        if self._action_node_name_direct is not None:
+            for node in self.nodes:
+                if node.name == self._action_node_name_direct:
+                    node.set_next_action(action)
+                    break
+        else:
+            assert isinstance(action, Mapping), "Action must be a mapping when there are multiple action spaces."
+            for node in self.nodes:
+                if node.action_space is not None:
+                    assert node.name in action, f"Action for node {node.name} is missing."
+                    node.set_next_action(action[node.name])
+    
+    def post_environment_step(self, dt):
+        for node in self.nodes:
+            node.post_environment_step(dt)
+    
+    def reset(self, *, seed = None, mask = None, pernode_kwargs : Dict[str, Any] = {}):
+        for node in self.nodes:
+            node.reset(
+                seed=seed,
+                mask=mask,
+                **pernode_kwargs.get(node.name, {})
+            )
+    
+    def after_reset(self, *, mask = None):
+        contexts = {}
+        observations = {}
+        infos = {}
+
+
+        for node in self.nodes:
+            context, observation, info = node.after_reset(mask=mask)
+            if context is not None:
+                contexts[node.name] = context
+            if observation is not None:
+                observations[node.name] = observation
+            if info is not None:
+                infos[node.name] = info
+
+        return self.aggregate_data(
+            contexts,
+            direct_return=self.direct_return,
+        ), self.aggregate_data(
+            observations,
+            direct_return=self.direct_return,
+        ), self.aggregate_data(
+            infos,
+            direct_return=False
+        )
+    
+
+    def close(self):
+        for node in self.nodes:
+            node.close()

unienv_interface/wrapper/backend_compat.py

@@ -60,7 +60,7 @@ class ToBackendOrDeviceWrapper(
 
         # Set new rng compatible with the new backend and device
         env.rng, seed = seed_util.next_seed_rng(env.rng, env.backend)
-        self._rng = backend.random.random_number_generator(
+        self._rng = (backend or env.backend).random.random_number_generator(
             seed=seed,
             device=device
         )
@@ -80,7 +80,7 @@ class ToBackendOrDeviceWrapper(
 
     @property
     def backend(self) -> ComputeBackend[Any, WrapperBDeviceT, Any, WrapperBRngT]:
-        return self._backend
+        return self._backend or self.env.backend
     
     @property
     def device(self) -> Optional[WrapperBDeviceT]:

unienv_interface/wrapper/frame_stack.py

@@ -1,103 +1,17 @@
-from typing import Dict as DictT, Any, Optional, Tuple, Union, Generic, SupportsFloat, Type, Sequence, TypeVar
+from typing import Dict, Any, Optional, Tuple, Union, SupportsFloat
 import numpy as np
 import copy
 
 from unienv_interface.backends import ComputeBackend, BArrayType, BDeviceType, BDtypeType, BRNGType
-
-from unienv_interface.space.space_utils import batch_utils as sbu, flatten_utils as sfu
-from unienv_interface.utils import seed_util
+from unienv_interface.space.space_utils import batch_utils as sbu
 from unienv_interface.env_base.env import Env, ContextType, ObsType, ActType, RenderFrame, BArrayType, BDeviceType, BDtypeType, BRNGType
 from unienv_interface.env_base.wrapper import ContextObservationWrapper, ActionWrapper, WrapperContextT, WrapperObsT, WrapperActT
 from unienv_interface.space import Space, DictSpace
-from collections import deque
-
-DataT = TypeVar('DataT')
-class SpaceDataQueue(
-    Generic[DataT, BArrayType, BDeviceType, BDtypeType, BRNGType]
-):
-    def __init__(
-        self,
-        space : Space[DataT, BDeviceType, BDtypeType, BRNGType],
-        batch_size : Optional[int],
-        maxlen: int,
-    ) -> None:
-        assert maxlen > 0, "Max length must be greater than 0"
-        assert batch_size is None or batch_size > 0, "Batch size must be greater than 0 if provided"
-        assert batch_size is None or sbu.batch_size(space) == batch_size, "Batch size must match the space's batch size if provided"
-        self.space = space
-        self.single_space = space
-        self.stacked_space = sbu.batch_space(space, maxlen) # (H, ...) or (L, B, ...)
-        self.output_space = sbu.swap_batch_dims(
-            self.stacked_space, 0, 1
-        ) if batch_size is not None else self.stacked_space # (B, L, ...) or (H, ...)
-        self.data = self.stacked_space.create_empty()
-        self._maxlen = maxlen
-        self._batch_size = batch_size
-
-    @property
-    def maxlen(self) -> int:
-        return self._maxlen
-
-    @property
-    def batch_size(self) -> Optional[int]:
-        return self._batch_size
-
-    @property
-    def backend(self) -> ComputeBackend:
-        return self.space.backend
-    
-    @property
-    def device(self) -> Optional[BDeviceType]:
-        return self.space.device
-    
-    def reset(
-        self, 
-        initial_data : DataT,
-        mask : Optional[BArrayType] = None,
-    ) -> None:
-        assert self.batch_size is None or mask is None, \
-            "Mask should not be provided if batch size is empty"
-        index = (
-            slice(None), mask
-        ) if mask is not None else slice(None)
-        
-        expanded_data = sbu.get_at( # Add a singleton horizon dimension to the data
-            self.space,
-            initial_data,
-            None
-        )
-        self.data = sbu.set_at(
-            self.stacked_space,
-            self.data,
-            index,
-            expanded_data
-        )
-
-    def append(self, data : DataT) -> None:
-        self.data = self.backend.map_fn_over_arrays(
-            self.data,
-            lambda x: self.backend.roll(x, shift=-1, axis=0),
-        )
-        self.data = sbu.set_at(
-            self.stacked_space,
-            self.data,
-            -1,
-            data
-        )
-    
-    def get_output_data(self) -> DataT:
-        if self.batch_size is None:
-            return self.data
-        else:
-            return sbu.swap_batch_dims_in_data(
-                self.backend,
-                self.data,
-                0, 1
-            ) # (L, B, ...) -> (B, L, ...)
+from unienv_interface.utils.data_queue import SpaceDataQueue
 
 class FrameStackWrapper(
     ContextObservationWrapper[
-        ContextType, Union[DictT[str, Any], Any],
+        ContextType, Union[Dict[str, Any], Any],
         BArrayType, ContextType, ObsType, ActType, RenderFrame, BDeviceType, BDtypeType, BRNGType
     ]
 ):
@@ -136,32 +50,24 @@ class FrameStackWrapper(
                 env.batch_size,
                 obs_stack_size + 1
             )
-            
             if action_stack_size > 0:
-                new_obs_spaces = self.obs_deque.output_space.spaces.copy()
-                new_obs_spaces['past_actions'] = self.action_deque.output_space
-                self.observation_space = DictSpace(
-                    env.backend,
-                    new_obs_spaces,
-                    device=env.observation_space.device
-                )
+                new_obs_space = copy.copy(self.obs_deque.output_space)
+                new_obs_space['past_actions'] = self.action_deque.output_space
+                self.observation_space = new_obs_space
             else:
                 self.observation_space = self.obs_deque.output_space
         else:
             if action_stack_size > 0:
-                spaces = env.observation_space.spaces.copy()
-                spaces['past_actions'] = self.action_deque.output_space
-                self.observation_space = DictSpace(
-                    env.backend,
-                    spaces,
-                    device=env.observation_space.device
-                )
-            self.obs_deque = None
+                new_obs_space = copy.copy(env.observation_space)
+                new_obs_space['past_actions'] = self.action_deque.output_space
+                self.observation_space = new_obs_space
+            else:
+                raise ValueError("At least one of observation stack size or action stack size must be greater than 0")
 
     def reverse_map_context(self, context: ContextType) -> ContextType:
         return context
 
-    def map_observation(self, observation: ObsType) -> Union[DictT[str, Any], Any]:
+    def map_observation(self, observation: ObsType) -> Union[Dict[str, Any], Any]:
         if self.obs_deque is not None:
             observation = self.obs_deque.get_output_data()
         
@@ -170,7 +76,7 @@ class FrameStackWrapper(
             observation['past_actions'] = stacked_action
         return observation
     
-    def reverse_map_observation(self, observation: Union[DictT[str, Any], Any]) -> ObsType:
+    def reverse_map_observation(self, observation: Union[Dict[str, Any], Any]) -> ObsType:
         if isinstance(observation, dict):
             stacked_obs = observation.copy()
             stacked_obs.pop('past_actions', None)
@@ -197,7 +103,7 @@ class FrameStackWrapper(
         mask: Optional[BArrayType] = None,
         seed: Optional[int] = None,
         **kwargs
-    ) -> Tuple[ContextType, Union[DictT[str, Any], Any], DictT[str, Any]]:
+    ) -> Tuple[ContextType, Union[Dict[str, Any], Any], Dict[str, Any]]:
         # TODO: If a mask is provided, we should only reset the stack for the masked indices
         context, obs, info = self.env.reset(
             *args,
@@ -227,16 +133,15 @@ class FrameStackWrapper(
         self,
         action: ActType
     ) -> Tuple[
-        Union[DictT[str, Any], Any],
+        Union[Dict[str, Any], Any],
         Union[SupportsFloat, BArrayType],
         Union[bool, BArrayType],
         Union[bool, BArrayType],
-        DictT[str, Any]
+        Dict[str, Any]
     ]:
         obs, rew, terminated, truncated, info = self.env.step(action)
         if self.action_deque is not None:
-            self.action_deque.append(action)
+            self.action_deque.add(action)
         if self.obs_deque is not None:
-            self.obs_deque.append(obs)
-        
+            self.obs_deque.add(obs)
         return self.map_observation(obs), rew, terminated, truncated, info

unienv_interface/wrapper/video_record.py

@@ -164,7 +164,11 @@ class EpisodeVideoWrapper(
 
         frames = []
         for frame in self.episodic_frames:
-            frame_np = self.env.backend.to_numpy(frame)
+            if self.env.backend.is_backendarray(frame):
+                frame_np = self.env.backend.to_numpy(frame)
+            else:
+                assert isinstance(frame, np.ndarray)
+                frame_np = frame
             assert frame_np.shape[2] == 3
             frames.append(frame_np)
         clip = ImageSequenceClip(frames, fps=self.env.render_fps or 30)
@@ -213,7 +217,12 @@ class EpisodeWandbVideoWrapper(
             *self.episodic_frames[0].shape
         ))
         for i, frame in enumerate(self.episodic_frames):
-            frame_np = self.env.backend.to_numpy(frame) if not isinstance(frame, np.ndarray) else frame
+            if self.env.backend.is_backendarray(frame):
+                frame_np = self.env.backend.to_numpy(frame)
+            else:
+                assert isinstance(frame, np.ndarray)
+                frame_np = frame
+            assert frame_np.shape[2] == 3
             frames[i] = frame_np
         clip = self.wandb.Video(
             frames.transpose(0, 3, 1, 2),

unienv-0.0.1b1.dist-info/METADATA

@@ -1,20 +0,0 @@
-Metadata-Version: 2.4
-Name: unienv
-Version: 0.0.1b1
-Requires-Python: >=3.10
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: xbarray>=0.0.1a8
-Requires-Dist: pillow
-Requires-Dist: h5py
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Provides-Extra: gymnasium
-Requires-Dist: gymnasium>=0.29.0; extra == "gymnasium"
-Provides-Extra: video
-Requires-Dist: moviepy>=2.1; extra == "video"
-Provides-Extra: mjx
-Requires-Dist: playground; extra == "mjx"
-Provides-Extra: maniskill
-Requires-Dist: mani_skill>=3.0.0b12; extra == "maniskill"
-Dynamic: license-file

unienv-0.0.1b1.dist-info/RECORD

@@ -1,85 +0,0 @@
-unienv-0.0.1b1.dist-info/licenses/LICENSE,sha256=VHeh-ceoc7FrtFmwszuGP2ZgOQGJNXIIWggxpk3B54E,1130
-unienv_data/__init__.py,sha256=zFxbe7aM5JvYXIK0FGnOPwWQJMN-8l_l8prB85CkcA8,95
-unienv_data/base/__init__.py,sha256=4RP84bYe8lpDFF3Ow1Ch4P91HGgE0Y_nmfEj1Ah5nxE,232
-unienv_data/base/common.py,sha256=SBYd2i-ZZq7ws_vphn8yx-q07jAbmMqUDvq4rdVlADE,10179
-unienv_data/base/storage.py,sha256=W_ZaNPnoXoarR83Ap56vV3_7BarZlhXVo2L_RDeARD8,5102
-unienv_data/base/transformations.py,sha256=dlZ7oAABz7Ihm9T6rJnDYw_5JQgBp2UsVRgy5-W-AdA,5596
-unienv_data/batches/__init__.py,sha256=431RMsGjpAIpvwaHBzCFaG5755is0W89KlPTVXESMGw,188
-unienv_data/batches/backend_compat.py,sha256=8L3jeWTWomAI87C7VQDwkbSDSncMS8-UgqGHTe5rmkw,6408
-unienv_data/batches/combined_batch.py,sha256=XyQeaJgKC6uEScjQUD1DrkowTW0R_DTIcH_I6kUnRYA,15395
-unienv_data/batches/framestack_batch.py,sha256=pdURqZeksOlbf21Nhx8kkm0gtFt6rjt2OiNWgZPdFCM,2312
-unienv_data/batches/slicestack_batch.py,sha256=J2EhARcPA-zz6EBnV7OLzm4yyvnZ06vrdUoPD5RkJ-o,16672
-unienv_data/integrations/pytorch.py,sha256=pW5rXBXagfzwJjM_VGgg8CPXEs3e2fKgg4nY7M3dpOc,2350
-unienv_data/replay_buffer/__init__.py,sha256=uVebYruIYlj8OjTYVi8UYI4gWp3S3XIdgFlHbwO260o,100
-unienv_data/replay_buffer/replay_buffer.py,sha256=GVfTyjkFAQ5I6hHtsPk2iftaIOwY9Aj0SN_ir0Kyb4M,10192
-unienv_data/replay_buffer/trajectory_replay_buffer.py,sha256=fxV6FIqAHhN8opYs2WjAJMPqNRWD3iIku-4WlaydyG4,20737
-unienv_data/samplers/__init__.py,sha256=pkoGnWKAR7dqKdDtQn-5y8pY8fqFPt7wFMnGapmFXP0,137
-unienv_data/samplers/multiprocessing_sampler.py,sha256=8GLnGiqEYozTif1Hg_rAjMMseWDkaq5D5IIsTTY67gw,13031
-unienv_data/samplers/slice_sampler.py,sha256=mbVKmlT0uij1p0emaPJI0T1hc5LS5B5D2chEO7yehIM,11521
-unienv_data/samplers/step_sampler.py,sha256=l6gm6F089iaytAd81mXZPgtCOQ1ckUwPuaVOgCIHLxs,3197
-unienv_data/storages/common.py,sha256=-Kb1SY-b4D2GvmLKOwRYjtrXiUROIVHLhs4Xh86S7UQ,6103
-unienv_data/storages/hdf5.py,sha256=3zxt-JWJOBVcC-IGk9LvIQBaJJO9f-2UriVNhMrtvk4,14494
-unienv_data/storages/pytorch.py,sha256=1kAU5ZPMkGLNry4aubnSZQjEP0H8dO8xrH2Yg8shpGw,6213
-unienv_interface/__init__.py,sha256=pAWqfm4l7NAssuyXCugIjekSIh05aBbOjNhwsNXcJbE,100
-unienv_interface/backends/__init__.py,sha256=L7CFwCChHVL-2Dpz34pTGC37WgodfJEeDQwXscyM7FM,198
-unienv_interface/backends/base.py,sha256=1_hji1qwNAhcEtFQdAuzaNey9g5bWYj38t1sQxjnggc,132
-unienv_interface/backends/jax.py,sha256=Rus-aBp1kz3XMOwDzoi5aI1hO0Ha7g2V5U1WcRz2bf0,433
-unienv_interface/backends/numpy.py,sha256=NnNoUGUsvXnTYU86sNmuf44Z2jSxBTk4qKul7eaNM-A,436
-unienv_interface/backends/pytorch.py,sha256=xLobPQFnM4WGppYx9N1Emly9w_UXEx8IHtK1TPd89dw,480
-unienv_interface/backends/serialization.py,sha256=0TZlpfbP1DRB4FkM8ysDVQmn6RlYtIPisyeHjvHr7bE,2289
-unienv_interface/env_base/__init__.py,sha256=UT5pBnf4kaXT450o8bmffH7kkSZXpU6AICrsZLxY2Yg,181
-unienv_interface/env_base/env.py,sha256=Wy2_kYyP-t-2zoJk5SLRhhwV-rMKGdQVWUgXOOCtlHU,4661
-unienv_interface/env_base/funcenv.py,sha256=naOfnff4yw-D3hh6covgVP-ZAszyq-3N96AOslVtASI,9678
-unienv_interface/env_base/funcenv_wrapper.py,sha256=UcTdE7vKiN8AQMwN4tk-AQyHbHuZjtWhEIpiVP1H-xY,7746
-unienv_interface/env_base/wrapper.py,sha256=7hf4Rr2wouS0igPoahhvb2tzYY3bCaWL0NlgwpYZwQs,9734
-unienv_interface/func_wrapper/__init__.py,sha256=X0BwdAFsrhmHy4DkhHgoAyCF5xIHtAwzijzCwegFq10,48
-unienv_interface/func_wrapper/transformation.py,sha256=7mdzcpjLjqtpbtXoqbkGtTMPQxoMmMsqzDWHcZLbrhs,5939
-unienv_interface/space/__init__.py,sha256=6-wLoD9mKDAfz7IuQs_Rn9DMDfDwTZ0tEhQ924libpg,99
-unienv_interface/space/space.py,sha256=mFlCcDvMgEPTXlwo_iwBlm6Eg4Bn2rrecgsfIVstdq0,4067
-unienv_interface/space/space_utils/__init__.py,sha256=uz53bqNEizFxJcyQj-Q3yt65ZovK_ItXyjkdapXqpmg,90
-unienv_interface/space/space_utils/batch_utils.py,sha256=3PXgrMrv9ecw0nwxYSvI91UUqwuxyYhe4INeN1--NIU,33616
-unienv_interface/space/space_utils/flatten_utils.py,sha256=kkHkjrsk43NDbg3Q5VAhVoIXStuRayYFO-7knsDzx4A,12289
-unienv_interface/space/space_utils/gym_utils.py,sha256=nH8EKruOKCXNrIMPUd9F4XGKCfFkhxsTmx4I1BeSgn0,15079
-unienv_interface/space/space_utils/serialization_utils.py,sha256=jfnHowqIAVXgT1WR4OU8VWp4b52mOWDXH25QdclDV18,8863
-unienv_interface/space/spaces/__init__.py,sha256=8EW6XKqTn9NQ9B1jYNSM9ouQhXRFjY-TsH1GAaBRVIU,480
-unienv_interface/space/spaces/binary.py,sha256=zg1fOxsugiDBKja29Q8J3OKZGWnt8jq8AnEEe-hvcKE,3638
-unienv_interface/space/spaces/box.py,sha256=qN-SF80T4UhWZskSd5hNMxSzkT1zEIqOh18LV4IFCeE,13792
-unienv_interface/space/spaces/dict.py,sha256=G5_iYC1Bj5DqeJ7aFlq6eRJbnpATbIRIyRu1jF_UUvk,7022
-unienv_interface/space/spaces/dynamic_box.py,sha256=HvMNgzfYwIVc5VVgCtq-8lQbNI1V1dZMI-w60AwYss4,19591
-unienv_interface/space/spaces/graph.py,sha256=KocRFLtYP5VWYpwbP6HybXH5R4jTIYJdNePKb6vhnYE,15163
-unienv_interface/space/spaces/text.py,sha256=S9u4fd-X6k-xQMxayxYECeasrXosCLprfLz4SgVHVew,4561
-unienv_interface/space/spaces/tuple.py,sha256=rgZQz3EB3CLbIk9UlHBQbM6w9gssbA1izm-Qq-_Chqs,4267
-unienv_interface/space/spaces/union.py,sha256=Qisd-DdmPcGRmdhZFGiQw8_AOjYWqkuQ4Hwd-I8tdSI,4375
-unienv_interface/transformations/__init__.py,sha256=g19uGnDHMywvDAXRaqFgoWAF1vCPrbJENEpaEgtIrOw,353
-unienv_interface/transformations/batch_and_unbatch.py,sha256=ELCnNtwmgA5wpTBJZasfNSHmtf4vzydzLPmO6IGbT9o,1164
-unienv_interface/transformations/chained_transform.py,sha256=TDnUvxUKK6bXGc_sfr6ZCvvVWw7P5KX2sA9i7i2lx14,2075
-unienv_interface/transformations/dict_transform.py,sha256=nv9BFDmoDyv2hTGgHAOcLOwIJD2i5N-L3qqE5AnIR1g,4504
-unienv_interface/transformations/filter_dict.py,sha256=DzR-hgHoHJObTipxwB2UrKVlTxbfIrJohaOgqdAICLY,5871
-unienv_interface/transformations/rescale.py,sha256=fM5ukWUvNvPeDO48_PRU0KyyvGhBIDxaN9XZyQ1VaQQ,4364
-unienv_interface/transformations/transformation.py,sha256=u4_9H1tvophhgG0p0F3xfkMMsRuaKY2TQmVeGoeQsJ0,1652
-unienv_interface/utils/seed_util.py,sha256=Up3nBXj7L8w-S9W5Q1U2d9accMhMf0TmHPaN6JXDVWs,677
-unienv_interface/utils/symbol_util.py,sha256=NAERK-D_2MaTg2eYW-L75tbzPQN5YJIiKtM9zuQ89Sw,383
-unienv_interface/world/__init__.py,sha256=FDhYhxAGnUmR-_3eCjN4LjiaYXXaVaU3QNRPhx-Umbw,132
-unienv_interface/world/funcnode.py,sha256=mUpVQ_j7dVF6V7Dc435RNtMQB2LsuWRRkp-hBLOCwzc,7829
-unienv_interface/world/funcworld.py,sha256=GLp8nS0Ym1gaj7FWvD5FPkQElCgZMbpyuLsIMU0w-sw,2020
-unienv_interface/world/node.py,sha256=Qn8rErvhkRp2U0s_m_0OqDLY723w9E5W8tGdmKcP-mY,5996
-unienv_interface/world/world.py,sha256=Kl7wbNbs2YR3CjFrCLFhDB3DQUAWM6LjBwSADQtBTII,5740
-unienv_interface/wrapper/__init__.py,sha256=ZNqr-WjVRqgvIxkLkeABxpYZ6tRgJNZOzmluDeJ6W_w,614
-unienv_interface/wrapper/action_rescale.py,sha256=rTJlEHvWSuwGVX83cjfLWvszBk7B2iExX_K37vH8Wic,1231
-unienv_interface/wrapper/backend_compat.py,sha256=-nq4XQHBLlwNu3ku65lVPv3-h_A0_sYZciQgGBG6RXs,7044
-unienv_interface/wrapper/batch_and_unbatch.py,sha256=HpmnppgOKmshNlfmJYkGQYtEU7_U7q3mEdY5n4UaqEY,3457
-unienv_interface/wrapper/control_frequency_limit.py,sha256=B0E2aUbaUr2p2yIN6wT3q4rAbPYsVroioqma2qKMoC0,2322
-unienv_interface/wrapper/flatten.py,sha256=NWA5xne5j_L34oq_wT85wGvp6iHwdCSeGsk1DMugvRw,5837
-unienv_interface/wrapper/frame_stack.py,sha256=ss7Z7AEMwuFDkmHbcpr9srZwt4a2i9V9DPykSF9LAQ8,8925
-unienv_interface/wrapper/gym_compat.py,sha256=JhLxDsO1NsJnKzKhO0MqMw9i5_1FLxoxKilWaQQyBkw,9789
-unienv_interface/wrapper/time_limit.py,sha256=VRvB00BK7deI2QtdGatqwDWmPgjgjg1E7MTvEyaW5rg,2904
-unienv_interface/wrapper/transformation.py,sha256=pQ-_YVU8WWDqSk2sONUUgQY1iigOD092KNcp1DYxoxk,10043
-unienv_interface/wrapper/video_record.py,sha256=dAwPQuxhj7Pgn4773I5Wlr1agxcLVVdXnw7dT-d0wtM,8357
-unienv_maniskill/__init__.py,sha256=GJ6Fe5XosHqVxXSQ_cZT6cd9GWmfb2_NIYefCFD7rpU,54
-unienv_maniskill/wrapper/maniskill_compat.py,sha256=yp9kX3Sn5Riszai47VasQcbGD6MFs67ITl0NuFqxp7Y,7435
-unienv_mjxplayground/__init__.py,sha256=EaiB9FV7um1oZhhUNPx-hf4j3ruQ51Q1OSiS7Njls1M,59
-unienv_mjxplayground/wrapper/playground_compat.py,sha256=xbkJ_7kO1VQjYsrtxT9Er6NNls4H5o5RZAe0ttgWX5w,7945
-unienv-0.0.1b1.dist-info/METADATA,sha256=dwzzbRrlByBym1cKaOJPa907gGNqCLyDaiJ--FNCq5c,568
-unienv-0.0.1b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-unienv-0.0.1b1.dist-info/top_level.txt,sha256=lL1n-OMi2oZ5e4kuFcvbelQ-9DsdEgr7w-dQ-faiCD8,67
-unienv-0.0.1b1.dist-info/RECORD,,

unienv-0.0.1b1.dist-info/top_level.txt

@@ -1,4 +0,0 @@
-unienv_data
-unienv_interface
-unienv_maniskill
-unienv_mjxplayground