unienv 0.0.1b1__tar.gz

unienv-0.0.1b1/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2016 OpenAI
+Copyright (c) 2022 Farama Foundation
+Copyright (c) 2024 Yunhao Cao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

unienv-0.0.1b1/PKG-INFO

@@ -0,0 +1,20 @@
+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/README.md

@@ -0,0 +1,46 @@
+# UniEnvPy
+
+TLDR: Gymnasium Library replacement with support for multiple tensor backends
+
+Provides an universal interface for single / parallel state-based or function-based environments. Also contains a set of utilities (such as replay buffers, wrappers, etc.) to facilitate the training of reinforcement learning agents.
+
+## Cross-backend Support
+
+UniEnvPy supports multiple tensor backends with zero-copy translation layers through the DLPack protocol, and allows you to use the same abstract compute backend interface to write custom data transformation layers, environment wrappers and other utilities. This is powered by the [xbarray](https://github.com/realquantumcookie/xbarray) package, which builts on top of the Array API Standard, and supports the following backends:
+
+- numpy
+- pytorch
+- jax
+
+We also support diverse simulation environments and real robots, built on top of the abstract environment / world interface. This allows you to reuse code across different sim and real robots.
+
+Current supported simulation environments:
+- Any Environment defined in Gymnasium interface
+- <s>Mujoco</s> (New code will be added in the future, but I'm currently working on refractoring World based environments)
+- MJX based on [Mujoco-Playground](https://github.com/google-deepmind/mujoco_playground)
+- [ManiSkill 3](https://github.com/haosulab/ManiSkill/)
+
+Current supported real robots:
+- Franka Research 3 + RobotiQ Gripper in Droid Setup
+- OyMotion OHand
+
+## Installation
+
+Clone down this repo
+
+```bash
+git clone https://github.com/realquantumcookie/UniEnvPy
+cd UniEnvPy
+```
+
+Install the package with pip
+
+```bash
+pip install -e .
+```
+
+You can install optional dependencies such as `gymnasium`, `mjx`, `maniskill`, `video` by running
+
+```bash
+pip install -e .[gymnasium,mjx,maniskill,video]
+```

unienv-0.0.1b1/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "unienv"
+version = "0.0.1b1"
+requires-python = ">= 3.10"
+dependencies = [
+    "numpy",
+    "xbarray>=0.0.1a8",
+    "pillow",
+    "h5py",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+]
+gymnasium = [
+    "gymnasium>=0.29.0",
+]
+video = [
+    "moviepy>=2.1"
+]
+mjx = [
+    "playground",
+]
+maniskill = [
+    "mani_skill>=3.0.0b12"
+]
+
+[tool.setuptools.packages.find]
+include = ["*"]
+exclude = ["training*", "tests*"]

unienv-0.0.1b1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

unienv-0.0.1b1/unienv.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+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/unienv.egg-info/SOURCES.txt

@@ -0,0 +1,88 @@
+LICENSE
+README.md
+pyproject.toml
+unienv.egg-info/PKG-INFO
+unienv.egg-info/SOURCES.txt
+unienv.egg-info/dependency_links.txt
+unienv.egg-info/requires.txt
+unienv.egg-info/top_level.txt
+unienv_data/__init__.py
+unienv_data/base/__init__.py
+unienv_data/base/common.py
+unienv_data/base/storage.py
+unienv_data/base/transformations.py
+unienv_data/batches/__init__.py
+unienv_data/batches/backend_compat.py
+unienv_data/batches/combined_batch.py
+unienv_data/batches/framestack_batch.py
+unienv_data/batches/slicestack_batch.py
+unienv_data/integrations/pytorch.py
+unienv_data/replay_buffer/__init__.py
+unienv_data/replay_buffer/replay_buffer.py
+unienv_data/replay_buffer/trajectory_replay_buffer.py
+unienv_data/samplers/__init__.py
+unienv_data/samplers/multiprocessing_sampler.py
+unienv_data/samplers/slice_sampler.py
+unienv_data/samplers/step_sampler.py
+unienv_data/storages/common.py
+unienv_data/storages/hdf5.py
+unienv_data/storages/pytorch.py
+unienv_interface/__init__.py
+unienv_interface/backends/__init__.py
+unienv_interface/backends/base.py
+unienv_interface/backends/jax.py
+unienv_interface/backends/numpy.py
+unienv_interface/backends/pytorch.py
+unienv_interface/backends/serialization.py
+unienv_interface/env_base/__init__.py
+unienv_interface/env_base/env.py
+unienv_interface/env_base/funcenv.py
+unienv_interface/env_base/funcenv_wrapper.py
+unienv_interface/env_base/wrapper.py
+unienv_interface/func_wrapper/__init__.py
+unienv_interface/func_wrapper/transformation.py
+unienv_interface/space/__init__.py
+unienv_interface/space/space.py
+unienv_interface/space/space_utils/__init__.py
+unienv_interface/space/space_utils/batch_utils.py
+unienv_interface/space/space_utils/flatten_utils.py
+unienv_interface/space/space_utils/gym_utils.py
+unienv_interface/space/space_utils/serialization_utils.py
+unienv_interface/space/spaces/__init__.py
+unienv_interface/space/spaces/binary.py
+unienv_interface/space/spaces/box.py
+unienv_interface/space/spaces/dict.py
+unienv_interface/space/spaces/dynamic_box.py
+unienv_interface/space/spaces/graph.py
+unienv_interface/space/spaces/text.py
+unienv_interface/space/spaces/tuple.py
+unienv_interface/space/spaces/union.py
+unienv_interface/transformations/__init__.py
+unienv_interface/transformations/batch_and_unbatch.py
+unienv_interface/transformations/chained_transform.py
+unienv_interface/transformations/dict_transform.py
+unienv_interface/transformations/filter_dict.py
+unienv_interface/transformations/rescale.py
+unienv_interface/transformations/transformation.py
+unienv_interface/utils/seed_util.py
+unienv_interface/utils/symbol_util.py
+unienv_interface/world/__init__.py
+unienv_interface/world/funcnode.py
+unienv_interface/world/funcworld.py
+unienv_interface/world/node.py
+unienv_interface/world/world.py
+unienv_interface/wrapper/__init__.py
+unienv_interface/wrapper/action_rescale.py
+unienv_interface/wrapper/backend_compat.py
+unienv_interface/wrapper/batch_and_unbatch.py
+unienv_interface/wrapper/control_frequency_limit.py
+unienv_interface/wrapper/flatten.py
+unienv_interface/wrapper/frame_stack.py
+unienv_interface/wrapper/gym_compat.py
+unienv_interface/wrapper/time_limit.py
+unienv_interface/wrapper/transformation.py
+unienv_interface/wrapper/video_record.py
+unienv_maniskill/__init__.py
+unienv_maniskill/wrapper/maniskill_compat.py
+unienv_mjxplayground/__init__.py
+unienv_mjxplayground/wrapper/playground_compat.py

unienv-0.0.1b1/unienv.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

unienv-0.0.1b1/unienv.egg-info/requires.txt

@@ -0,0 +1,19 @@
+numpy
+xbarray>=0.0.1a8
+pillow
+h5py
+
+[dev]
+pytest
+
+[gymnasium]
+gymnasium>=0.29.0
+
+[maniskill]
+mani_skill>=3.0.0b12
+
+[mjx]
+playground
+
+[video]
+moviepy>=2.1

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

@@ -0,0 +1,6 @@
+dist
+unienv_data
+unienv_interface
+unienv_maniskill
+unienv_mjxplayground
+unienv_mujoco

unienv-0.0.1b1/unienv_data/__init__.py

@@ -0,0 +1,4 @@
+from .base import *
+from .batches import *
+from .samplers import *
+from .replay_buffer import *

unienv-0.0.1b1/unienv_data/base/__init__.py

@@ -0,0 +1,3 @@
+from .common import BatchT, SamplerBatchT, SamplerArrayType, SamplerDeviceType, SamplerDtypeType, SamplerRNGType, BatchBase, BatchSampler, IndexableType
+from .transformations import TransformedBatch
+from .storage import SpaceStorage

unienv-0.0.1b1/unienv_data/base/common.py

@@ -0,0 +1,228 @@
+from typing import List, Tuple, Union, Dict, Any, Optional, Generic, TypeVar, Iterable, Iterator
+from types import EllipsisType
+import os
+import abc
+from unienv_interface.backends import ComputeBackend, BArrayType, BDeviceType, BDtypeType, BRNGType
+from unienv_interface.env_base.env import ContextType, ObsType, ActType
+from unienv_interface.space import Space, BoxSpace, DictSpace
+import dataclasses
+
+from unienv_interface.space.space_utils import batch_utils as space_batch_utils, flatten_utils as space_flatten_utils
+
+IndexableType = Union[int, slice, EllipsisType]
+
+BatchT = TypeVar('BatchT')
+class BatchBase(abc.ABC, Generic[BatchT, BArrayType, BDeviceType, BDtypeType, BRNGType]):
+    backend: ComputeBackend[BArrayType, BDeviceType, BDtypeType, BRNGType]
+    device: Optional[BDeviceType] = None
+
+    # If the batch is mutable, then the data can be changed (extend_*, set_*, remove_*, etc.)
+    is_mutable: bool = True
+
+    def __init__(
+        self,
+        single_space : Space[Any, BDeviceType, BDtypeType, BRNGType],
+        single_metadata_space : Optional[DictSpace[BDeviceType, BDtypeType, BRNGType]] = None,
+    ):
+        self.single_space = single_space
+        self.single_metadata_space = single_metadata_space
+        self._batched_space : Space[
+            BatchT, Any, BDeviceType, BDtypeType, BRNGType
+        ] = space_batch_utils.batch_space(single_space, 1)
+        if single_metadata_space is not None:
+            self._batched_metadata_space : DictSpace[
+                BDeviceType, BDtypeType, BRNGType
+            ] = space_batch_utils.batch_space(single_metadata_space, 1)
+        else:
+            self._batched_metadata_space = None
+
+    @abc.abstractmethod
+    def __len__(self) -> int:
+        raise NotImplementedError
+    
+    def get_flattened_at(self, idx : Union[IndexableType, BArrayType]) -> BArrayType:
+        return self.get_flattened_at_with_metadata(idx)[0]
+
+    @abc.abstractmethod
+    def get_flattened_at_with_metadata(
+        self, idx : Union[IndexableType, BArrayType]
+    ) -> Tuple[BArrayType, Optional[Dict[str, Any]]]:
+        raise NotImplementedError
+
+    def set_flattened_at(self, idx : Union[IndexableType, BArrayType], value : BArrayType) -> None:
+        raise NotImplementedError
+
+    def extend_flattened(self, value : BArrayType) -> None:
+        raise NotImplementedError
+    
+    def get_at(self, idx : Union[IndexableType, BArrayType]) -> BatchT:
+        flattened_data = self.get_flattened_at(idx)
+        if isinstance(idx, int):
+            return space_flatten_utils.unflatten_data(self.single_space, flattened_data)
+        else:
+            return space_flatten_utils.unflatten_data(self._batched_space, flattened_data, start_dim=1)
+    
+    def get_at_with_metadata(
+        self, idx : Union[IndexableType, BArrayType]
+    ) -> Tuple[BatchT, Optional[Dict[str, Any]]]:
+        flattened_data, metadata = self.get_flattened_at_with_metadata(idx)
+        if isinstance(idx, int):
+            return space_flatten_utils.unflatten_data(self.single_space, flattened_data), metadata
+        else:
+            return space_flatten_utils.unflatten_data(self._batched_space, flattened_data, start_dim=1), metadata
+
+    def __getitem__(self, idx : Union[IndexableType, BArrayType]) -> BatchT:
+        return self.get_at(idx)
+
+    def set_at(self, idx : Union[IndexableType, BArrayType], value : BatchT) -> None:
+        if isinstance(idx, int):
+            flattened_data = space_flatten_utils.flatten_data(self.single_space, value)
+        else:
+            flattened_data = space_flatten_utils.flatten_data(self._batched_space, value, start_dim=1)
+        self.set_flattened_at(idx, flattened_data)
+    
+    def __setitem__(self, idx : Union[IndexableType, BArrayType], value : BatchT) -> None:
+        self.set_at(idx, value)
+    
+    def remove_at(self, idx : Union[IndexableType, BArrayType]) -> None:
+        raise NotImplementedError
+
+    def __delitem__(self, idx : Union[IndexableType, BArrayType]) -> None:
+        self.remove_at(idx)
+
+    def extend(self, value : BatchT) -> None:
+        flattened_data = space_flatten_utils.flatten_data(self._batched_space, value, start_dim=1)
+        self.extend_flattened(flattened_data)
+
+    def close(self) -> None:
+        pass
+
+    def __del__(self) -> None:
+        self.close()
+
+SamplerBatchT = TypeVar('SamplerBatchT')
+SamplerArrayType = TypeVar('SamplerArrayType')
+SamplerDeviceType = TypeVar('SamplerDeviceType')
+SamplerDtypeType = TypeVar('SamplerDtypeType')
+SamplerRNGType = TypeVar('SamplerRNGType')
+class BatchSampler(abc.ABC, Generic[
+    SamplerBatchT, SamplerArrayType, SamplerDeviceType, SamplerDtypeType, SamplerRNGType,
+    BatchT, BArrayType, BDeviceType, BDtypeType, BRNGType,
+]):
+    batch_size : int
+    sampled_space : Space[SamplerBatchT, SamplerDeviceType, SamplerDtypeType, SamplerRNGType]
+    sampled_space_flat : BoxSpace[SamplerArrayType, SamplerDeviceType, SamplerDtypeType, SamplerRNGType]
+    sampled_metadata_space : Optional[DictSpace[SamplerDeviceType, SamplerDtypeType, SamplerRNGType]] = None
+
+    backend : ComputeBackend[SamplerArrayType, SamplerDeviceType, SamplerDtypeType, SamplerRNGType]
+    device : Optional[SamplerDeviceType] = None
+
+    data : BatchBase[BatchT, BArrayType, BDeviceType, BDtypeType, BRNGType]
+
+    rng : Optional[SamplerRNGType] = None
+    data_rng : Optional[BRNGType] = None
+
+    def get_flat_at(self, idx : SamplerArrayType) -> SamplerArrayType:
+        return self.get_flat_at_with_metadata(idx)[0]
+    
+    @abc.abstractmethod
+    def get_flat_at_with_metadata(
+        self, idx : SamplerArrayType
+    ) -> Tuple[SamplerArrayType, Optional[Dict[str, Any]]]:
+        raise NotImplementedError
+    
+    def get_at(self, idx : SamplerArrayType) -> SamplerBatchT:
+        return space_flatten_utils.unflatten_data(self.sampled_space, self.get_flat_at(idx), start_dim=1)
+    
+    def get_at_with_metadata(
+        self, idx : SamplerArrayType
+    ) -> Tuple[SamplerBatchT, Optional[Dict[str, Any]]]:
+        flat_data, metadata = self.get_flat_at_with_metadata(idx)
+        return space_flatten_utils.unflatten_data(self.sampled_space, flat_data, start_dim=1), metadata
+
+    def sample_index(self) -> SamplerArrayType:
+        new_rng, indices = self.backend.random.random_discrete_uniform( # (B, )
+            (self.batch_size,),
+            0,
+            len(self.data),
+            rng=self.data_rng if self.data_rng is not None else self.rng,
+            device=self.data.device,
+        )
+        if self.data_rng is not None:
+            self.data_rng = new_rng
+        else:
+            self.rng = new_rng
+        return indices
+
+    def sample_flat(self) -> SamplerArrayType:
+        idx = self.sample_index()
+        return self.get_flat_at(idx)
+    
+    def sample_flat_with_metadata(self) -> Tuple[SamplerArrayType, Optional[Dict[str, Any]]]:
+        idx = self.sample_index()
+        return self.get_flat_at_with_metadata(idx)
+
+    def sample(self) -> SamplerBatchT:
+        idx = self.sample_index()
+        return self.get_at(idx)
+    
+    def sample_with_metadata(self) -> Tuple[SamplerBatchT, Optional[Dict[str, Any]]]:
+        idx = self.sample_index()
+        return self.get_at_with_metadata(idx)
+
+    def __iter__(self) -> Iterator[SamplerBatchT]:
+        return self.epoch_iter()
+    
+    def epoch_iter(self) -> Iterator[SamplerBatchT]:
+        if self.data_rng is not None:
+            self.data_rng, idx = self.backend.random.random_permutation(len(self.data), rng=self.data_rng, device=self.data.device)
+        else:
+            self.rng, idx = self.backend.random.random_permutation(len(self.data), rng=self.rng, device=self.data.device)
+        n_batches = len(self.data) // self.batch_size
+        num_left = len(self.data) % self.batch_size
+        for i in range(n_batches):
+            yield self.get_at(idx[i*self.batch_size:(i+1)*self.batch_size])
+        if num_left > 0:
+            yield self.get_at(idx[-num_left:])
+    
+    def epoch_iter_with_metadata(self) -> Iterator[Tuple[SamplerBatchT, Optional[Dict[str, Any]]]]:
+        if self.data_rng is not None:
+            self.data_rng, idx = self.backend.random.random_permutation(len(self.data), rng=self.data_rng, device=self.data.device)
+        else:
+            self.rng, idx = self.backend.random.random_permutation(len(self.data), rng=self.rng, device=self.data.device)
+        n_batches = len(self.data) // self.batch_size
+        num_left = len(self.data) % self.batch_size
+        for i in range(n_batches):
+            yield self.get_at_with_metadata(idx[i*self.batch_size:(i+1)*self.batch_size])
+        if num_left > 0:
+            yield self.get_at_with_metadata(idx[-num_left:])
+
+    def epoch_flat_iter(self) -> Iterator[SamplerArrayType]:
+        if self.data_rng is not None:
+            self.data_rng, idx = self.backend.random.random_permutation(len(self.data), rng=self.data_rng, device=self.data.device)
+        else:
+            self.rng, idx = self.backend.random.random_permutation(len(self.data), rng=self.rng, device=self.data.device)
+        n_batches = len(self.data) // self.batch_size
+        num_left = len(self.data) % self.batch_size
+        for i in range(n_batches):
+            yield self.get_flat_at(idx[i*self.batch_size:(i+1)*self.batch_size])
+        if num_left > 0:
+            yield self.get_flat_at(idx[-num_left:])
+    
+    def epoch_flat_iter_with_metadata(self) -> Iterator[Tuple[SamplerArrayType, Optional[Dict[str, Any]]]]:
+        if self.data_rng is not None:
+            self.data_rng, idx = self.backend.random.random_permutation(len(self.data), rng=self.data_rng, device=self.data.device)
+        else:
+            self.rng, idx = self.backend.random.random_permutation(len(self.data), rng=self.rng, device=self.data.device)
+        n_batches = len(self.data) // self.batch_size
+        num_left = len(self.data) % self.batch_size
+        for i in range(n_batches):
+            yield self.get_flat_at_with_metadata(idx[i*self.batch_size:(i+1)*self.batch_size])
+        if num_left > 0:
+            yield self.get_flat_at_with_metadata(idx[-num_left:])
+
+    def close(self) -> None:
+        pass
+
+    def __del__(self) -> None:
+        self.close()

unienv-0.0.1b1/unienv_data/base/storage.py

@@ -0,0 +1,132 @@
+import abc
+import os
+from typing import Generic, TypeVar, Optional, Any, Dict, Union, Tuple, Sequence, Callable, Type
+from unienv_interface.backends import ComputeBackend, BArrayType, BDeviceType, BDtypeType, BRNGType
+
+from unienv_interface.space import Space
+from .common import BatchBase, BatchT, IndexableType
+
+class SpaceStorage(abc.ABC, Generic[BatchT, BArrayType, BDeviceType, BDtypeType, BRNGType]):
+    """
+    SpaceStorage is an abstract base class for storages that hold instances of a specific space.
+    It provides a common interface for creating, loading, and managing the storage of instances of a given space.
+    Note that if you want your space storage to support multiprocessing, you need to check / implement `__getstate__` and `__setstate__` methods to ensure that the storage can be pickled and unpickled correctly.
+    """
+    # ========== Class Creation and Loading Methods ==========
+    @classmethod
+    def create(
+        cls,
+        single_instance_space : Space[BatchT, BDeviceType, BDtypeType, BRNGType],
+        *args,
+        capacity : Optional[int],
+        cache_path : Optional[Union[str, os.PathLike]] = None,
+        **kwargs
+    ) -> "SpaceStorage[BatchT, BArrayType, BDeviceType, BDtypeType, BRNGType]":
+        raise NotImplementedError
+
+    @classmethod
+    def load_from(
+        cls,
+        path: Union[str, os.PathLike],
+        single_instance_space: Space[BatchT, BDeviceType, BDtypeType, BRNGType],
+        *,
+        capacity : Optional[int] = None,
+        **kwargs
+    ) -> "SpaceStorage[BatchT, BArrayType, BDeviceType, BDtypeType, BRNGType]":
+        raise NotImplementedError
+
+    # ========== Class Attributes ==========
+    
+    """
+    The file extension (e.g. `.pt`) used for saving a single instance of the space.
+    If this is None, it means the storage stores files in a folder
+    """
+    single_file_ext : Optional[str] = None
+
+    # ======== Instance Attributes ==========
+    """
+    The total capacity (number of single instances) of the storage.
+    If None, the storage has unlimited capacity.
+    """
+    capacity : Optional[int] = None
+
+    """
+    The cache path for the storage.
+    If None, the storage will not use caching.
+    """
+    cache_filename : Optional[Union[str, os.PathLike]] = None
+
+    @property
+    def backend(self) -> ComputeBackend[BArrayType, BDeviceType, BDtypeType, BRNGType]:
+        return self.single_instance_space.backend
+    
+    @property
+    def device(self) -> Optional[BDeviceType]:
+        return self.single_instance_space.device
+
+    def __init__(
+        self,
+        single_instance_space : Space[BatchT, BDeviceType, BDtypeType, BRNGType],
+    ):
+        self.single_instance_space = single_instance_space
+    
+    def extend_length(self, length : int) -> None:
+        """
+        This is used by capacity = None storages to extend the length of the storage
+        If this is called on a storage with a fixed capacity, we will simply ignore the call.
+        """
+        pass
+
+    def shrink_length(self, length : int) -> None:
+        """
+        This is used by capacity = None storages to shrink the length of the storage
+        If this is called on a storage with a fixed capacity, we will simply ignore the call.
+        """
+        pass
+
+    def __len__(self) -> int:
+        """
+        Returns the number of instances in the storage
+        Storages with unlimited capacity should implement this method to return the current length of the storage.
+        """
+        if self.capacity is None:
+            raise NotImplementedError(f"__len__ is not implemented for class {type(self).__name__}")
+        return self.capacity
+
+    # We don't define them here, since they are optional and the `ReplayBuffer` checks if they are implemented
+    # by using hasattr(self, "get_flattened") and hasattr(self, "set_flattened").
+    # def get_flattened(self, index : Union[IndexableType, BArrayType]) -> BArrayType:
+    #     raise NotImplementedError
+    
+    # def set_flattened(self, index : Union[IndexableType, BArrayType], value : BArrayType) -> None:
+    #     raise NotImplementedError
+
+    @abc.abstractmethod
+    def get(self, index : Union[IndexableType, BArrayType]) -> BatchT:
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def set(self, index : Union[IndexableType, BArrayType], value : BatchT) -> None:
+        raise NotImplementedError
+    
+    def clear(self) -> None:
+        """
+        Clear all data inside the storage and set the length to 0 if the storage has unlimited capacity.
+        For storages with fixed capacity, this should reset the storage to its initial state.
+        """
+        if self.capacity is None:
+            self.shrink_length(len(self))
+
+    @abc.abstractmethod
+    def dumps(self, path : Union[str, os.PathLike]) -> None:
+        """
+        Dumps the storage to the specified path.
+        This is used for storages that have a single file extension (e.g. `.pt` for PyTorch).
+        """
+        raise NotImplementedError
+
+    def close(self) -> None:
+        pass
+
+    def __del__(self) -> None:
+        self.close()