Add files using upload-large-folder tool

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/__init__.py

@@ -0,0 +1,14 @@
+import importlib
+import sys
+
+__version__, _, _ = sys.version.partition(' ')
+
+
+try:
+    # Allow Debian and pkgsrc (only) to customize system
+    # behavior. Ref pypa/distutils#2 and pypa/distutils#16.
+    # This hook is deprecated and no other environments
+    # should use it.
+    importlib.import_module('_distutils_system_mod')
+except ImportError:
+    pass

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/dep_util.py

@@ -0,0 +1,14 @@
+import warnings
+
+from . import _modified
+
+
+def __getattr__(name):
+    if name not in ['newer', 'newer_group', 'newer_pairwise']:
+        raise AttributeError(name)
+    warnings.warn(
+        "dep_util is Deprecated. Use functions from setuptools instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return getattr(_modified, name)

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/errors.py

@@ -0,0 +1,108 @@
+"""
+Exceptions used by the Distutils modules.
+
+Distutils modules may raise these or standard exceptions,
+including :exc:`SystemExit`.
+"""
+
+# compiler exceptions aliased for compatibility
+from .compilers.C.errors import CompileError as CompileError
+from .compilers.C.errors import Error as _Error
+from .compilers.C.errors import LibError as LibError
+from .compilers.C.errors import LinkError as LinkError
+from .compilers.C.errors import PreprocessError as PreprocessError
+from .compilers.C.errors import UnknownFileType as _UnknownFileType
+
+CCompilerError = _Error
+UnknownFileError = _UnknownFileType
+
+
+class DistutilsError(Exception):
+    """The root of all Distutils evil."""
+
+    pass
+
+
+class DistutilsModuleError(DistutilsError):
+    """Unable to load an expected module, or to find an expected class
+    within some module (in particular, command modules and classes)."""
+
+    pass
+
+
+class DistutilsClassError(DistutilsError):
+    """Some command class (or possibly distribution class, if anyone
+    feels a need to subclass Distribution) is found not to be holding
+    up its end of the bargain, ie. implementing some part of the
+    "command "interface."""
+
+    pass
+
+
+class DistutilsGetoptError(DistutilsError):
+    """The option table provided to 'fancy_getopt()' is bogus."""
+
+    pass
+
+
+class DistutilsArgError(DistutilsError):
+    """Raised by fancy_getopt in response to getopt.error -- ie. an
+    error in the command line usage."""
+
+    pass
+
+
+class DistutilsFileError(DistutilsError):
+    """Any problems in the filesystem: expected file not found, etc.
+    Typically this is for problems that we detect before OSError
+    could be raised."""
+
+    pass
+
+
+class DistutilsOptionError(DistutilsError):
+    """Syntactic/semantic errors in command options, such as use of
+    mutually conflicting options, or inconsistent options,
+    badly-spelled values, etc.  No distinction is made between option
+    values originating in the setup script, the command line, config
+    files, or what-have-you -- but if we *know* something originated in
+    the setup script, we'll raise DistutilsSetupError instead."""
+
+    pass
+
+
+class DistutilsSetupError(DistutilsError):
+    """For errors that can be definitely blamed on the setup script,
+    such as invalid keyword arguments to 'setup()'."""
+
+    pass
+
+
+class DistutilsPlatformError(DistutilsError):
+    """We don't know how to do something on the current platform (but
+    we do know how to do it on some platform) -- eg. trying to compile
+    C files on a platform not supported by a CCompiler subclass."""
+
+    pass
+
+
+class DistutilsExecError(DistutilsError):
+    """Any problems executing an external program (such as the C
+    compiler, when compiling C files)."""
+
+    pass
+
+
+class DistutilsInternalError(DistutilsError):
+    """Internal inconsistencies or impossibilities (obviously, this
+    should never be seen if the code is working!)."""
+
+    pass
+
+
+class DistutilsTemplateError(DistutilsError):
+    """Syntax error in a file list template."""
+
+
+class DistutilsByteCompileError(DistutilsError):
+    """Byte compile error."""

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/extension.py

@@ -0,0 +1,258 @@
+"""distutils.extension
+
+Provides the Extension class, used to describe C/C++ extension
+modules in setup scripts."""
+
+from __future__ import annotations
+
+import os
+import warnings
+from collections.abc import Iterable
+
+# This class is really only used by the "build_ext" command, so it might
+# make sense to put it in distutils.command.build_ext.  However, that
+# module is already big enough, and I want to make this class a bit more
+# complex to simplify some common cases ("foo" module in "foo.c") and do
+# better error-checking ("foo.c" actually exists).
+#
+# Also, putting this in build_ext.py means every setup script would have to
+# import that large-ish module (indirectly, through distutils.core) in
+# order to do anything.
+
+
+class Extension:
+    """Just a collection of attributes that describes an extension
+    module and everything needed to build it (hopefully in a portable
+    way, but there are hooks that let you be as unportable as you need).
+
+    Instance attributes:
+      name : string
+        the full name of the extension, including any packages -- ie.
+        *not* a filename or pathname, but Python dotted name
+      sources : Iterable[string | os.PathLike]
+        iterable of source filenames (except strings, which could be misinterpreted
+        as a single filename), relative to the distribution root (where the setup
+        script lives), in Unix form (slash-separated) for portability. Can be any
+        non-string iterable (list, tuple, set, etc.) containing strings or
+        PathLike objects. Source files may be C, C++, SWIG (.i), platform-specific
+        resource files, or whatever else is recognized by the "build_ext" command
+        as source for a Python extension.
+      include_dirs : [string]
+        list of directories to search for C/C++ header files (in Unix
+        form for portability)
+      define_macros : [(name : string, value : string|None)]
+        list of macros to define; each macro is defined using a 2-tuple,
+        where 'value' is either the string to define it to or None to
+        define it without a particular value (equivalent of "#define
+        FOO" in source or -DFOO on Unix C compiler command line)
+      undef_macros : [string]
+        list of macros to undefine explicitly
+      library_dirs : [string]
+        list of directories to search for C/C++ libraries at link time
+      libraries : [string]
+        list of library names (not filenames or paths) to link against
+      runtime_library_dirs : [string]
+        list of directories to search for C/C++ libraries at run time
+        (for shared extensions, this is when the extension is loaded)
+      extra_objects : [string]
+        list of extra files to link with (eg. object files not implied
+        by 'sources', static library that must be explicitly specified,
+        binary resource files, etc.)
+      extra_compile_args : [string]
+        any extra platform- and compiler-specific information to use
+        when compiling the source files in 'sources'.  For platforms and
+        compilers where "command line" makes sense, this is typically a
+        list of command-line arguments, but for other platforms it could
+        be anything.
+      extra_link_args : [string]
+        any extra platform- and compiler-specific information to use
+        when linking object files together to create the extension (or
+        to create a new static Python interpreter).  Similar
+        interpretation as for 'extra_compile_args'.
+      export_symbols : [string]
+        list of symbols to be exported from a shared extension.  Not
+        used on all platforms, and not generally necessary for Python
+        extensions, which typically export exactly one symbol: "init" +
+        extension_name.
+      swig_opts : [string]
+        any extra options to pass to SWIG if a source file has the .i
+        extension.
+      depends : [string]
+        list of files that the extension depends on
+      language : string
+        extension language (i.e. "c", "c++", "objc"). Will be detected
+        from the source extensions if not provided.
+      optional : boolean
+        specifies that a build failure in the extension should not abort the
+        build process, but simply not install the failing extension.
+    """
+
+    # When adding arguments to this constructor, be sure to update
+    # setup_keywords in core.py.
+    def __init__(
+        self,
+        name: str,
+        sources: Iterable[str | os.PathLike[str]],
+        include_dirs: list[str] | None = None,
+        define_macros: list[tuple[str, str | None]] | None = None,
+        undef_macros: list[str] | None = None,
+        library_dirs: list[str] | None = None,
+        libraries: list[str] | None = None,
+        runtime_library_dirs: list[str] | None = None,
+        extra_objects: list[str] | None = None,
+        extra_compile_args: list[str] | None = None,
+        extra_link_args: list[str] | None = None,
+        export_symbols: list[str] | None = None,
+        swig_opts: list[str] | None = None,
+        depends: list[str] | None = None,
+        language: str | None = None,
+        optional: bool | None = None,
+        **kw,  # To catch unknown keywords
+    ):
+        if not isinstance(name, str):
+            raise TypeError("'name' must be a string")
+
+        # handle the string case first; since strings are iterable, disallow them
+        if isinstance(sources, str):
+            raise TypeError(
+                "'sources' must be an iterable of strings or PathLike objects, not a string"
+            )
+
+        # now we check if it's iterable and contains valid types
+        try:
+            self.sources = list(map(os.fspath, sources))
+        except TypeError:
+            raise TypeError(
+                "'sources' must be an iterable of strings or PathLike objects"
+            )
+
+        self.name = name
+        self.include_dirs = include_dirs or []
+        self.define_macros = define_macros or []
+        self.undef_macros = undef_macros or []
+        self.library_dirs = library_dirs or []
+        self.libraries = libraries or []
+        self.runtime_library_dirs = runtime_library_dirs or []
+        self.extra_objects = extra_objects or []
+        self.extra_compile_args = extra_compile_args or []
+        self.extra_link_args = extra_link_args or []
+        self.export_symbols = export_symbols or []
+        self.swig_opts = swig_opts or []
+        self.depends = depends or []
+        self.language = language
+        self.optional = optional
+
+        # If there are unknown keyword options, warn about them
+        if len(kw) > 0:
+            options = [repr(option) for option in kw]
+            options = ', '.join(sorted(options))
+            msg = f"Unknown Extension options: {options}"
+            warnings.warn(msg)
+
+    def __repr__(self):
+        return f'<{self.__class__.__module__}.{self.__class__.__qualname__}({self.name!r}) at {id(self):#x}>'
+
+
+def read_setup_file(filename):  # noqa: C901
+    """Reads a Setup file and returns Extension instances."""
+    from distutils.sysconfig import _variable_rx, expand_makefile_vars, parse_makefile
+    from distutils.text_file import TextFile
+    from distutils.util import split_quoted
+
+    # First pass over the file to gather "VAR = VALUE" assignments.
+    vars = parse_makefile(filename)
+
+    # Second pass to gobble up the real content: lines of the form
+    #   <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
+    file = TextFile(
+        filename,
+        strip_comments=True,
+        skip_blanks=True,
+        join_lines=True,
+        lstrip_ws=True,
+        rstrip_ws=True,
+    )
+    try:
+        extensions = []
+
+        while True:
+            line = file.readline()
+            if line is None:  # eof
+                break
+            if _variable_rx.match(line):  # VAR=VALUE, handled in first pass
+                continue
+
+            if line[0] == line[-1] == "*":
+                file.warn(f"'{line}' lines not handled yet")
+                continue
+
+            line = expand_makefile_vars(line, vars)
+            words = split_quoted(line)
+
+            # NB. this parses a slightly different syntax than the old
+            # makesetup script: here, there must be exactly one extension per
+            # line, and it must be the first word of the line.  I have no idea
+            # why the old syntax supported multiple extensions per line, as
+            # they all wind up being the same.
+
+            module = words[0]
+            ext = Extension(module, [])
+            append_next_word = None
+
+            for word in words[1:]:
+                if append_next_word is not None:
+                    append_next_word.append(word)
+                    append_next_word = None
+                    continue
+
+                suffix = os.path.splitext(word)[1]
+                switch = word[0:2]
+                value = word[2:]
+
+                if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
+                    # hmm, should we do something about C vs. C++ sources?
+                    # or leave it up to the CCompiler implementation to
+                    # worry about?
+                    ext.sources.append(word)
+                elif switch == "-I":
+                    ext.include_dirs.append(value)
+                elif switch == "-D":
+                    equals = value.find("=")
+                    if equals == -1:  # bare "-DFOO" -- no value
+                        ext.define_macros.append((value, None))
+                    else:  # "-DFOO=blah"
+                        ext.define_macros.append((value[0:equals], value[equals + 2 :]))
+                elif switch == "-U":
+                    ext.undef_macros.append(value)
+                elif switch == "-C":  # only here 'cause makesetup has it!
+                    ext.extra_compile_args.append(word)
+                elif switch == "-l":
+                    ext.libraries.append(value)
+                elif switch == "-L":
+                    ext.library_dirs.append(value)
+                elif switch == "-R":
+                    ext.runtime_library_dirs.append(value)
+                elif word == "-rpath":
+                    append_next_word = ext.runtime_library_dirs
+                elif word == "-Xlinker":
+                    append_next_word = ext.extra_link_args
+                elif word == "-Xcompiler":
+                    append_next_word = ext.extra_compile_args
+                elif switch == "-u":
+                    ext.extra_link_args.append(word)
+                    if not value:
+                        append_next_word = ext.extra_link_args
+                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
+                    # NB. a really faithful emulation of makesetup would
+                    # append a .o file to extra_objects only if it
+                    # had a slash in it; otherwise, it would s/.o/.c/
+                    # and append it to sources.  Hmmmm.
+                    ext.extra_objects.append(word)
+                else:
+                    file.warn(f"unrecognized argument '{word}'")
+
+            extensions.append(ext)
+    finally:
+        file.close()
+
+    return extensions

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/support.py

@@ -0,0 +1,134 @@
+"""Support code for distutils test cases."""
+
+import itertools
+import os
+import pathlib
+import shutil
+import sys
+import sysconfig
+import tempfile
+from distutils.core import Distribution
+
+import pytest
+from more_itertools import always_iterable
+
+
+@pytest.mark.usefixtures('distutils_managed_tempdir')
+class TempdirManager:
+    """
+    Mix-in class that handles temporary directories for test cases.
+    """
+
+    def mkdtemp(self):
+        """Create a temporary directory that will be cleaned up.
+
+        Returns the path of the directory.
+        """
+        d = tempfile.mkdtemp()
+        self.tempdirs.append(d)
+        return d
+
+    def write_file(self, path, content='xxx'):
+        """Writes a file in the given path.
+
+        path can be a string or a sequence.
+        """
+        pathlib.Path(*always_iterable(path)).write_text(content, encoding='utf-8')
+
+    def create_dist(self, pkg_name='foo', **kw):
+        """Will generate a test environment.
+
+        This function creates:
+         - a Distribution instance using keywords
+         - a temporary directory with a package structure
+
+        It returns the package directory and the distribution
+        instance.
+        """
+        tmp_dir = self.mkdtemp()
+        pkg_dir = os.path.join(tmp_dir, pkg_name)
+        os.mkdir(pkg_dir)
+        dist = Distribution(attrs=kw)
+
+        return pkg_dir, dist
+
+
+class DummyCommand:
+    """Class to store options for retrieval via set_undefined_options()."""
+
+    def __init__(self, **kwargs):
+        vars(self).update(kwargs)
+
+    def ensure_finalized(self):
+        pass
+
+
+def copy_xxmodule_c(directory):
+    """Helper for tests that need the xxmodule.c source file.
+
+    Example use:
+
+        def test_compile(self):
+            copy_xxmodule_c(self.tmpdir)
+            self.assertIn('xxmodule.c', os.listdir(self.tmpdir))
+
+    If the source file can be found, it will be copied to *directory*.  If not,
+    the test will be skipped.  Errors during copy are not caught.
+    """
+    shutil.copy(_get_xxmodule_path(), os.path.join(directory, 'xxmodule.c'))
+
+
+def _get_xxmodule_path():
+    source_name = 'xxmodule.c' if sys.version_info > (3, 9) else 'xxmodule-3.8.c'
+    return os.path.join(os.path.dirname(__file__), source_name)
+
+
+def fixup_build_ext(cmd):
+    """Function needed to make build_ext tests pass.
+
+    When Python was built with --enable-shared on Unix, -L. is not enough to
+    find libpython<blah>.so, because regrtest runs in a tempdir, not in the
+    source directory where the .so lives.
+
+    When Python was built with in debug mode on Windows, build_ext commands
+    need their debug attribute set, and it is not done automatically for
+    some reason.
+
+    This function handles both of these things.  Example use:
+
+        cmd = build_ext(dist)
+        support.fixup_build_ext(cmd)
+        cmd.ensure_finalized()
+
+    Unlike most other Unix platforms, Mac OS X embeds absolute paths
+    to shared libraries into executables, so the fixup is not needed there.
+    """
+    if os.name == 'nt':
+        cmd.debug = sys.executable.endswith('_d.exe')
+    elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
+        # To further add to the shared builds fun on Unix, we can't just add
+        # library_dirs to the Extension() instance because that doesn't get
+        # plumbed through to the final compiler command.
+        runshared = sysconfig.get_config_var('RUNSHARED')
+        if runshared is None:
+            cmd.library_dirs = ['.']
+        else:
+            if sys.platform == 'darwin':
+                cmd.library_dirs = []
+            else:
+                name, equals, value = runshared.partition('=')
+                cmd.library_dirs = [d for d in value.split(os.pathsep) if d]
+
+
+def combine_markers(cls):
+    """
+    pytest will honor markers as found on the class, but when
+    markers are on multiple subclasses, only one appears. Use
+    this decorator to combine those markers.
+    """
+    cls.pytestmark = [
+        mark
+        for base in itertools.chain([cls], cls.__bases__)
+        for mark in getattr(base, 'pytestmark', [])
+    ]
+    return cls

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_bdist_rpm.py

@@ -0,0 +1,127 @@
+"""Tests for distutils.command.bdist_rpm."""
+
+import os
+import shutil  # noqa: F401
+import sys
+from distutils.command.bdist_rpm import bdist_rpm
+from distutils.core import Distribution
+from distutils.tests import support
+
+import pytest
+from test.support import requires_zlib
+
+SETUP_PY = """\
+from distutils.core import setup
+import foo
+
+setup(name='foo', version='0.1', py_modules=['foo'],
+      url='xxx', author='xxx', author_email='xxx')
+
+"""
+
+
+@pytest.fixture(autouse=True)
+def sys_executable_encodable():
+    try:
+        sys.executable.encode('UTF-8')
+    except UnicodeEncodeError:
+        pytest.skip("sys.executable is not encodable to UTF-8")
+
+
+mac_woes = pytest.mark.skipif(
+    "not sys.platform.startswith('linux')",
+    reason='spurious sdtout/stderr output under macOS',
+)
+
+
+@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
+@pytest.mark.usefixtures('save_cwd')
+class TestBuildRpm(
+    support.TempdirManager,
+):
+    @mac_woes
+    @requires_zlib()
+    @pytest.mark.skipif("not shutil.which('rpm')")
+    @pytest.mark.skipif("not shutil.which('rpmbuild')")
+    def test_quiet(self):
+        # let's create a package
+        tmp_dir = self.mkdtemp()
+        os.environ['HOME'] = tmp_dir  # to confine dir '.rpmdb' creation
+        pkg_dir = os.path.join(tmp_dir, 'foo')
+        os.mkdir(pkg_dir)
+        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
+        self.write_file((pkg_dir, 'foo.py'), '#')
+        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
+        self.write_file((pkg_dir, 'README'), '')
+
+        dist = Distribution({
+            'name': 'foo',
+            'version': '0.1',
+            'py_modules': ['foo'],
+            'url': 'xxx',
+            'author': 'xxx',
+            'author_email': 'xxx',
+        })
+        dist.script_name = 'setup.py'
+        os.chdir(pkg_dir)
+
+        sys.argv = ['setup.py']
+        cmd = bdist_rpm(dist)
+        cmd.fix_python = True
+
+        # running in quiet mode
+        cmd.quiet = True
+        cmd.ensure_finalized()
+        cmd.run()
+
+        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
+        assert 'foo-0.1-1.noarch.rpm' in dist_created
+
+        # bug #2945: upload ignores bdist_rpm files
+        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files
+        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files
+
+    @mac_woes
+    @requires_zlib()
+    # https://bugs.python.org/issue1533164
+    @pytest.mark.skipif("not shutil.which('rpm')")
+    @pytest.mark.skipif("not shutil.which('rpmbuild')")
+    def test_no_optimize_flag(self):
+        # let's create a package that breaks bdist_rpm
+        tmp_dir = self.mkdtemp()
+        os.environ['HOME'] = tmp_dir  # to confine dir '.rpmdb' creation
+        pkg_dir = os.path.join(tmp_dir, 'foo')
+        os.mkdir(pkg_dir)
+        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
+        self.write_file((pkg_dir, 'foo.py'), '#')
+        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
+        self.write_file((pkg_dir, 'README'), '')
+
+        dist = Distribution({
+            'name': 'foo',
+            'version': '0.1',
+            'py_modules': ['foo'],
+            'url': 'xxx',
+            'author': 'xxx',
+            'author_email': 'xxx',
+        })
+        dist.script_name = 'setup.py'
+        os.chdir(pkg_dir)
+
+        sys.argv = ['setup.py']
+        cmd = bdist_rpm(dist)
+        cmd.fix_python = True
+
+        cmd.quiet = True
+        cmd.ensure_finalized()
+        cmd.run()
+
+        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
+        assert 'foo-0.1-1.noarch.rpm' in dist_created
+
+        # bug #2945: upload ignores bdist_rpm files
+        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files
+        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files
+
+        os.remove(os.path.join(pkg_dir, 'dist', 'foo-0.1-1.noarch.rpm'))

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_build.py

@@ -0,0 +1,49 @@
+"""Tests for distutils.command.build."""
+
+import os
+import sys
+from distutils.command.build import build
+from distutils.tests import support
+from sysconfig import get_config_var, get_platform
+
+
+class TestBuild(support.TempdirManager):
+    def test_finalize_options(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build(dist)
+        cmd.finalize_options()
+
+        # if not specified, plat_name gets the current platform
+        assert cmd.plat_name == get_platform()
+
+        # build_purelib is build + lib
+        wanted = os.path.join(cmd.build_base, 'lib')
+        assert cmd.build_purelib == wanted
+
+        # build_platlib is 'build/lib.platform-cache_tag[-pydebug]'
+        # examples:
+        #   build/lib.macosx-10.3-i386-cpython39
+        plat_spec = f'.{cmd.plat_name}-{sys.implementation.cache_tag}'
+        if get_config_var('Py_GIL_DISABLED'):
+            plat_spec += 't'
+        if hasattr(sys, 'gettotalrefcount'):
+            assert cmd.build_platlib.endswith('-pydebug')
+            plat_spec += '-pydebug'
+        wanted = os.path.join(cmd.build_base, 'lib' + plat_spec)
+        assert cmd.build_platlib == wanted
+
+        # by default, build_lib = build_purelib
+        assert cmd.build_lib == cmd.build_purelib
+
+        # build_temp is build/temp.<plat>
+        wanted = os.path.join(cmd.build_base, 'temp' + plat_spec)
+        assert cmd.build_temp == wanted
+
+        # build_scripts is build/scripts-x.x
+        wanted = os.path.join(
+            cmd.build_base, f'scripts-{sys.version_info.major}.{sys.version_info.minor}'
+        )
+        assert cmd.build_scripts == wanted
+
+        # executable is os.path.normpath(sys.executable)
+        assert cmd.executable == os.path.normpath(sys.executable)

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_build_clib.py

@@ -0,0 +1,134 @@
+"""Tests for distutils.command.build_clib."""
+
+import os
+from distutils.command.build_clib import build_clib
+from distutils.errors import DistutilsSetupError
+from distutils.tests import missing_compiler_executable, support
+
+import pytest
+
+
+class TestBuildCLib(support.TempdirManager):
+    def test_check_library_dist(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        # 'libraries' option must be a list
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list('foo')
+
+        # each element of 'libraries' must a 2-tuple
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list(['foo1', 'foo2'])
+
+        # first element of each tuple in 'libraries'
+        # must be a string (the library name)
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list([(1, 'foo1'), ('name', 'foo2')])
+
+        # library name may not contain directory separators
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list(
+                [('name', 'foo1'), ('another/name', 'foo2')],
+            )
+
+        # second element of each tuple must be a dictionary (build info)
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list(
+                [('name', {}), ('another', 'foo2')],
+            )
+
+        # those work
+        libs = [('name', {}), ('name', {'ok': 'good'})]
+        cmd.check_library_list(libs)
+
+    def test_get_source_files(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        # "in 'libraries' option 'sources' must be present and must be
+        # a list of source filenames
+        cmd.libraries = [('name', {})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.get_source_files()
+
+        cmd.libraries = [('name', {'sources': 1})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.get_source_files()
+
+        cmd.libraries = [('name', {'sources': ['a', 'b']})]
+        assert cmd.get_source_files() == ['a', 'b']
+
+        cmd.libraries = [('name', {'sources': ('a', 'b')})]
+        assert cmd.get_source_files() == ['a', 'b']
+
+        cmd.libraries = [
+            ('name', {'sources': ('a', 'b')}),
+            ('name2', {'sources': ['c', 'd']}),
+        ]
+        assert cmd.get_source_files() == ['a', 'b', 'c', 'd']
+
+    def test_build_libraries(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        class FakeCompiler:
+            def compile(*args, **kw):
+                pass
+
+            create_static_lib = compile
+
+        cmd.compiler = FakeCompiler()
+
+        # build_libraries is also doing a bit of typo checking
+        lib = [('name', {'sources': 'notvalid'})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.build_libraries(lib)
+
+        lib = [('name', {'sources': list()})]
+        cmd.build_libraries(lib)
+
+        lib = [('name', {'sources': tuple()})]
+        cmd.build_libraries(lib)
+
+    def test_finalize_options(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        cmd.include_dirs = 'one-dir'
+        cmd.finalize_options()
+        assert cmd.include_dirs == ['one-dir']
+
+        cmd.include_dirs = None
+        cmd.finalize_options()
+        assert cmd.include_dirs == []
+
+        cmd.distribution.libraries = 'WONTWORK'
+        with pytest.raises(DistutilsSetupError):
+            cmd.finalize_options()
+
+    @pytest.mark.skipif('platform.system() == "Windows"')
+    def test_run(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        foo_c = os.path.join(pkg_dir, 'foo.c')
+        self.write_file(foo_c, 'int main(void) { return 1;}\n')
+        cmd.libraries = [('foo', {'sources': [foo_c]})]
+
+        build_temp = os.path.join(pkg_dir, 'build')
+        os.mkdir(build_temp)
+        cmd.build_temp = build_temp
+        cmd.build_clib = build_temp
+
+        # Before we run the command, we want to make sure
+        # all commands are present on the system.
+        ccmd = missing_compiler_executable()
+        if ccmd is not None:
+            self.skipTest(f'The {ccmd!r} command is not found')
+
+        # this should work
+        cmd.run()
+
+        # let's check the result
+        assert 'libfoo.a' in os.listdir(build_temp)

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_build_ext.py

@@ -0,0 +1,628 @@
+import contextlib
+import glob
+import importlib
+import os.path
+import platform
+import re
+import shutil
+import site
+import subprocess
+import sys
+import tempfile
+import textwrap
+import time
+from distutils import sysconfig
+from distutils.command.build_ext import build_ext
+from distutils.core import Distribution
+from distutils.errors import (
+    CompileError,
+    DistutilsPlatformError,
+    DistutilsSetupError,
+    UnknownFileError,
+)
+from distutils.extension import Extension
+from distutils.tests import missing_compiler_executable
+from distutils.tests.support import TempdirManager, copy_xxmodule_c, fixup_build_ext
+from io import StringIO
+
+import jaraco.path
+import path
+import pytest
+from test import support
+
+from .compat import py39 as import_helper
+
+
+@pytest.fixture()
+def user_site_dir(request):
+    self = request.instance
+    self.tmp_dir = self.mkdtemp()
+    self.tmp_path = path.Path(self.tmp_dir)
+    from distutils.command import build_ext
+
+    orig_user_base = site.USER_BASE
+
+    site.USER_BASE = self.mkdtemp()
+    build_ext.USER_BASE = site.USER_BASE
+
+    # bpo-30132: On Windows, a .pdb file may be created in the current
+    # working directory. Create a temporary working directory to cleanup
+    # everything at the end of the test.
+    with self.tmp_path:
+        yield
+
+    site.USER_BASE = orig_user_base
+    build_ext.USER_BASE = orig_user_base
+
+    if sys.platform == 'cygwin':
+        time.sleep(1)
+
+
+@contextlib.contextmanager
+def safe_extension_import(name, path):
+    with import_helper.CleanImport(name):
+        with extension_redirect(name, path) as new_path:
+            with import_helper.DirsOnSysPath(new_path):
+                yield
+
+
+@contextlib.contextmanager
+def extension_redirect(mod, path):
+    """
+    Tests will fail to tear down an extension module if it's been imported.
+
+    Before importing, copy the file to a temporary directory that won't
+    be cleaned up. Yield the new path.
+    """
+    if platform.system() != "Windows" and sys.platform != "cygwin":
+        yield path
+        return
+    with import_helper.DirsOnSysPath(path):
+        spec = importlib.util.find_spec(mod)
+    filename = os.path.basename(spec.origin)
+    trash_dir = tempfile.mkdtemp(prefix='deleteme')
+    dest = os.path.join(trash_dir, os.path.basename(filename))
+    shutil.copy(spec.origin, dest)
+    yield trash_dir
+    # TODO: can the file be scheduled for deletion?
+
+
+@pytest.mark.usefixtures('user_site_dir')
+class TestBuildExt(TempdirManager):
+    def build_ext(self, *args, **kwargs):
+        return build_ext(*args, **kwargs)
+
+    @pytest.mark.parametrize("copy_so", [False])
+    def test_build_ext(self, copy_so):
+        missing_compiler_executable()
+        copy_xxmodule_c(self.tmp_dir)
+        xx_c = os.path.join(self.tmp_dir, 'xxmodule.c')
+        xx_ext = Extension('xx', [xx_c])
+        if sys.platform != "win32":
+            if not copy_so:
+                xx_ext = Extension(
+                    'xx',
+                    [xx_c],
+                    library_dirs=['/usr/lib'],
+                    libraries=['z'],
+                    runtime_library_dirs=['/usr/lib'],
+                )
+            elif sys.platform == 'linux':
+                libz_so = {
+                    os.path.realpath(name) for name in glob.iglob('/usr/lib*/libz.so*')
+                }
+                libz_so = sorted(libz_so, key=lambda lib_path: len(lib_path))
+                shutil.copyfile(libz_so[-1], '/tmp/libxx_z.so')
+
+                xx_ext = Extension(
+                    'xx',
+                    [xx_c],
+                    library_dirs=['/tmp'],
+                    libraries=['xx_z'],
+                    runtime_library_dirs=['/tmp'],
+                )
+        dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]})
+        dist.package_dir = self.tmp_dir
+        cmd = self.build_ext(dist)
+        fixup_build_ext(cmd)
+        cmd.build_lib = self.tmp_dir
+        cmd.build_temp = self.tmp_dir
+
+        old_stdout = sys.stdout
+        if not support.verbose:
+            # silence compiler output
+            sys.stdout = StringIO()
+        try:
+            cmd.ensure_finalized()
+            cmd.run()
+        finally:
+            sys.stdout = old_stdout
+
+        with safe_extension_import('xx', self.tmp_dir):
+            self._test_xx(copy_so)
+
+        if sys.platform == 'linux' and copy_so:
+            os.unlink('/tmp/libxx_z.so')
+
+    @staticmethod
+    def _test_xx(copy_so):
+        import xx  # type: ignore[import-not-found] # Module generated for tests
+
+        for attr in ('error', 'foo', 'new', 'roj'):
+            assert hasattr(xx, attr)
+
+        assert xx.foo(2, 5) == 7
+        assert xx.foo(13, 15) == 28
+        assert xx.new().demo() is None
+        if support.HAVE_DOCSTRINGS:
+            doc = 'This is a template module just for instruction.'
+            assert xx.__doc__ == doc
+        assert isinstance(xx.Null(), xx.Null)
+        assert isinstance(xx.Str(), xx.Str)
+
+        if sys.platform == 'linux':
+            so_headers = subprocess.check_output(
+                ["readelf", "-d", xx.__file__], universal_newlines=True
+            )
+            import pprint
+
+            pprint.pprint(so_headers)
+            rpaths = [
+                rpath
+                for line in so_headers.split("\n")
+                if "RPATH" in line or "RUNPATH" in line
+                for rpath in line.split()[2][1:-1].split(":")
+            ]
+            if not copy_so:
+                pprint.pprint(rpaths)
+                # Linked against a library in /usr/lib{,64}
+                assert "/usr/lib" not in rpaths and "/usr/lib64" not in rpaths
+            else:
+                # Linked against a library in /tmp
+                assert "/tmp" in rpaths
+                # The import is the real test here
+
+    def test_solaris_enable_shared(self):
+        dist = Distribution({'name': 'xx'})
+        cmd = self.build_ext(dist)
+        old = sys.platform
+
+        sys.platform = 'sunos'  # fooling finalize_options
+        from distutils.sysconfig import _config_vars
+
+        old_var = _config_vars.get('Py_ENABLE_SHARED')
+        _config_vars['Py_ENABLE_SHARED'] = True
+        try:
+            cmd.ensure_finalized()
+        finally:
+            sys.platform = old
+            if old_var is None:
+                del _config_vars['Py_ENABLE_SHARED']
+            else:
+                _config_vars['Py_ENABLE_SHARED'] = old_var
+
+        # make sure we get some library dirs under solaris
+        assert len(cmd.library_dirs) > 0
+
+    def test_user_site(self):
+        import site
+
+        dist = Distribution({'name': 'xx'})
+        cmd = self.build_ext(dist)
+
+        # making sure the user option is there
+        options = [name for name, short, label in cmd.user_options]
+        assert 'user' in options
+
+        # setting a value
+        cmd.user = True
+
+        # setting user based lib and include
+        lib = os.path.join(site.USER_BASE, 'lib')
+        incl = os.path.join(site.USER_BASE, 'include')
+        os.mkdir(lib)
+        os.mkdir(incl)
+
+        # let's run finalize
+        cmd.ensure_finalized()
+
+        # see if include_dirs and library_dirs
+        # were set
+        assert lib in cmd.library_dirs
+        assert lib in cmd.rpath
+        assert incl in cmd.include_dirs
+
+    def test_optional_extension(self):
+        # this extension will fail, but let's ignore this failure
+        # with the optional argument.
+        modules = [Extension('foo', ['xxx'], optional=False)]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        with pytest.raises((UnknownFileError, CompileError)):
+            cmd.run()  # should raise an error
+
+        modules = [Extension('foo', ['xxx'], optional=True)]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        cmd.run()  # should pass
+
+    def test_finalize_options(self):
+        # Make sure Python's include directories (for Python.h, pyconfig.h,
+        # etc.) are in the include search path.
+        modules = [Extension('foo', ['xxx'], optional=False)]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.finalize_options()
+
+        py_include = sysconfig.get_python_inc()
+        for p in py_include.split(os.path.pathsep):
+            assert p in cmd.include_dirs
+
+        plat_py_include = sysconfig.get_python_inc(plat_specific=True)
+        for p in plat_py_include.split(os.path.pathsep):
+            assert p in cmd.include_dirs
+
+        # make sure cmd.libraries is turned into a list
+        # if it's a string
+        cmd = self.build_ext(dist)
+        cmd.libraries = 'my_lib, other_lib lastlib'
+        cmd.finalize_options()
+        assert cmd.libraries == ['my_lib', 'other_lib', 'lastlib']
+
+        # make sure cmd.library_dirs is turned into a list
+        # if it's a string
+        cmd = self.build_ext(dist)
+        cmd.library_dirs = f'my_lib_dir{os.pathsep}other_lib_dir'
+        cmd.finalize_options()
+        assert 'my_lib_dir' in cmd.library_dirs
+        assert 'other_lib_dir' in cmd.library_dirs
+
+        # make sure rpath is turned into a list
+        # if it's a string
+        cmd = self.build_ext(dist)
+        cmd.rpath = f'one{os.pathsep}two'
+        cmd.finalize_options()
+        assert cmd.rpath == ['one', 'two']
+
+        # make sure cmd.link_objects is turned into a list
+        # if it's a string
+        cmd = build_ext(dist)
+        cmd.link_objects = 'one two,three'
+        cmd.finalize_options()
+        assert cmd.link_objects == ['one', 'two', 'three']
+
+        # XXX more tests to perform for win32
+
+        # make sure define is turned into 2-tuples
+        # strings if they are ','-separated strings
+        cmd = self.build_ext(dist)
+        cmd.define = 'one,two'
+        cmd.finalize_options()
+        assert cmd.define == [('one', '1'), ('two', '1')]
+
+        # make sure undef is turned into a list of
+        # strings if they are ','-separated strings
+        cmd = self.build_ext(dist)
+        cmd.undef = 'one,two'
+        cmd.finalize_options()
+        assert cmd.undef == ['one', 'two']
+
+        # make sure swig_opts is turned into a list
+        cmd = self.build_ext(dist)
+        cmd.swig_opts = None
+        cmd.finalize_options()
+        assert cmd.swig_opts == []
+
+        cmd = self.build_ext(dist)
+        cmd.swig_opts = '1 2'
+        cmd.finalize_options()
+        assert cmd.swig_opts == ['1', '2']
+
+    def test_check_extensions_list(self):
+        dist = Distribution()
+        cmd = self.build_ext(dist)
+        cmd.finalize_options()
+
+        # 'extensions' option must be a list of Extension instances
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list('foo')
+
+        # each element of 'ext_modules' option must be an
+        # Extension instance or 2-tuple
+        exts = [('bar', 'foo', 'bar'), 'foo']
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list(exts)
+
+        # first element of each tuple in 'ext_modules'
+        # must be the extension name (a string) and match
+        # a python dotted-separated name
+        exts = [('foo-bar', '')]
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list(exts)
+
+        # second element of each tuple in 'ext_modules'
+        # must be a dictionary (build info)
+        exts = [('foo.bar', '')]
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list(exts)
+
+        # ok this one should pass
+        exts = [('foo.bar', {'sources': [''], 'libraries': 'foo', 'some': 'bar'})]
+        cmd.check_extensions_list(exts)
+        ext = exts[0]
+        assert isinstance(ext, Extension)
+
+        # check_extensions_list adds in ext the values passed
+        # when they are in ('include_dirs', 'library_dirs', 'libraries'
+        # 'extra_objects', 'extra_compile_args', 'extra_link_args')
+        assert ext.libraries == 'foo'
+        assert not hasattr(ext, 'some')
+
+        # 'macros' element of build info dict must be 1- or 2-tuple
+        exts = [
+            (
+                'foo.bar',
+                {
+                    'sources': [''],
+                    'libraries': 'foo',
+                    'some': 'bar',
+                    'macros': [('1', '2', '3'), 'foo'],
+                },
+            )
+        ]
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list(exts)
+
+        exts[0][1]['macros'] = [('1', '2'), ('3',)]
+        cmd.check_extensions_list(exts)
+        assert exts[0].undef_macros == ['3']
+        assert exts[0].define_macros == [('1', '2')]
+
+    def test_get_source_files(self):
+        modules = [Extension('foo', ['xxx'], optional=False)]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        assert cmd.get_source_files() == ['xxx']
+
+    def test_unicode_module_names(self):
+        modules = [
+            Extension('foo', ['aaa'], optional=False),
+            Extension('föö', ['uuu'], optional=False),
+        ]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        assert re.search(r'foo(_d)?\..*', cmd.get_ext_filename(modules[0].name))
+        assert re.search(r'föö(_d)?\..*', cmd.get_ext_filename(modules[1].name))
+        assert cmd.get_export_symbols(modules[0]) == ['PyInit_foo']
+        assert cmd.get_export_symbols(modules[1]) == ['PyInitU_f_1gaa']
+
+    def test_export_symbols__init__(self):
+        # https://github.com/python/cpython/issues/80074
+        # https://github.com/pypa/setuptools/issues/4826
+        modules = [
+            Extension('foo.__init__', ['aaa']),
+            Extension('föö.__init__', ['uuu']),
+        ]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        assert cmd.get_export_symbols(modules[0]) == ['PyInit_foo']
+        assert cmd.get_export_symbols(modules[1]) == ['PyInitU_f_1gaa']
+
+    def test_compiler_option(self):
+        # cmd.compiler is an option and
+        # should not be overridden by a compiler instance
+        # when the command is run
+        dist = Distribution()
+        cmd = self.build_ext(dist)
+        cmd.compiler = 'unix'
+        cmd.ensure_finalized()
+        cmd.run()
+        assert cmd.compiler == 'unix'
+
+    def test_get_outputs(self):
+        missing_compiler_executable()
+        tmp_dir = self.mkdtemp()
+        c_file = os.path.join(tmp_dir, 'foo.c')
+        self.write_file(c_file, 'void PyInit_foo(void) {}\n')
+        ext = Extension('foo', [c_file], optional=False)
+        dist = Distribution({'name': 'xx', 'ext_modules': [ext]})
+        cmd = self.build_ext(dist)
+        fixup_build_ext(cmd)
+        cmd.ensure_finalized()
+        assert len(cmd.get_outputs()) == 1
+
+        cmd.build_lib = os.path.join(self.tmp_dir, 'build')
+        cmd.build_temp = os.path.join(self.tmp_dir, 'tempt')
+
+        # issue #5977 : distutils build_ext.get_outputs
+        # returns wrong result with --inplace
+        other_tmp_dir = os.path.realpath(self.mkdtemp())
+        old_wd = os.getcwd()
+        os.chdir(other_tmp_dir)
+        try:
+            cmd.inplace = True
+            cmd.run()
+            so_file = cmd.get_outputs()[0]
+        finally:
+            os.chdir(old_wd)
+        assert os.path.exists(so_file)
+        ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
+        assert so_file.endswith(ext_suffix)
+        so_dir = os.path.dirname(so_file)
+        assert so_dir == other_tmp_dir
+
+        cmd.inplace = False
+        cmd.compiler = None
+        cmd.run()
+        so_file = cmd.get_outputs()[0]
+        assert os.path.exists(so_file)
+        assert so_file.endswith(ext_suffix)
+        so_dir = os.path.dirname(so_file)
+        assert so_dir == cmd.build_lib
+
+        # inplace = False, cmd.package = 'bar'
+        build_py = cmd.get_finalized_command('build_py')
+        build_py.package_dir = {'': 'bar'}
+        path = cmd.get_ext_fullpath('foo')
+        # checking that the last directory is the build_dir
+        path = os.path.split(path)[0]
+        assert path == cmd.build_lib
+
+        # inplace = True, cmd.package = 'bar'
+        cmd.inplace = True
+        other_tmp_dir = os.path.realpath(self.mkdtemp())
+        old_wd = os.getcwd()
+        os.chdir(other_tmp_dir)
+        try:
+            path = cmd.get_ext_fullpath('foo')
+        finally:
+            os.chdir(old_wd)
+        # checking that the last directory is bar
+        path = os.path.split(path)[0]
+        lastdir = os.path.split(path)[-1]
+        assert lastdir == 'bar'
+
+    def test_ext_fullpath(self):
+        ext = sysconfig.get_config_var('EXT_SUFFIX')
+        # building lxml.etree inplace
+        # etree_c = os.path.join(self.tmp_dir, 'lxml.etree.c')
+        # etree_ext = Extension('lxml.etree', [etree_c])
+        # dist = Distribution({'name': 'lxml', 'ext_modules': [etree_ext]})
+        dist = Distribution()
+        cmd = self.build_ext(dist)
+        cmd.inplace = True
+        cmd.distribution.package_dir = {'': 'src'}
+        cmd.distribution.packages = ['lxml', 'lxml.html']
+        curdir = os.getcwd()
+        wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
+        path = cmd.get_ext_fullpath('lxml.etree')
+        assert wanted == path
+
+        # building lxml.etree not inplace
+        cmd.inplace = False
+        cmd.build_lib = os.path.join(curdir, 'tmpdir')
+        wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext)
+        path = cmd.get_ext_fullpath('lxml.etree')
+        assert wanted == path
+
+        # building twisted.runner.portmap not inplace
+        build_py = cmd.get_finalized_command('build_py')
+        build_py.package_dir = {}
+        cmd.distribution.packages = ['twisted', 'twisted.runner.portmap']
+        path = cmd.get_ext_fullpath('twisted.runner.portmap')
+        wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner', 'portmap' + ext)
+        assert wanted == path
+
+        # building twisted.runner.portmap inplace
+        cmd.inplace = True
+        path = cmd.get_ext_fullpath('twisted.runner.portmap')
+        wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext)
+        assert wanted == path
+
+    @pytest.mark.skipif('platform.system() != "Darwin"')
+    @pytest.mark.usefixtures('save_env')
+    def test_deployment_target_default(self):
+        # Issue 9516: Test that, in the absence of the environment variable,
+        # an extension module is compiled with the same deployment target as
+        #  the interpreter.
+        self._try_compile_deployment_target('==', None)
+
+    @pytest.mark.skipif('platform.system() != "Darwin"')
+    @pytest.mark.usefixtures('save_env')
+    def test_deployment_target_too_low(self):
+        # Issue 9516: Test that an extension module is not allowed to be
+        # compiled with a deployment target less than that of the interpreter.
+        with pytest.raises(DistutilsPlatformError):
+            self._try_compile_deployment_target('>', '10.1')
+
+    @pytest.mark.skipif('platform.system() != "Darwin"')
+    @pytest.mark.usefixtures('save_env')
+    def test_deployment_target_higher_ok(self):  # pragma: no cover
+        # Issue 9516: Test that an extension module can be compiled with a
+        # deployment target higher than that of the interpreter: the ext
+        # module may depend on some newer OS feature.
+        deptarget = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
+        if deptarget:
+            # increment the minor version number (i.e. 10.6 -> 10.7)
+            deptarget = [int(x) for x in deptarget.split('.')]
+            deptarget[-1] += 1
+            deptarget = '.'.join(str(i) for i in deptarget)
+            self._try_compile_deployment_target('<', deptarget)
+
+    def _try_compile_deployment_target(self, operator, target):  # pragma: no cover
+        if target is None:
+            if os.environ.get('MACOSX_DEPLOYMENT_TARGET'):
+                del os.environ['MACOSX_DEPLOYMENT_TARGET']
+        else:
+            os.environ['MACOSX_DEPLOYMENT_TARGET'] = target
+
+        jaraco.path.build(
+            {
+                'deptargetmodule.c': textwrap.dedent(f"""\
+                    #include <AvailabilityMacros.h>
+
+                    int dummy;
+
+                    #if TARGET {operator} MAC_OS_X_VERSION_MIN_REQUIRED
+                    #else
+                    #error "Unexpected target"
+                    #endif
+
+                    """),
+            },
+            self.tmp_path,
+        )
+
+        # get the deployment target that the interpreter was built with
+        target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
+        target = tuple(map(int, target.split('.')[0:2]))
+        # format the target value as defined in the Apple
+        # Availability Macros.  We can't use the macro names since
+        # at least one value we test with will not exist yet.
+        if target[:2] < (10, 10):
+            # for 10.1 through 10.9.x -> "10n0"
+            tmpl = '{:02}{:01}0'
+        else:
+            # for 10.10 and beyond -> "10nn00"
+            if len(target) >= 2:
+                tmpl = '{:02}{:02}00'
+            else:
+                # 11 and later can have no minor version (11 instead of 11.0)
+                tmpl = '{:02}0000'
+        target = tmpl.format(*target)
+        deptarget_ext = Extension(
+            'deptarget',
+            [self.tmp_path / 'deptargetmodule.c'],
+            extra_compile_args=[f'-DTARGET={target}'],
+        )
+        dist = Distribution({'name': 'deptarget', 'ext_modules': [deptarget_ext]})
+        dist.package_dir = self.tmp_dir
+        cmd = self.build_ext(dist)
+        cmd.build_lib = self.tmp_dir
+        cmd.build_temp = self.tmp_dir
+
+        try:
+            old_stdout = sys.stdout
+            if not support.verbose:
+                # silence compiler output
+                sys.stdout = StringIO()
+            try:
+                cmd.ensure_finalized()
+                cmd.run()
+            finally:
+                sys.stdout = old_stdout
+
+        except CompileError:
+            self.fail("Wrong deployment target during compilation")
+
+
+class TestParallelBuildExt(TestBuildExt):
+    def build_ext(self, *args, **kwargs):
+        build_ext = super().build_ext(*args, **kwargs)
+        build_ext.parallel = True
+        return build_ext

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_build_py.py

@@ -0,0 +1,196 @@
+"""Tests for distutils.command.build_py."""
+
+import os
+import sys
+from distutils.command.build_py import build_py
+from distutils.core import Distribution
+from distutils.errors import DistutilsFileError
+from distutils.tests import support
+
+import jaraco.path
+import pytest
+
+
+@support.combine_markers
+class TestBuildPy(support.TempdirManager):
+    def test_package_data(self):
+        sources = self.mkdtemp()
+        jaraco.path.build(
+            {
+                '__init__.py': "# Pretend this is a package.",
+                'README.txt': 'Info about this package',
+            },
+            sources,
+        )
+
+        destination = self.mkdtemp()
+
+        dist = Distribution({"packages": ["pkg"], "package_dir": {"pkg": sources}})
+        # script_name need not exist, it just need to be initialized
+        dist.script_name = os.path.join(sources, "setup.py")
+        dist.command_obj["build"] = support.DummyCommand(
+            force=False, build_lib=destination
+        )
+        dist.packages = ["pkg"]
+        dist.package_data = {"pkg": ["README.txt"]}
+        dist.package_dir = {"pkg": sources}
+
+        cmd = build_py(dist)
+        cmd.compile = True
+        cmd.ensure_finalized()
+        assert cmd.package_data == dist.package_data
+
+        cmd.run()
+
+        # This makes sure the list of outputs includes byte-compiled
+        # files for Python modules but not for package data files
+        # (there shouldn't *be* byte-code files for those!).
+        assert len(cmd.get_outputs()) == 3
+        pkgdest = os.path.join(destination, "pkg")
+        files = os.listdir(pkgdest)
+        pycache_dir = os.path.join(pkgdest, "__pycache__")
+        assert "__init__.py" in files
+        assert "README.txt" in files
+        if sys.dont_write_bytecode:
+            assert not os.path.exists(pycache_dir)
+        else:
+            pyc_files = os.listdir(pycache_dir)
+            assert f"__init__.{sys.implementation.cache_tag}.pyc" in pyc_files
+
+    def test_empty_package_dir(self):
+        # See bugs #1668596/#1720897
+        sources = self.mkdtemp()
+        jaraco.path.build({'__init__.py': '', 'doc': {'testfile': ''}}, sources)
+
+        os.chdir(sources)
+        dist = Distribution({
+            "packages": ["pkg"],
+            "package_dir": {"pkg": ""},
+            "package_data": {"pkg": ["doc/*"]},
+        })
+        # script_name need not exist, it just need to be initialized
+        dist.script_name = os.path.join(sources, "setup.py")
+        dist.script_args = ["build"]
+        dist.parse_command_line()
+
+        try:
+            dist.run_commands()
+        except DistutilsFileError:
+            self.fail("failed package_data test when package_dir is ''")
+
+    @pytest.mark.skipif('sys.dont_write_bytecode')
+    def test_byte_compile(self):
+        project_dir, dist = self.create_dist(py_modules=['boiledeggs'])
+        os.chdir(project_dir)
+        self.write_file('boiledeggs.py', 'import antigravity')
+        cmd = build_py(dist)
+        cmd.compile = True
+        cmd.build_lib = 'here'
+        cmd.finalize_options()
+        cmd.run()
+
+        found = os.listdir(cmd.build_lib)
+        assert sorted(found) == ['__pycache__', 'boiledeggs.py']
+        found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
+        assert found == [f'boiledeggs.{sys.implementation.cache_tag}.pyc']
+
+    @pytest.mark.skipif('sys.dont_write_bytecode')
+    def test_byte_compile_optimized(self):
+        project_dir, dist = self.create_dist(py_modules=['boiledeggs'])
+        os.chdir(project_dir)
+        self.write_file('boiledeggs.py', 'import antigravity')
+        cmd = build_py(dist)
+        cmd.compile = False
+        cmd.optimize = 1
+        cmd.build_lib = 'here'
+        cmd.finalize_options()
+        cmd.run()
+
+        found = os.listdir(cmd.build_lib)
+        assert sorted(found) == ['__pycache__', 'boiledeggs.py']
+        found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
+        expect = f'boiledeggs.{sys.implementation.cache_tag}.opt-1.pyc'
+        assert sorted(found) == [expect]
+
+    def test_dir_in_package_data(self):
+        """
+        A directory in package_data should not be added to the filelist.
+        """
+        # See bug 19286
+        sources = self.mkdtemp()
+        jaraco.path.build(
+            {
+                'pkg': {
+                    '__init__.py': '',
+                    'doc': {
+                        'testfile': '',
+                        # create a directory that could be incorrectly detected as a file
+                        'otherdir': {},
+                    },
+                }
+            },
+            sources,
+        )
+
+        os.chdir(sources)
+        dist = Distribution({"packages": ["pkg"], "package_data": {"pkg": ["doc/*"]}})
+        # script_name need not exist, it just need to be initialized
+        dist.script_name = os.path.join(sources, "setup.py")
+        dist.script_args = ["build"]
+        dist.parse_command_line()
+
+        try:
+            dist.run_commands()
+        except DistutilsFileError:
+            self.fail("failed package_data when data dir includes a dir")
+
+    def test_dont_write_bytecode(self, caplog):
+        # makes sure byte_compile is not used
+        dist = self.create_dist()[1]
+        cmd = build_py(dist)
+        cmd.compile = True
+        cmd.optimize = 1
+
+        old_dont_write_bytecode = sys.dont_write_bytecode
+        sys.dont_write_bytecode = True
+        try:
+            cmd.byte_compile([])
+        finally:
+            sys.dont_write_bytecode = old_dont_write_bytecode
+
+        assert 'byte-compiling is disabled' in caplog.records[0].message
+
+    def test_namespace_package_does_not_warn(self, caplog):
+        """
+        Originally distutils implementation did not account for PEP 420
+        and included warns for package directories that did not contain
+        ``__init__.py`` files.
+        After the acceptance of PEP 420, these warnings don't make more sense
+        so we want to ensure there are not displayed to not confuse the users.
+        """
+        # Create a fake project structure with a package namespace:
+        tmp = self.mkdtemp()
+        jaraco.path.build({'ns': {'pkg': {'module.py': ''}}}, tmp)
+        os.chdir(tmp)
+
+        # Configure the package:
+        attrs = {
+            "name": "ns.pkg",
+            "packages": ["ns", "ns.pkg"],
+            "script_name": "setup.py",
+        }
+        dist = Distribution(attrs)
+
+        # Run code paths that would trigger the trap:
+        cmd = dist.get_command_obj("build_py")
+        cmd.finalize_options()
+        modules = cmd.find_all_modules()
+        assert len(modules) == 1
+        module_path = modules[0][-1]
+        assert module_path.replace(os.sep, "/") == "ns/pkg/module.py"
+
+        cmd.run()
+
+        assert not any(
+            "package init file" in msg and "not found" in msg for msg in caplog.messages
+        )

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_clean.py

@@ -0,0 +1,45 @@
+"""Tests for distutils.command.clean."""
+
+import os
+from distutils.command.clean import clean
+from distutils.tests import support
+
+
+class TestClean(support.TempdirManager):
+    def test_simple_run(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = clean(dist)
+
+        # let's add some elements clean should remove
+        dirs = [
+            (d, os.path.join(pkg_dir, d))
+            for d in (
+                'build_temp',
+                'build_lib',
+                'bdist_base',
+                'build_scripts',
+                'build_base',
+            )
+        ]
+
+        for name, path in dirs:
+            os.mkdir(path)
+            setattr(cmd, name, path)
+            if name == 'build_base':
+                continue
+            for f in ('one', 'two', 'three'):
+                self.write_file(os.path.join(path, f))
+
+        # let's run the command
+        cmd.all = 1
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # make sure the files where removed
+        for _name, path in dirs:
+            assert not os.path.exists(path), f'{path} was not removed'
+
+        # let's run the command again (should spit warnings but succeed)
+        cmd.all = 1
+        cmd.ensure_finalized()
+        cmd.run()

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_cmd.py

@@ -0,0 +1,107 @@
+"""Tests for distutils.cmd."""
+
+import os
+from distutils import debug
+from distutils.cmd import Command
+from distutils.dist import Distribution
+from distutils.errors import DistutilsOptionError
+
+import pytest
+
+
+class MyCmd(Command):
+    def initialize_options(self):
+        pass
+
+
+@pytest.fixture
+def cmd(request):
+    return MyCmd(Distribution())
+
+
+class TestCommand:
+    def test_ensure_string_list(self, cmd):
+        cmd.not_string_list = ['one', 2, 'three']
+        cmd.yes_string_list = ['one', 'two', 'three']
+        cmd.not_string_list2 = object()
+        cmd.yes_string_list2 = 'ok'
+        cmd.ensure_string_list('yes_string_list')
+        cmd.ensure_string_list('yes_string_list2')
+
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_string_list('not_string_list')
+
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_string_list('not_string_list2')
+
+        cmd.option1 = 'ok,dok'
+        cmd.ensure_string_list('option1')
+        assert cmd.option1 == ['ok', 'dok']
+
+        cmd.option2 = ['xxx', 'www']
+        cmd.ensure_string_list('option2')
+
+        cmd.option3 = ['ok', 2]
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_string_list('option3')
+
+    def test_make_file(self, cmd):
+        # making sure it raises when infiles is not a string or a list/tuple
+        with pytest.raises(TypeError):
+            cmd.make_file(infiles=True, outfile='', func='func', args=())
+
+        # making sure execute gets called properly
+        def _execute(func, args, exec_msg, level):
+            assert exec_msg == 'generating out from in'
+
+        cmd.force = True
+        cmd.execute = _execute
+        cmd.make_file(infiles='in', outfile='out', func='func', args=())
+
+    def test_dump_options(self, cmd):
+        msgs = []
+
+        def _announce(msg, level):
+            msgs.append(msg)
+
+        cmd.announce = _announce
+        cmd.option1 = 1
+        cmd.option2 = 1
+        cmd.user_options = [('option1', '', ''), ('option2', '', '')]
+        cmd.dump_options()
+
+        wanted = ["command options for 'MyCmd':", '  option1 = 1', '  option2 = 1']
+        assert msgs == wanted
+
+    def test_ensure_string(self, cmd):
+        cmd.option1 = 'ok'
+        cmd.ensure_string('option1')
+
+        cmd.option2 = None
+        cmd.ensure_string('option2', 'xxx')
+        assert hasattr(cmd, 'option2')
+
+        cmd.option3 = 1
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_string('option3')
+
+    def test_ensure_filename(self, cmd):
+        cmd.option1 = __file__
+        cmd.ensure_filename('option1')
+        cmd.option2 = 'xxx'
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_filename('option2')
+
+    def test_ensure_dirname(self, cmd):
+        cmd.option1 = os.path.dirname(__file__) or os.curdir
+        cmd.ensure_dirname('option1')
+        cmd.option2 = 'xxx'
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_dirname('option2')
+
+    def test_debug_print(self, cmd, capsys, monkeypatch):
+        cmd.debug_print('xxx')
+        assert capsys.readouterr().out == ''
+        monkeypatch.setattr(debug, 'DEBUG', True)
+        cmd.debug_print('xxx')
+        assert capsys.readouterr().out == 'xxx\n'

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_config_cmd.py

@@ -0,0 +1,87 @@
+"""Tests for distutils.command.config."""
+
+import os
+import sys
+from distutils._log import log
+from distutils.command.config import config, dump_file
+from distutils.tests import missing_compiler_executable, support
+
+import more_itertools
+import path
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def info_log(request, monkeypatch):
+    self = request.instance
+    self._logs = []
+    monkeypatch.setattr(log, 'info', self._info)
+
+
+@support.combine_markers
+class TestConfig(support.TempdirManager):
+    def _info(self, msg, *args):
+        for line in msg.splitlines():
+            self._logs.append(line)
+
+    def test_dump_file(self):
+        this_file = path.Path(__file__).with_suffix('.py')
+        with this_file.open(encoding='utf-8') as f:
+            numlines = more_itertools.ilen(f)
+
+        dump_file(this_file, 'I am the header')
+        assert len(self._logs) == numlines + 1
+
+    @pytest.mark.skipif('platform.system() == "Windows"')
+    def test_search_cpp(self):
+        cmd = missing_compiler_executable(['preprocessor'])
+        if cmd is not None:
+            self.skipTest(f'The {cmd!r} command is not found')
+        pkg_dir, dist = self.create_dist()
+        cmd = config(dist)
+        cmd._check_compiler()
+        compiler = cmd.compiler
+        if sys.platform[:3] == "aix" and "xlc" in compiler.preprocessor[0].lower():
+            self.skipTest(
+                'xlc: The -E option overrides the -P, -o, and -qsyntaxonly options'
+            )
+
+        # simple pattern searches
+        match = cmd.search_cpp(pattern='xxx', body='/* xxx */')
+        assert match == 0
+
+        match = cmd.search_cpp(pattern='_configtest', body='/* xxx */')
+        assert match == 1
+
+    def test_finalize_options(self):
+        # finalize_options does a bit of transformation
+        # on options
+        pkg_dir, dist = self.create_dist()
+        cmd = config(dist)
+        cmd.include_dirs = f'one{os.pathsep}two'
+        cmd.libraries = 'one'
+        cmd.library_dirs = f'three{os.pathsep}four'
+        cmd.ensure_finalized()
+
+        assert cmd.include_dirs == ['one', 'two']
+        assert cmd.libraries == ['one']
+        assert cmd.library_dirs == ['three', 'four']
+
+    def test_clean(self):
+        # _clean removes files
+        tmp_dir = self.mkdtemp()
+        f1 = os.path.join(tmp_dir, 'one')
+        f2 = os.path.join(tmp_dir, 'two')
+
+        self.write_file(f1, 'xxx')
+        self.write_file(f2, 'xxx')
+
+        for f in (f1, f2):
+            assert os.path.exists(f)
+
+        pkg_dir, dist = self.create_dist()
+        cmd = config(dist)
+        cmd._clean(f1, f2)
+
+        for f in (f1, f2):
+            assert not os.path.exists(f)

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_core.py

@@ -0,0 +1,130 @@
+"""Tests for distutils.core."""
+
+import distutils.core
+import io
+import os
+import sys
+from distutils.dist import Distribution
+
+import pytest
+
+# setup script that uses __file__
+setup_using___file__ = """\
+
+__file__
+
+from distutils.core import setup
+setup()
+"""
+
+setup_prints_cwd = """\
+
+import os
+print(os.getcwd())
+
+from distutils.core import setup
+setup()
+"""
+
+setup_does_nothing = """\
+from distutils.core import setup
+setup()
+"""
+
+
+setup_defines_subclass = """\
+from distutils.core import setup
+from distutils.command.install import install as _install
+
+class install(_install):
+    sub_commands = _install.sub_commands + ['cmd']
+
+setup(cmdclass={'install': install})
+"""
+
+setup_within_if_main = """\
+from distutils.core import setup
+
+def main():
+    return setup(name="setup_within_if_main")
+
+if __name__ == "__main__":
+    main()
+"""
+
+
+@pytest.fixture(autouse=True)
+def save_stdout(monkeypatch):
+    monkeypatch.setattr(sys, 'stdout', sys.stdout)
+
+
+@pytest.fixture
+def temp_file(tmp_path):
+    return tmp_path / 'file'
+
+
+@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
+class TestCore:
+    def test_run_setup_provides_file(self, temp_file):
+        # Make sure the script can use __file__; if that's missing, the test
+        # setup.py script will raise NameError.
+        temp_file.write_text(setup_using___file__, encoding='utf-8')
+        distutils.core.run_setup(temp_file)
+
+    def test_run_setup_preserves_sys_argv(self, temp_file):
+        # Make sure run_setup does not clobber sys.argv
+        argv_copy = sys.argv.copy()
+        temp_file.write_text(setup_does_nothing, encoding='utf-8')
+        distutils.core.run_setup(temp_file)
+        assert sys.argv == argv_copy
+
+    def test_run_setup_defines_subclass(self, temp_file):
+        # Make sure the script can use __file__; if that's missing, the test
+        # setup.py script will raise NameError.
+        temp_file.write_text(setup_defines_subclass, encoding='utf-8')
+        dist = distutils.core.run_setup(temp_file)
+        install = dist.get_command_obj('install')
+        assert 'cmd' in install.sub_commands
+
+    def test_run_setup_uses_current_dir(self, tmp_path):
+        """
+        Test that the setup script is run with the current directory
+        as its own current directory.
+        """
+        sys.stdout = io.StringIO()
+        cwd = os.getcwd()
+
+        # Create a directory and write the setup.py file there:
+        setup_py = tmp_path / 'setup.py'
+        setup_py.write_text(setup_prints_cwd, encoding='utf-8')
+        distutils.core.run_setup(setup_py)
+
+        output = sys.stdout.getvalue()
+        if output.endswith("\n"):
+            output = output[:-1]
+        assert cwd == output
+
+    def test_run_setup_within_if_main(self, temp_file):
+        temp_file.write_text(setup_within_if_main, encoding='utf-8')
+        dist = distutils.core.run_setup(temp_file, stop_after="config")
+        assert isinstance(dist, Distribution)
+        assert dist.get_name() == "setup_within_if_main"
+
+    def test_run_commands(self, temp_file):
+        sys.argv = ['setup.py', 'build']
+        temp_file.write_text(setup_within_if_main, encoding='utf-8')
+        dist = distutils.core.run_setup(temp_file, stop_after="commandline")
+        assert 'build' not in dist.have_run
+        distutils.core.run_commands(dist)
+        assert 'build' in dist.have_run
+
+    def test_debug_mode(self, capsys, monkeypatch):
+        # this covers the code called when DEBUG is set
+        sys.argv = ['setup.py', '--name']
+        distutils.core.setup(name='bar')
+        assert capsys.readouterr().out == 'bar\n'
+        monkeypatch.setattr(distutils.core, 'DEBUG', True)
+        distutils.core.setup(name='bar')
+        wanted = "options (after parsing config files):\n"
+        assert capsys.readouterr().out.startswith(wanted)

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_dist.py

@@ -0,0 +1,552 @@
+"""Tests for distutils.dist."""
+
+import email
+import email.generator
+import email.policy
+import functools
+import io
+import os
+import sys
+import textwrap
+import unittest.mock as mock
+import warnings
+from distutils.cmd import Command
+from distutils.dist import Distribution, fix_help_options
+from distutils.tests import support
+from typing import ClassVar
+
+import jaraco.path
+import pytest
+
+pydistutils_cfg = '.' * (os.name == 'posix') + 'pydistutils.cfg'
+
+
+class test_dist(Command):
+    """Sample distutils extension command."""
+
+    user_options: ClassVar[list[tuple[str, str, str]]] = [
+        ("sample-option=", "S", "help text"),
+    ]
+
+    def initialize_options(self):
+        self.sample_option = None
+
+
+class TestDistribution(Distribution):
+    """Distribution subclasses that avoids the default search for
+    configuration files.
+
+    The ._config_files attribute must be set before
+    .parse_config_files() is called.
+    """
+
+    def find_config_files(self):
+        return self._config_files
+
+
+@pytest.fixture
+def clear_argv():
+    del sys.argv[1:]
+
+
+@support.combine_markers
+@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
+class TestDistributionBehavior(support.TempdirManager):
+    def create_distribution(self, configfiles=()):
+        d = TestDistribution()
+        d._config_files = configfiles
+        d.parse_config_files()
+        d.parse_command_line()
+        return d
+
+    def test_command_packages_unspecified(self, clear_argv):
+        sys.argv.append("build")
+        d = self.create_distribution()
+        assert d.get_command_packages() == ["distutils.command"]
+
+    def test_command_packages_cmdline(self, clear_argv):
+        from distutils.tests.test_dist import test_dist
+
+        sys.argv.extend([
+            "--command-packages",
+            "foo.bar,distutils.tests",
+            "test_dist",
+            "-Ssometext",
+        ])
+        d = self.create_distribution()
+        # let's actually try to load our test command:
+        assert d.get_command_packages() == [
+            "distutils.command",
+            "foo.bar",
+            "distutils.tests",
+        ]
+        cmd = d.get_command_obj("test_dist")
+        assert isinstance(cmd, test_dist)
+        assert cmd.sample_option == "sometext"
+
+    @pytest.mark.skipif(
+        'distutils' not in Distribution.parse_config_files.__module__,
+        reason='Cannot test when virtualenv has monkey-patched Distribution',
+    )
+    def test_venv_install_options(self, tmp_path, clear_argv):
+        sys.argv.append("install")
+        file = str(tmp_path / 'file')
+
+        fakepath = '/somedir'
+
+        jaraco.path.build({
+            file: f"""
+                    [install]
+                    install-base = {fakepath}
+                    install-platbase = {fakepath}
+                    install-lib = {fakepath}
+                    install-platlib = {fakepath}
+                    install-purelib = {fakepath}
+                    install-headers = {fakepath}
+                    install-scripts = {fakepath}
+                    install-data = {fakepath}
+                    prefix = {fakepath}
+                    exec-prefix = {fakepath}
+                    home = {fakepath}
+                    user = {fakepath}
+                    root = {fakepath}
+                    """,
+        })
+
+        # Base case: Not in a Virtual Environment
+        with mock.patch.multiple(sys, prefix='/a', base_prefix='/a'):
+            d = self.create_distribution([file])
+
+        option_tuple = (file, fakepath)
+
+        result_dict = {
+            'install_base': option_tuple,
+            'install_platbase': option_tuple,
+            'install_lib': option_tuple,
+            'install_platlib': option_tuple,
+            'install_purelib': option_tuple,
+            'install_headers': option_tuple,
+            'install_scripts': option_tuple,
+            'install_data': option_tuple,
+            'prefix': option_tuple,
+            'exec_prefix': option_tuple,
+            'home': option_tuple,
+            'user': option_tuple,
+            'root': option_tuple,
+        }
+
+        assert sorted(d.command_options.get('install').keys()) == sorted(
+            result_dict.keys()
+        )
+
+        for key, value in d.command_options.get('install').items():
+            assert value == result_dict[key]
+
+        # Test case: In a Virtual Environment
+        with mock.patch.multiple(sys, prefix='/a', base_prefix='/b'):
+            d = self.create_distribution([file])
+
+        for key in result_dict.keys():
+            assert key not in d.command_options.get('install', {})
+
+    def test_command_packages_configfile(self, tmp_path, clear_argv):
+        sys.argv.append("build")
+        file = str(tmp_path / "file")
+        jaraco.path.build({
+            file: """
+                    [global]
+                    command_packages = foo.bar, splat
+                    """,
+        })
+
+        d = self.create_distribution([file])
+        assert d.get_command_packages() == ["distutils.command", "foo.bar", "splat"]
+
+        # ensure command line overrides config:
+        sys.argv[1:] = ["--command-packages", "spork", "build"]
+        d = self.create_distribution([file])
+        assert d.get_command_packages() == ["distutils.command", "spork"]
+
+        # Setting --command-packages to '' should cause the default to
+        # be used even if a config file specified something else:
+        sys.argv[1:] = ["--command-packages", "", "build"]
+        d = self.create_distribution([file])
+        assert d.get_command_packages() == ["distutils.command"]
+
+    def test_empty_options(self, request):
+        # an empty options dictionary should not stay in the
+        # list of attributes
+
+        # catching warnings
+        warns = []
+
+        def _warn(msg):
+            warns.append(msg)
+
+        request.addfinalizer(
+            functools.partial(setattr, warnings, 'warn', warnings.warn)
+        )
+        warnings.warn = _warn
+        dist = Distribution(
+            attrs={
+                'author': 'xxx',
+                'name': 'xxx',
+                'version': 'xxx',
+                'url': 'xxxx',
+                'options': {},
+            }
+        )
+
+        assert len(warns) == 0
+        assert 'options' not in dir(dist)
+
+    def test_finalize_options(self):
+        attrs = {'keywords': 'one,two', 'platforms': 'one,two'}
+
+        dist = Distribution(attrs=attrs)
+        dist.finalize_options()
+
+        # finalize_option splits platforms and keywords
+        assert dist.metadata.platforms == ['one', 'two']
+        assert dist.metadata.keywords == ['one', 'two']
+
+        attrs = {'keywords': 'foo bar', 'platforms': 'foo bar'}
+        dist = Distribution(attrs=attrs)
+        dist.finalize_options()
+        assert dist.metadata.platforms == ['foo bar']
+        assert dist.metadata.keywords == ['foo bar']
+
+    def test_get_command_packages(self):
+        dist = Distribution()
+        assert dist.command_packages is None
+        cmds = dist.get_command_packages()
+        assert cmds == ['distutils.command']
+        assert dist.command_packages == ['distutils.command']
+
+        dist.command_packages = 'one,two'
+        cmds = dist.get_command_packages()
+        assert cmds == ['distutils.command', 'one', 'two']
+
+    def test_announce(self):
+        # make sure the level is known
+        dist = Distribution()
+        with pytest.raises(TypeError):
+            dist.announce('ok', level='ok2')
+
+    def test_find_config_files_disable(self, temp_home):
+        # Ticket #1180: Allow user to disable their home config file.
+        jaraco.path.build({pydistutils_cfg: '[distutils]\n'}, temp_home)
+
+        d = Distribution()
+        all_files = d.find_config_files()
+
+        d = Distribution(attrs={'script_args': ['--no-user-cfg']})
+        files = d.find_config_files()
+
+        # make sure --no-user-cfg disables the user cfg file
+        assert len(all_files) - 1 == len(files)
+
+    def test_script_args_list_coercion(self):
+        d = Distribution(attrs={'script_args': ('build', '--no-user-cfg')})
+
+        # make sure script_args is a list even if it started as a different iterable
+        assert d.script_args == ['build', '--no-user-cfg']
+
+    @pytest.mark.skipif(
+        'platform.system() == "Windows"',
+        reason='Windows does not honor chmod 000',
+    )
+    def test_find_config_files_permission_error(self, fake_home):
+        """
+        Finding config files should not fail when directory is inaccessible.
+        """
+        fake_home.joinpath(pydistutils_cfg).write_text('', encoding='utf-8')
+        fake_home.chmod(0o000)
+        Distribution().find_config_files()
+
+
+@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
+class TestMetadata(support.TempdirManager):
+    def format_metadata(self, dist):
+        sio = io.StringIO()
+        dist.metadata.write_pkg_file(sio)
+        return sio.getvalue()
+
+    def test_simple_metadata(self):
+        attrs = {"name": "package", "version": "1.0"}
+        dist = Distribution(attrs)
+        meta = self.format_metadata(dist)
+        assert "Metadata-Version: 1.0" in meta
+        assert "provides:" not in meta.lower()
+        assert "requires:" not in meta.lower()
+        assert "obsoletes:" not in meta.lower()
+
+    def test_provides(self):
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "provides": ["package", "package.sub"],
+        }
+        dist = Distribution(attrs)
+        assert dist.metadata.get_provides() == ["package", "package.sub"]
+        assert dist.get_provides() == ["package", "package.sub"]
+        meta = self.format_metadata(dist)
+        assert "Metadata-Version: 1.1" in meta
+        assert "requires:" not in meta.lower()
+        assert "obsoletes:" not in meta.lower()
+
+    def test_provides_illegal(self):
+        with pytest.raises(ValueError):
+            Distribution(
+                {"name": "package", "version": "1.0", "provides": ["my.pkg (splat)"]},
+            )
+
+    def test_requires(self):
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "requires": ["other", "another (==1.0)"],
+        }
+        dist = Distribution(attrs)
+        assert dist.metadata.get_requires() == ["other", "another (==1.0)"]
+        assert dist.get_requires() == ["other", "another (==1.0)"]
+        meta = self.format_metadata(dist)
+        assert "Metadata-Version: 1.1" in meta
+        assert "provides:" not in meta.lower()
+        assert "Requires: other" in meta
+        assert "Requires: another (==1.0)" in meta
+        assert "obsoletes:" not in meta.lower()
+
+    def test_requires_illegal(self):
+        with pytest.raises(ValueError):
+            Distribution(
+                {"name": "package", "version": "1.0", "requires": ["my.pkg (splat)"]},
+            )
+
+    def test_requires_to_list(self):
+        attrs = {"name": "package", "requires": iter(["other"])}
+        dist = Distribution(attrs)
+        assert isinstance(dist.metadata.requires, list)
+
+    def test_obsoletes(self):
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "obsoletes": ["other", "another (<1.0)"],
+        }
+        dist = Distribution(attrs)
+        assert dist.metadata.get_obsoletes() == ["other", "another (<1.0)"]
+        assert dist.get_obsoletes() == ["other", "another (<1.0)"]
+        meta = self.format_metadata(dist)
+        assert "Metadata-Version: 1.1" in meta
+        assert "provides:" not in meta.lower()
+        assert "requires:" not in meta.lower()
+        assert "Obsoletes: other" in meta
+        assert "Obsoletes: another (<1.0)" in meta
+
+    def test_obsoletes_illegal(self):
+        with pytest.raises(ValueError):
+            Distribution(
+                {"name": "package", "version": "1.0", "obsoletes": ["my.pkg (splat)"]},
+            )
+
+    def test_obsoletes_to_list(self):
+        attrs = {"name": "package", "obsoletes": iter(["other"])}
+        dist = Distribution(attrs)
+        assert isinstance(dist.metadata.obsoletes, list)
+
+    def test_classifier(self):
+        attrs = {
+            'name': 'Boa',
+            'version': '3.0',
+            'classifiers': ['Programming Language :: Python :: 3'],
+        }
+        dist = Distribution(attrs)
+        assert dist.get_classifiers() == ['Programming Language :: Python :: 3']
+        meta = self.format_metadata(dist)
+        assert 'Metadata-Version: 1.1' in meta
+
+    def test_classifier_invalid_type(self, caplog):
+        attrs = {
+            'name': 'Boa',
+            'version': '3.0',
+            'classifiers': ('Programming Language :: Python :: 3',),
+        }
+        d = Distribution(attrs)
+        # should have warning about passing a non-list
+        assert 'should be a list' in caplog.messages[0]
+        # should be converted to a list
+        assert isinstance(d.metadata.classifiers, list)
+        assert d.metadata.classifiers == list(attrs['classifiers'])
+
+    def test_keywords(self):
+        attrs = {
+            'name': 'Monty',
+            'version': '1.0',
+            'keywords': ['spam', 'eggs', 'life of brian'],
+        }
+        dist = Distribution(attrs)
+        assert dist.get_keywords() == ['spam', 'eggs', 'life of brian']
+
+    def test_keywords_invalid_type(self, caplog):
+        attrs = {
+            'name': 'Monty',
+            'version': '1.0',
+            'keywords': ('spam', 'eggs', 'life of brian'),
+        }
+        d = Distribution(attrs)
+        # should have warning about passing a non-list
+        assert 'should be a list' in caplog.messages[0]
+        # should be converted to a list
+        assert isinstance(d.metadata.keywords, list)
+        assert d.metadata.keywords == list(attrs['keywords'])
+
+    def test_platforms(self):
+        attrs = {
+            'name': 'Monty',
+            'version': '1.0',
+            'platforms': ['GNU/Linux', 'Some Evil Platform'],
+        }
+        dist = Distribution(attrs)
+        assert dist.get_platforms() == ['GNU/Linux', 'Some Evil Platform']
+
+    def test_platforms_invalid_types(self, caplog):
+        attrs = {
+            'name': 'Monty',
+            'version': '1.0',
+            'platforms': ('GNU/Linux', 'Some Evil Platform'),
+        }
+        d = Distribution(attrs)
+        # should have warning about passing a non-list
+        assert 'should be a list' in caplog.messages[0]
+        # should be converted to a list
+        assert isinstance(d.metadata.platforms, list)
+        assert d.metadata.platforms == list(attrs['platforms'])
+
+    def test_download_url(self):
+        attrs = {
+            'name': 'Boa',
+            'version': '3.0',
+            'download_url': 'http://example.org/boa',
+        }
+        dist = Distribution(attrs)
+        meta = self.format_metadata(dist)
+        assert 'Metadata-Version: 1.1' in meta
+
+    def test_long_description(self):
+        long_desc = textwrap.dedent(
+            """\
+        example::
+              We start here
+            and continue here
+          and end here."""
+        )
+        attrs = {"name": "package", "version": "1.0", "long_description": long_desc}
+
+        dist = Distribution(attrs)
+        meta = self.format_metadata(dist)
+        meta = meta.replace('\n' + 8 * ' ', '\n')
+        assert long_desc in meta
+
+    def test_custom_pydistutils(self, temp_home):
+        """
+        pydistutils.cfg is found
+        """
+        jaraco.path.build({pydistutils_cfg: ''}, temp_home)
+        config_path = temp_home / pydistutils_cfg
+
+        assert str(config_path) in Distribution().find_config_files()
+
+    def test_extra_pydistutils(self, monkeypatch, tmp_path):
+        jaraco.path.build({'overrides.cfg': ''}, tmp_path)
+        filename = tmp_path / 'overrides.cfg'
+        monkeypatch.setenv('DIST_EXTRA_CONFIG', str(filename))
+        assert str(filename) in Distribution().find_config_files()
+
+    def test_fix_help_options(self):
+        help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
+        fancy_options = fix_help_options(help_tuples)
+        assert fancy_options[0] == ('a', 'b', 'c')
+        assert fancy_options[1] == (1, 2, 3)
+
+    def test_show_help(self, request, capsys):
+        # smoke test, just makes sure some help is displayed
+        dist = Distribution()
+        sys.argv = []
+        dist.help = True
+        dist.script_name = 'setup.py'
+        dist.parse_command_line()
+
+        output = [
+            line for line in capsys.readouterr().out.split('\n') if line.strip() != ''
+        ]
+        assert output
+
+    def test_read_metadata(self):
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "long_description": "desc",
+            "description": "xxx",
+            "download_url": "http://example.com",
+            "keywords": ['one', 'two'],
+            "requires": ['foo'],
+        }
+
+        dist = Distribution(attrs)
+        metadata = dist.metadata
+
+        # write it then reloads it
+        PKG_INFO = io.StringIO()
+        metadata.write_pkg_file(PKG_INFO)
+        PKG_INFO.seek(0)
+        metadata.read_pkg_file(PKG_INFO)
+
+        assert metadata.name == "package"
+        assert metadata.version == "1.0"
+        assert metadata.description == "xxx"
+        assert metadata.download_url == 'http://example.com'
+        assert metadata.keywords == ['one', 'two']
+        assert metadata.platforms is None
+        assert metadata.obsoletes is None
+        assert metadata.requires == ['foo']
+
+    def test_round_trip_through_email_generator(self):
+        """
+        In pypa/setuptools#4033, it was shown that once PKG-INFO is
+        re-generated using ``email.generator.Generator``, some control
+        characters might cause problems.
+        """
+        # Given a PKG-INFO file ...
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "long_description": "hello\x0b\nworld\n",
+        }
+        dist = Distribution(attrs)
+        metadata = dist.metadata
+
+        with io.StringIO() as buffer:
+            metadata.write_pkg_file(buffer)
+            msg = buffer.getvalue()
+
+        # ... when it is read and re-written using stdlib's email library,
+        orig = email.message_from_string(msg)
+        policy = email.policy.EmailPolicy(
+            utf8=True,
+            mangle_from_=False,
+            max_line_length=0,
+        )
+        with io.StringIO() as buffer:
+            email.generator.Generator(buffer, policy=policy).flatten(orig)
+
+            buffer.seek(0)
+            regen = email.message_from_file(buffer)
+
+        # ... then it should be the same as the original
+        # (except for the specific line break characters)
+        orig_desc = set(orig["Description"].splitlines())
+        regen_desc = set(regen["Description"].splitlines())
+        assert regen_desc == orig_desc

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_extension.py

@@ -0,0 +1,117 @@
+"""Tests for distutils.extension."""
+
+import os
+import pathlib
+import warnings
+from distutils.extension import Extension, read_setup_file
+
+import pytest
+from test.support.warnings_helper import check_warnings
+
+
+class TestExtension:
+    def test_read_setup_file(self):
+        # trying to read a Setup file
+        # (sample extracted from the PyGame project)
+        setup = os.path.join(os.path.dirname(__file__), 'Setup.sample')
+
+        exts = read_setup_file(setup)
+        names = [ext.name for ext in exts]
+        names.sort()
+
+        # here are the extensions read_setup_file should have created
+        # out of the file
+        wanted = [
+            '_arraysurfarray',
+            '_camera',
+            '_numericsndarray',
+            '_numericsurfarray',
+            'base',
+            'bufferproxy',
+            'cdrom',
+            'color',
+            'constants',
+            'display',
+            'draw',
+            'event',
+            'fastevent',
+            'font',
+            'gfxdraw',
+            'image',
+            'imageext',
+            'joystick',
+            'key',
+            'mask',
+            'mixer',
+            'mixer_music',
+            'mouse',
+            'movie',
+            'overlay',
+            'pixelarray',
+            'pypm',
+            'rect',
+            'rwobject',
+            'scrap',
+            'surface',
+            'surflock',
+            'time',
+            'transform',
+        ]
+
+        assert names == wanted
+
+    def test_extension_init(self):
+        # the first argument, which is the name, must be a string
+        with pytest.raises(TypeError):
+            Extension(1, [])
+        ext = Extension('name', [])
+        assert ext.name == 'name'
+
+        # the second argument, which is the list of files, must
+        # be an iterable of strings or PathLike objects, and not a string
+        with pytest.raises(TypeError):
+            Extension('name', 'file')
+        with pytest.raises(TypeError):
+            Extension('name', ['file', 1])
+        ext = Extension('name', ['file1', 'file2'])
+        assert ext.sources == ['file1', 'file2']
+        ext = Extension('name', [pathlib.Path('file1'), pathlib.Path('file2')])
+        assert ext.sources == ['file1', 'file2']
+
+        # any non-string iterable of strings or PathLike objects should work
+        ext = Extension('name', ('file1', 'file2'))  # tuple
+        assert ext.sources == ['file1', 'file2']
+        ext = Extension('name', {'file1', 'file2'})  # set
+        assert sorted(ext.sources) == ['file1', 'file2']
+        ext = Extension('name', iter(['file1', 'file2']))  # iterator
+        assert ext.sources == ['file1', 'file2']
+        ext = Extension('name', [pathlib.Path('file1'), 'file2'])  # mixed types
+        assert ext.sources == ['file1', 'file2']
+
+        # others arguments have defaults
+        for attr in (
+            'include_dirs',
+            'define_macros',
+            'undef_macros',
+            'library_dirs',
+            'libraries',
+            'runtime_library_dirs',
+            'extra_objects',
+            'extra_compile_args',
+            'extra_link_args',
+            'export_symbols',
+            'swig_opts',
+            'depends',
+        ):
+            assert getattr(ext, attr) == []
+
+        assert ext.language is None
+        assert ext.optional is None
+
+        # if there are unknown keyword options, warn about them
+        with check_warnings() as w:
+            warnings.simplefilter('always')
+            ext = Extension('name', ['file1', 'file2'], chic=True)
+
+        assert len(w.warnings) == 1
+        assert str(w.warnings[0].message) == "Unknown Extension options: 'chic'"

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_file_util.py

@@ -0,0 +1,95 @@
+"""Tests for distutils.file_util."""
+
+import errno
+import os
+import unittest.mock as mock
+from distutils.errors import DistutilsFileError
+from distutils.file_util import copy_file, move_file
+
+import jaraco.path
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def stuff(request, tmp_path):
+    self = request.instance
+    self.source = tmp_path / 'f1'
+    self.target = tmp_path / 'f2'
+    self.target_dir = tmp_path / 'd1'
+
+
+class TestFileUtil:
+    def test_move_file_verbosity(self, caplog):
+        jaraco.path.build({self.source: 'some content'})
+
+        move_file(self.source, self.target, verbose=False)
+        assert not caplog.messages
+
+        # back to original state
+        move_file(self.target, self.source, verbose=False)
+
+        move_file(self.source, self.target, verbose=True)
+        wanted = [f'moving {self.source} -> {self.target}']
+        assert caplog.messages == wanted
+
+        # back to original state
+        move_file(self.target, self.source, verbose=False)
+
+        caplog.clear()
+        # now the target is a dir
+        os.mkdir(self.target_dir)
+        move_file(self.source, self.target_dir, verbose=True)
+        wanted = [f'moving {self.source} -> {self.target_dir}']
+        assert caplog.messages == wanted
+
+    def test_move_file_exception_unpacking_rename(self):
+        # see issue 22182
+        with (
+            mock.patch("os.rename", side_effect=OSError("wrong", 1)),
+            pytest.raises(DistutilsFileError),
+        ):
+            jaraco.path.build({self.source: 'spam eggs'})
+            move_file(self.source, self.target, verbose=False)
+
+    def test_move_file_exception_unpacking_unlink(self):
+        # see issue 22182
+        with (
+            mock.patch("os.rename", side_effect=OSError(errno.EXDEV, "wrong")),
+            mock.patch("os.unlink", side_effect=OSError("wrong", 1)),
+            pytest.raises(DistutilsFileError),
+        ):
+            jaraco.path.build({self.source: 'spam eggs'})
+            move_file(self.source, self.target, verbose=False)
+
+    def test_copy_file_hard_link(self):
+        jaraco.path.build({self.source: 'some content'})
+        # Check first that copy_file() will not fall back on copying the file
+        # instead of creating the hard link.
+        try:
+            os.link(self.source, self.target)
+        except OSError as e:
+            self.skipTest(f'os.link: {e}')
+        else:
+            self.target.unlink()
+        st = os.stat(self.source)
+        copy_file(self.source, self.target, link='hard')
+        st2 = os.stat(self.source)
+        st3 = os.stat(self.target)
+        assert os.path.samestat(st, st2), (st, st2)
+        assert os.path.samestat(st2, st3), (st2, st3)
+        assert self.source.read_text(encoding='utf-8') == 'some content'
+
+    def test_copy_file_hard_link_failure(self):
+        # If hard linking fails, copy_file() falls back on copying file
+        # (some special filesystems don't support hard linking even under
+        #  Unix, see issue #8876).
+        jaraco.path.build({self.source: 'some content'})
+        st = os.stat(self.source)
+        with mock.patch("os.link", side_effect=OSError(0, "linking unsupported")):
+            copy_file(self.source, self.target, link='hard')
+        st2 = os.stat(self.source)
+        st3 = os.stat(self.target)
+        assert os.path.samestat(st, st2), (st, st2)
+        assert not os.path.samestat(st2, st3), (st2, st3)
+        for fn in (self.source, self.target):
+            assert fn.read_text(encoding='utf-8') == 'some content'

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_install_data.py

@@ -0,0 +1,74 @@
+"""Tests for distutils.command.install_data."""
+
+import os
+import pathlib
+from distutils.command.install_data import install_data
+from distutils.tests import support
+
+import pytest
+
+
+@pytest.mark.usefixtures('save_env')
+class TestInstallData(
+    support.TempdirManager,
+):
+    def test_simple_run(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = install_data(dist)
+        cmd.install_dir = inst = os.path.join(pkg_dir, 'inst')
+
+        # data_files can contain
+        #  - simple files
+        #  - a Path object
+        #  - a tuple with a path, and a list of file
+        one = os.path.join(pkg_dir, 'one')
+        self.write_file(one, 'xxx')
+        inst2 = os.path.join(pkg_dir, 'inst2')
+        two = os.path.join(pkg_dir, 'two')
+        self.write_file(two, 'xxx')
+        three = pathlib.Path(pkg_dir) / 'three'
+        self.write_file(three, 'xxx')
+
+        cmd.data_files = [one, (inst2, [two]), three]
+        assert cmd.get_inputs() == [one, (inst2, [two]), three]
+
+        # let's run the command
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # let's check the result
+        assert len(cmd.get_outputs()) == 3
+        rthree = os.path.split(one)[-1]
+        assert os.path.exists(os.path.join(inst, rthree))
+        rtwo = os.path.split(two)[-1]
+        assert os.path.exists(os.path.join(inst2, rtwo))
+        rone = os.path.split(one)[-1]
+        assert os.path.exists(os.path.join(inst, rone))
+        cmd.outfiles = []
+
+        # let's try with warn_dir one
+        cmd.warn_dir = True
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # let's check the result
+        assert len(cmd.get_outputs()) == 3
+        assert os.path.exists(os.path.join(inst, rthree))
+        assert os.path.exists(os.path.join(inst2, rtwo))
+        assert os.path.exists(os.path.join(inst, rone))
+        cmd.outfiles = []
+
+        # now using root and empty dir
+        cmd.root = os.path.join(pkg_dir, 'root')
+        inst5 = os.path.join(pkg_dir, 'inst5')
+        four = os.path.join(cmd.install_dir, 'four')
+        self.write_file(four, 'xx')
+        cmd.data_files = [one, (inst2, [two]), three, ('inst5', [four]), (inst5, [])]
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # let's check the result
+        assert len(cmd.get_outputs()) == 5
+        assert os.path.exists(os.path.join(inst, rthree))
+        assert os.path.exists(os.path.join(inst2, rtwo))
+        assert os.path.exists(os.path.join(inst, rone))

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_log.py

@@ -0,0 +1,12 @@
+"""Tests for distutils.log"""
+
+import logging
+from distutils._log import log
+
+
+class TestLog:
+    def test_non_ascii(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        log.debug('Dεbug\tMėssãge')
+        log.fatal('Fαtal\tÈrrōr')
+        assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr']

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_modified.py

@@ -0,0 +1,126 @@
+"""Tests for distutils._modified."""
+
+import os
+import types
+from distutils._modified import newer, newer_group, newer_pairwise, newer_pairwise_group
+from distutils.errors import DistutilsFileError
+from distutils.tests import support
+
+import pytest
+
+
+class TestDepUtil(support.TempdirManager):
+    def test_newer(self):
+        tmpdir = self.mkdtemp()
+        new_file = os.path.join(tmpdir, 'new')
+        old_file = os.path.abspath(__file__)
+
+        # Raise DistutilsFileError if 'new_file' does not exist.
+        with pytest.raises(DistutilsFileError):
+            newer(new_file, old_file)
+
+        # Return true if 'new_file' exists and is more recently modified than
+        # 'old_file', or if 'new_file' exists and 'old_file' doesn't.
+        self.write_file(new_file)
+        assert newer(new_file, 'I_dont_exist')
+        assert newer(new_file, old_file)
+
+        # Return false if both exist and 'old_file' is the same age or younger
+        # than 'new_file'.
+        assert not newer(old_file, new_file)
+
+    def _setup_1234(self):
+        tmpdir = self.mkdtemp()
+        sources = os.path.join(tmpdir, 'sources')
+        targets = os.path.join(tmpdir, 'targets')
+        os.mkdir(sources)
+        os.mkdir(targets)
+        one = os.path.join(sources, 'one')
+        two = os.path.join(sources, 'two')
+        three = os.path.abspath(__file__)  # I am the old file
+        four = os.path.join(targets, 'four')
+        self.write_file(one)
+        self.write_file(two)
+        self.write_file(four)
+        return one, two, three, four
+
+    def test_newer_pairwise(self):
+        one, two, three, four = self._setup_1234()
+
+        assert newer_pairwise([one, two], [three, four]) == ([one], [three])
+
+    def test_newer_pairwise_mismatch(self):
+        one, two, three, four = self._setup_1234()
+
+        with pytest.raises(ValueError):
+            newer_pairwise([one], [three, four])
+
+        with pytest.raises(ValueError):
+            newer_pairwise([one, two], [three])
+
+    def test_newer_pairwise_empty(self):
+        assert newer_pairwise([], []) == ([], [])
+
+    def test_newer_pairwise_fresh(self):
+        one, two, three, four = self._setup_1234()
+
+        assert newer_pairwise([one, three], [two, four]) == ([], [])
+
+    def test_newer_group(self):
+        tmpdir = self.mkdtemp()
+        sources = os.path.join(tmpdir, 'sources')
+        os.mkdir(sources)
+        one = os.path.join(sources, 'one')
+        two = os.path.join(sources, 'two')
+        three = os.path.join(sources, 'three')
+        old_file = os.path.abspath(__file__)
+
+        # return true if 'old_file' is out-of-date with respect to any file
+        # listed in 'sources'.
+        self.write_file(one)
+        self.write_file(two)
+        self.write_file(three)
+        assert newer_group([one, two, three], old_file)
+        assert not newer_group([one, two, old_file], three)
+
+        # missing handling
+        os.remove(one)
+        with pytest.raises(OSError):
+            newer_group([one, two, old_file], three)
+
+        assert not newer_group([one, two, old_file], three, missing='ignore')
+
+        assert newer_group([one, two, old_file], three, missing='newer')
+
+
+@pytest.fixture
+def groups_target(tmp_path):
+    """
+    Set up some older sources, a target, and newer sources.
+
+    Returns a simple namespace with these values.
+    """
+    filenames = ['older.c', 'older.h', 'target.o', 'newer.c', 'newer.h']
+    paths = [tmp_path / name for name in filenames]
+
+    for mtime, path in enumerate(paths):
+        path.write_text('', encoding='utf-8')
+
+        # make sure modification times are sequential
+        os.utime(path, (mtime, mtime))
+
+    return types.SimpleNamespace(older=paths[:2], target=paths[2], newer=paths[3:])
+
+
+def test_newer_pairwise_group(groups_target):
+    older = newer_pairwise_group([groups_target.older], [groups_target.target])
+    newer = newer_pairwise_group([groups_target.newer], [groups_target.target])
+    assert older == ([], [])
+    assert newer == ([groups_target.newer], [groups_target.target])
+
+
+def test_newer_group_no_sources_no_target(tmp_path):
+    """
+    Consider no sources and no target "newer".
+    """
+    assert newer_group([], str(tmp_path / 'does-not-exist'))

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_spawn.py

@@ -0,0 +1,141 @@
+"""Tests for distutils.spawn."""
+
+import os
+import stat
+import sys
+import unittest.mock as mock
+from distutils.errors import DistutilsExecError
+from distutils.spawn import find_executable, spawn
+from distutils.tests import support
+
+import path
+import pytest
+from test.support import unix_shell
+
+from .compat import py39 as os_helper
+
+
+class TestSpawn(support.TempdirManager):
+    @pytest.mark.skipif("os.name not in ('nt', 'posix')")
+    def test_spawn(self):
+        tmpdir = self.mkdtemp()
+
+        # creating something executable
+        # through the shell that returns 1
+        if sys.platform != 'win32':
+            exe = os.path.join(tmpdir, 'foo.sh')
+            self.write_file(exe, f'#!{unix_shell}\nexit 1')
+        else:
+            exe = os.path.join(tmpdir, 'foo.bat')
+            self.write_file(exe, 'exit 1')
+
+        os.chmod(exe, 0o777)
+        with pytest.raises(DistutilsExecError):
+            spawn([exe])
+
+        # now something that works
+        if sys.platform != 'win32':
+            exe = os.path.join(tmpdir, 'foo.sh')
+            self.write_file(exe, f'#!{unix_shell}\nexit 0')
+        else:
+            exe = os.path.join(tmpdir, 'foo.bat')
+            self.write_file(exe, 'exit 0')
+
+        os.chmod(exe, 0o777)
+        spawn([exe])  # should work without any error
+
+    def test_find_executable(self, tmp_path):
+        program_path = self._make_executable(tmp_path, '.exe')
+        program = program_path.name
+        program_noeext = program_path.with_suffix('').name
+        filename = str(program_path)
+        tmp_dir = path.Path(tmp_path)
+
+        # test path parameter
+        rv = find_executable(program, path=tmp_dir)
+        assert rv == filename
+
+        if sys.platform == 'win32':
+            # test without ".exe" extension
+            rv = find_executable(program_noeext, path=tmp_dir)
+            assert rv == filename
+
+        # test find in the current directory
+        with tmp_dir:
+            rv = find_executable(program)
+            assert rv == program
+
+        # test non-existent program
+        dont_exist_program = "dontexist_" + program
+        rv = find_executable(dont_exist_program, path=tmp_dir)
+        assert rv is None
+
+        # PATH='': no match, except in the current directory
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATH'] = ''
+            with (
+                mock.patch(
+                    'distutils.spawn.os.confstr', return_value=tmp_dir, create=True
+                ),
+                mock.patch('distutils.spawn.os.defpath', tmp_dir),
+            ):
+                rv = find_executable(program)
+                assert rv is None
+
+                # look in current directory
+                with tmp_dir:
+                    rv = find_executable(program)
+                    assert rv == program
+
+        # PATH=':': explicitly looks in the current directory
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATH'] = os.pathsep
+            with (
+                mock.patch('distutils.spawn.os.confstr', return_value='', create=True),
+                mock.patch('distutils.spawn.os.defpath', ''),
+            ):
+                rv = find_executable(program)
+                assert rv is None
+
+                # look in current directory
+                with tmp_dir:
+                    rv = find_executable(program)
+                    assert rv == program
+
+        # missing PATH: test os.confstr("CS_PATH") and os.defpath
+        with os_helper.EnvironmentVarGuard() as env:
+            env.pop('PATH', None)
+
+            # without confstr
+            with (
+                mock.patch(
+                    'distutils.spawn.os.confstr', side_effect=ValueError, create=True
+                ),
+                mock.patch('distutils.spawn.os.defpath', tmp_dir),
+            ):
+                rv = find_executable(program)
+                assert rv == filename
+
+            # with confstr
+            with (
+                mock.patch(
+                    'distutils.spawn.os.confstr', return_value=tmp_dir, create=True
+                ),
+                mock.patch('distutils.spawn.os.defpath', ''),
+            ):
+                rv = find_executable(program)
+                assert rv == filename
+
+    @staticmethod
+    def _make_executable(tmp_path, ext):
+        # Give the temporary program a suffix regardless of platform.
+        # It's needed on Windows and not harmful on others.
+        program = tmp_path.joinpath('program').with_suffix(ext)
+        program.write_text("", encoding='utf-8')
+        program.chmod(stat.S_IXUSR)
+        return program
+
+    def test_spawn_missing_exe(self):
+        with pytest.raises(DistutilsExecError) as ctx:
+            spawn(['does-not-exist'])
+        assert "command 'does-not-exist' failed" in str(ctx.value)

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_sysconfig.py

@@ -0,0 +1,319 @@
+"""Tests for distutils.sysconfig."""
+
+import contextlib
+import distutils
+import os
+import pathlib
+import subprocess
+import sys
+from distutils import sysconfig
+from distutils.ccompiler import new_compiler  # noqa: F401
+from distutils.unixccompiler import UnixCCompiler
+
+import jaraco.envs
+import path
+import pytest
+from jaraco.text import trim
+from test.support import swap_item
+
+
+def _gen_makefile(root, contents):
+    jaraco.path.build({'Makefile': trim(contents)}, root)
+    return root / 'Makefile'
+
+
+@pytest.mark.usefixtures('save_env')
+class TestSysconfig:
+    def test_get_config_h_filename(self):
+        config_h = sysconfig.get_config_h_filename()
+        assert os.path.isfile(config_h)
+
+    @pytest.mark.skipif("platform.system() == 'Windows'")
+    @pytest.mark.skipif("sys.implementation.name != 'cpython'")
+    def test_get_makefile_filename(self):
+        makefile = sysconfig.get_makefile_filename()
+        assert os.path.isfile(makefile)
+
+    def test_get_python_lib(self, tmp_path):
+        assert sysconfig.get_python_lib() != sysconfig.get_python_lib(prefix=tmp_path)
+
+    def test_get_config_vars(self):
+        cvars = sysconfig.get_config_vars()
+        assert isinstance(cvars, dict)
+        assert cvars
+
+    @pytest.mark.skipif('sysconfig.IS_PYPY')
+    @pytest.mark.skipif('sysconfig.python_build')
+    @pytest.mark.xfail('platform.system() == "Windows"')
+    def test_srcdir_simple(self):
+        # See #15364.
+        srcdir = pathlib.Path(sysconfig.get_config_var('srcdir'))
+
+        assert srcdir.absolute()
+        assert srcdir.is_dir()
+
+        makefile = pathlib.Path(sysconfig.get_makefile_filename())
+        assert makefile.parent.samefile(srcdir)
+
+    @pytest.mark.skipif('sysconfig.IS_PYPY')
+    @pytest.mark.skipif('not sysconfig.python_build')
+    def test_srcdir_python_build(self):
+        # See #15364.
+        srcdir = pathlib.Path(sysconfig.get_config_var('srcdir'))
+
+        # The python executable has not been installed so srcdir
+        # should be a full source checkout.
+        Python_h = srcdir.joinpath('Include', 'Python.h')
+        assert Python_h.is_file()
+        assert sysconfig._is_python_source_dir(srcdir)
+        assert sysconfig._is_python_source_dir(str(srcdir))
+
+    def test_srcdir_independent_of_cwd(self):
+        """
+        srcdir should be independent of the current working directory
+        """
+        # See #15364.
+        srcdir = sysconfig.get_config_var('srcdir')
+        with path.Path('..'):
+            srcdir2 = sysconfig.get_config_var('srcdir')
+        assert srcdir == srcdir2
+
+    def customize_compiler(self):
+        # make sure AR gets caught
+        class compiler:
+            compiler_type = 'unix'
+            executables = UnixCCompiler.executables
+
+            def __init__(self):
+                self.exes = {}
+
+            def set_executables(self, **kw):
+                for k, v in kw.items():
+                    self.exes[k] = v
+
+        sysconfig_vars = {
+            'AR': 'sc_ar',
+            'CC': 'sc_cc',
+            'CXX': 'sc_cxx',
+            'ARFLAGS': '--sc-arflags',
+            'CFLAGS': '--sc-cflags',
+            'CCSHARED': '--sc-ccshared',
+            'LDSHARED': 'sc_ldshared',
+            'SHLIB_SUFFIX': 'sc_shutil_suffix',
+        }
+
+        comp = compiler()
+        with contextlib.ExitStack() as cm:
+            for key, value in sysconfig_vars.items():
+                cm.enter_context(swap_item(sysconfig._config_vars, key, value))
+            sysconfig.customize_compiler(comp)
+
+        return comp
+
+    @pytest.mark.skipif("not isinstance(new_compiler(), UnixCCompiler)")
+    @pytest.mark.usefixtures('disable_macos_customization')
+    def test_customize_compiler(self):
+        # Make sure that sysconfig._config_vars is initialized
+        sysconfig.get_config_vars()
+
+        os.environ['AR'] = 'env_ar'
+        os.environ['CC'] = 'env_cc'
+        os.environ['CPP'] = 'env_cpp'
+        os.environ['CXX'] = 'env_cxx --env-cxx-flags'
+        os.environ['LDSHARED'] = 'env_ldshared'
+        os.environ['LDFLAGS'] = '--env-ldflags'
+        os.environ['ARFLAGS'] = '--env-arflags'
+        os.environ['CFLAGS'] = '--env-cflags'
+        os.environ['CPPFLAGS'] = '--env-cppflags'
+        os.environ['RANLIB'] = 'env_ranlib'
+
+        comp = self.customize_compiler()
+        assert comp.exes['archiver'] == 'env_ar --env-arflags'
+        assert comp.exes['preprocessor'] == 'env_cpp --env-cppflags'
+        assert comp.exes['compiler'] == 'env_cc --env-cflags --env-cppflags'
+        assert comp.exes['compiler_so'] == (
+            'env_cc --env-cflags --env-cppflags --sc-ccshared'
+        )
+        assert (
+            comp.exes['compiler_cxx']
+            == 'env_cxx --env-cxx-flags --sc-cflags --env-cppflags'
+        )
+        assert comp.exes['linker_exe'] == 'env_cc'
+        assert comp.exes['linker_so'] == (
+            'env_ldshared --env-ldflags --env-cflags --env-cppflags'
+        )
+        assert comp.shared_lib_extension == 'sc_shutil_suffix'
+
+        if sys.platform == "darwin":
+            assert comp.exes['ranlib'] == 'env_ranlib'
+        else:
+            assert 'ranlib' not in comp.exes
+
+        del os.environ['AR']
+        del os.environ['CC']
+        del os.environ['CPP']
+        del os.environ['CXX']
+        del os.environ['LDSHARED']
+        del os.environ['LDFLAGS']
+        del os.environ['ARFLAGS']
+        del os.environ['CFLAGS']
+        del os.environ['CPPFLAGS']
+        del os.environ['RANLIB']
+
+        comp = self.customize_compiler()
+        assert comp.exes['archiver'] == 'sc_ar --sc-arflags'
+        assert comp.exes['preprocessor'] == 'sc_cc -E'
+        assert comp.exes['compiler'] == 'sc_cc --sc-cflags'
+        assert comp.exes['compiler_so'] == 'sc_cc --sc-cflags --sc-ccshared'
+        assert comp.exes['compiler_cxx'] == 'sc_cxx --sc-cflags'
+        assert comp.exes['linker_exe'] == 'sc_cc'
+        assert comp.exes['linker_so'] == 'sc_ldshared'
+        assert comp.shared_lib_extension == 'sc_shutil_suffix'
+        assert 'ranlib' not in comp.exes
+
+    def test_parse_makefile_base(self, tmp_path):
+        makefile = _gen_makefile(
+            tmp_path,
+            """
+            CONFIG_ARGS=  '--arg1=optarg1' 'ENV=LIB'
+            VAR=$OTHER
+            OTHER=foo
+            """,
+        )
+        d = sysconfig.parse_makefile(makefile)
+        assert d == {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", 'OTHER': 'foo'}
+
+    def test_parse_makefile_literal_dollar(self, tmp_path):
+        makefile = _gen_makefile(
+            tmp_path,
+            """
+            CONFIG_ARGS=  '--arg1=optarg1' 'ENV=\\$$LIB'
+            VAR=$OTHER
+            OTHER=foo
+            """,
+        )
+        d = sysconfig.parse_makefile(makefile)
+        assert d == {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", 'OTHER': 'foo'}
+
+    def test_sysconfig_module(self):
+        import sysconfig as global_sysconfig
+
+        assert global_sysconfig.get_config_var('CFLAGS') == sysconfig.get_config_var(
+            'CFLAGS'
+        )
+        assert global_sysconfig.get_config_var('LDFLAGS') == sysconfig.get_config_var(
+            'LDFLAGS'
+        )
+
+    # On macOS, binary installers support extension module building on
+    # various levels of the operating system with differing Xcode
+    # configurations, requiring customization of some of the
+    # compiler configuration directives to suit the environment on
+    # the installed machine. Some of these customizations may require
+    # running external programs and are thus deferred until needed by
+    # the first extension module build. Only
+    # the Distutils version of sysconfig is used for extension module
+    # builds, which happens earlier in the Distutils tests. This may
+    # cause the following tests to fail since no tests have caused
+    # the global version of sysconfig to call the customization yet.
+    # The solution for now is to simply skip this test in this case.
+    # The longer-term solution is to only have one version of sysconfig.
+    @pytest.mark.skipif("sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER')")
+    def test_sysconfig_compiler_vars(self):
+        import sysconfig as global_sysconfig
+
+        if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'):
+            pytest.skip('compiler flags customized')
+        assert global_sysconfig.get_config_var('LDSHARED') == sysconfig.get_config_var(
+            'LDSHARED'
+        )
+        assert global_sysconfig.get_config_var('CC') == sysconfig.get_config_var('CC')
+
+    @pytest.mark.skipif("not sysconfig.get_config_var('EXT_SUFFIX')")
+    def test_SO_deprecation(self):
+        with pytest.warns(DeprecationWarning):
+            sysconfig.get_config_var('SO')
+
+    def test_customize_compiler_before_get_config_vars(self, tmp_path):
+        # Issue #21923: test that a Distribution compiler
+        # instance can be called without an explicit call to
+        # get_config_vars().
+        jaraco.path.build(
+            {
+                'file': trim("""
+                    from distutils.core import Distribution
+                    config = Distribution().get_command_obj('config')
+                    # try_compile may pass or it may fail if no compiler
+                    # is found but it should not raise an exception.
+                    rc = config.try_compile('int x;')
+                    """)
+            },
+            tmp_path,
+        )
+        p = subprocess.Popen(
+            [sys.executable, tmp_path / 'file'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+            encoding='utf-8',
+        )
+        outs, errs = p.communicate()
+        assert 0 == p.returncode, "Subprocess failed: " + outs
+
+    def test_parse_config_h(self):
+        config_h = sysconfig.get_config_h_filename()
+        input = {}
+        with open(config_h, encoding="utf-8") as f:
+            result = sysconfig.parse_config_h(f, g=input)
+        assert input is result
+        with open(config_h, encoding="utf-8") as f:
+            result = sysconfig.parse_config_h(f)
+        assert isinstance(result, dict)
+
+    @pytest.mark.skipif("platform.system() != 'Windows'")
+    @pytest.mark.skipif("sys.implementation.name != 'cpython'")
+    def test_win_ext_suffix(self):
+        assert sysconfig.get_config_var("EXT_SUFFIX").endswith(".pyd")
+        assert sysconfig.get_config_var("EXT_SUFFIX") != ".pyd"
+
+    @pytest.mark.skipif("platform.system() != 'Windows'")
+    @pytest.mark.skipif("sys.implementation.name != 'cpython'")
+    @pytest.mark.skipif(
+        '\\PCbuild\\'.casefold() not in sys.executable.casefold(),
+        reason='Need sys.executable to be in a source tree',
+    )
+    def test_win_build_venv_from_source_tree(self, tmp_path):
+        """Ensure distutils.sysconfig detects venvs from source tree builds."""
+        env = jaraco.envs.VEnv()
+        env.create_opts = env.clean_opts
+        env.root = tmp_path
+        env.ensure_env()
+        cmd = [
+            env.exe(),
+            "-c",
+            "import distutils.sysconfig; print(distutils.sysconfig.python_build)",
+        ]
+        distutils_path = os.path.dirname(os.path.dirname(distutils.__file__))
+        out = subprocess.check_output(
+            cmd, env={**os.environ, "PYTHONPATH": distutils_path}
+        )
+        assert out == "True"
+
+    def test_get_python_inc_missing_config_dir(self, monkeypatch):
+        """
+        In portable Python installations, the sysconfig will be broken,
+        pointing to the directories where the installation was built and
+        not where it currently is. In this case, ensure that the missing
+        directory isn't used for get_python_inc.
+
+        See pypa/distutils#178.
+        """
+
+        def override(name):
+            if name == 'INCLUDEPY':
+                return '/does-not-exist'
+            return sysconfig.get_config_var(name)
+
+        monkeypatch.setattr(sysconfig, 'get_config_var', override)
+
+        assert os.path.exists(sysconfig.get_python_inc())

project/ManiSkill3/src/maniskill2_benchmark/mani_skill2_repo/.eggs/setuptools-80.9.0-py3.10.egg/setuptools/_distutils/tests/test_util.py

@@ -0,0 +1,243 @@
+"""Tests for distutils.util."""
+
+import email
+import email.generator
+import email.policy
+import io
+import os
+import pathlib
+import sys
+import sysconfig as stdlib_sysconfig
+import unittest.mock as mock
+from copy import copy
+from distutils import sysconfig, util
+from distutils.errors import DistutilsByteCompileError, DistutilsPlatformError
+from distutils.util import (
+    byte_compile,
+    change_root,
+    check_environ,
+    convert_path,
+    get_host_platform,
+    get_platform,
+    grok_environment_error,
+    rfc822_escape,
+    split_quoted,
+    strtobool,
+)
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def environment(monkeypatch):
+    monkeypatch.setattr(os, 'name', os.name)
+    monkeypatch.setattr(sys, 'platform', sys.platform)
+    monkeypatch.setattr(sys, 'version', sys.version)
+    monkeypatch.setattr(os, 'sep', os.sep)
+    monkeypatch.setattr(os.path, 'join', os.path.join)
+    monkeypatch.setattr(os.path, 'isabs', os.path.isabs)
+    monkeypatch.setattr(os.path, 'splitdrive', os.path.splitdrive)
+    monkeypatch.setattr(sysconfig, '_config_vars', copy(sysconfig._config_vars))
+
+
+@pytest.mark.usefixtures('save_env')
+class TestUtil:
+    def test_get_host_platform(self):
+        with mock.patch('os.name', 'nt'):
+            with mock.patch('sys.version', '... [... (ARM64)]'):
+                assert get_host_platform() == 'win-arm64'
+            with mock.patch('sys.version', '... [... (ARM)]'):
+                assert get_host_platform() == 'win-arm32'
+
+        with mock.patch('sys.version_info', (3, 9, 0, 'final', 0)):
+            assert get_host_platform() == stdlib_sysconfig.get_platform()
+
+    def test_get_platform(self):
+        with mock.patch('os.name', 'nt'):
+            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x86'}):
+                assert get_platform() == 'win32'
+            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x64'}):
+                assert get_platform() == 'win-amd64'
+            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm'}):
+                assert get_platform() == 'win-arm32'
+            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm64'}):
+                assert get_platform() == 'win-arm64'
+
+    def test_convert_path(self):
+        expected = os.sep.join(('', 'home', 'to', 'my', 'stuff'))
+        assert convert_path('/home/to/my/stuff') == expected
+        assert convert_path(pathlib.Path('/home/to/my/stuff')) == expected
+        assert convert_path('.') == os.curdir
+
+    def test_change_root(self):
+        # linux/mac
+        os.name = 'posix'
+
+        def _isabs(path):
+            return path[0] == '/'
+
+        os.path.isabs = _isabs
+
+        def _join(*path):
+            return '/'.join(path)
+
+        os.path.join = _join
+
+        assert change_root('/root', '/old/its/here') == '/root/old/its/here'
+        assert change_root('/root', 'its/here') == '/root/its/here'
+
+        # windows
+        os.name = 'nt'
+        os.sep = '\\'
+
+        def _isabs(path):
+            return path.startswith('c:\\')
+
+        os.path.isabs = _isabs
+
+        def _splitdrive(path):
+            if path.startswith('c:'):
+                return ('', path.replace('c:', ''))
+            return ('', path)
+
+        os.path.splitdrive = _splitdrive
+
+        def _join(*path):
+            return '\\'.join(path)
+
+        os.path.join = _join
+
+        assert (
+            change_root('c:\\root', 'c:\\old\\its\\here') == 'c:\\root\\old\\its\\here'
+        )
+        assert change_root('c:\\root', 'its\\here') == 'c:\\root\\its\\here'
+
+        # BugsBunny os (it's a great os)
+        os.name = 'BugsBunny'
+        with pytest.raises(DistutilsPlatformError):
+            change_root('c:\\root', 'its\\here')
+
+        # XXX platforms to be covered: mac
+
+    def test_check_environ(self):
+        util.check_environ.cache_clear()
+        os.environ.pop('HOME', None)
+
+        check_environ()
+
+        assert os.environ['PLAT'] == get_platform()
+
+    @pytest.mark.skipif("os.name != 'posix'")
+    def test_check_environ_getpwuid(self):
+        util.check_environ.cache_clear()
+        os.environ.pop('HOME', None)
+
+        import pwd
+
+        # only set pw_dir field, other fields are not used
+        result = pwd.struct_passwd((
+            None,
+            None,
+            None,
+            None,
+            None,
+            '/home/distutils',
+            None,
+        ))
+        with mock.patch.object(pwd, 'getpwuid', return_value=result):
+            check_environ()
+            assert os.environ['HOME'] == '/home/distutils'
+
+        util.check_environ.cache_clear()
+        os.environ.pop('HOME', None)
+
+        # bpo-10496: Catch pwd.getpwuid() error
+        with mock.patch.object(pwd, 'getpwuid', side_effect=KeyError):
+            check_environ()
+            assert 'HOME' not in os.environ
+
+    def test_split_quoted(self):
+        assert split_quoted('""one"" "two" \'three\' \\four') == [
+            'one',
+            'two',
+            'three',
+            'four',
+        ]
+
+    def test_strtobool(self):
+        yes = ('y', 'Y', 'yes', 'True', 't', 'true', 'True', 'On', 'on', '1')
+        no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N')
+
+        for y in yes:
+            assert strtobool(y)
+
+        for n in no:
+            assert not strtobool(n)
+
+    indent = 8 * ' '
+
+    @pytest.mark.parametrize(
+        "given,wanted",
+        [
+            # 0x0b, 0x0c, ..., etc are also considered a line break by Python
+            ("hello\x0b\nworld\n", f"hello\x0b{indent}\n{indent}world\n{indent}"),
+            ("hello\x1eworld", f"hello\x1e{indent}world"),
+            ("", ""),
+            (
+                "I am a\npoor\nlonesome\nheader\n",
+                f"I am a\n{indent}poor\n{indent}lonesome\n{indent}header\n{indent}",
+            ),
+        ],
+    )
+    def test_rfc822_escape(self, given, wanted):
+        """
+        We want to ensure a multi-line header parses correctly.
+
+        For interoperability, the escaped value should also "round-trip" over
+        `email.generator.Generator.flatten` and `email.message_from_*`
+        (see pypa/setuptools#4033).
+
+        The main issue is that internally `email.policy.EmailPolicy` uses
+        `splitlines` which will split on some control chars. If all the new lines
+        are not prefixed with spaces, the parser will interrupt reading
+        the current header and produce an incomplete value, while
+        incorrectly interpreting the rest of the headers as part of the payload.
+        """
+        res = rfc822_escape(given)
+
+        policy = email.policy.EmailPolicy(
+            utf8=True,
+            mangle_from_=False,
+            max_line_length=0,
+        )
+        with io.StringIO() as buffer:
+            raw = f"header: {res}\nother-header: 42\n\npayload\n"
+            orig = email.message_from_string(raw)
+            email.generator.Generator(buffer, policy=policy).flatten(orig)
+            buffer.seek(0)
+            regen = email.message_from_file(buffer)
+
+        for msg in (orig, regen):
+            assert msg.get_payload() == "payload\n"
+            assert msg["other-header"] == "42"
+            # Generator may replace control chars with `\n`
+            assert set(msg["header"].splitlines()) == set(res.splitlines())
+
+        assert res == wanted
+
+    def test_dont_write_bytecode(self):
+        # makes sure byte_compile raise a DistutilsError
+        # if sys.dont_write_bytecode is True
+        old_dont_write_bytecode = sys.dont_write_bytecode
+        sys.dont_write_bytecode = True
+        try:
+            with pytest.raises(DistutilsByteCompileError):
+                byte_compile([])
+        finally:
+            sys.dont_write_bytecode = old_dont_write_bytecode
+
+    def test_grok_environment_error(self):
+        # test obsolete function to ensure backward compat (#4931)
+        exc = OSError("Unable to find batch file")
+        msg = grok_environment_error(exc)
+        assert msg == "error: Unable to find batch file"

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/empty_scene/0_scene_config.yaml

@@ -0,0 +1,20 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -10
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/empty_table/0_scene_config.yaml

@@ -0,0 +1,20 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/empty_table/1_scene_config.yaml

@@ -0,0 +1,20 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/empty_table/2_scene_config.yaml

@@ -0,0 +1,20 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/empty_table/3_scene_config.yaml

@@ -0,0 +1,20 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/empty_table/4_scene_config.yaml

@@ -0,0 +1,20 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/empty_table/5_scene_config.yaml

@@ -0,0 +1,20 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/scene/base_scene.yaml

@@ -0,0 +1,19 @@
+objects:
+  - name: table
+    visual:
+      path: object/table/desktable.glb
+    collision:
+      path: "object/table/desktable.obj"  # same as visual in this case
+    scale: [2.0, 1.0, 1.5]
+    pose:
+      position: [0.4, 0, -0.75]
+      quaternion: [0, 0, 0.7071068, 0.7071068]
+  # - name: box_1
+  #   visual:
+  #     path: object/box_01/box_01.gltf
+  #   collision:
+  #     path: "object/box_01/box_01.gltf"  # same as visual in this case
+  #   scale: [0.6, 1, 0.7]
+  #   pose:
+  #     position: [0.6, 0, 0.2]
+  #     quaternion: [1, 0, 0, 0]

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/scene/base_scene_shelf.yaml

@@ -0,0 +1,28 @@
+objects:
+  - name: table
+    visual:
+      path: object/table/desktable.glb
+    collision:
+      path: "object/table/desktable.obj"  # same as visual in this case
+    scale: [2.0, 1.0, 1.5]
+    pose:
+      position: [0.4, 0.5, -0.75]
+      quaternion: [0, 0, 0.7071068, 0.7071068]
+  - name: rack
+    visual:
+      path: object/storage_rack_02/storage_rack_02.gltf
+    collision:
+      path: "object/storage_rack_02/rack_convex/"
+    scale: [0.4, 1.1, 1.0]
+    pose:
+      position: [0.4, -0.6, -1.0]
+      quaternion: [0.5, 0.5, 0.5, 0.5]
+  # - name: rack
+  #   visual:
+  #     path: object/storage_rack_02/storage_rack_02.gltf
+  #   collision:
+  #     path: "object/storage_rack_02/storage_rack_02.gltf"  # same as visual in this case
+  #   scale: [0.4, 1.1, 1.0]
+  #   pose:
+  #     position: [0.4, -0.6, -1.0]
+  #     quaternion: [0.5, 0.5, 0.5, 0.5]

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/scene/base_scene_shelf_box.yaml

@@ -0,0 +1,28 @@
+objects:
+  - name: table
+    visual:
+      path: object/table/desktable.glb
+    collision:
+      path: "object/table/desktable.obj"  # same as visual in this case
+    scale: [2.0, 1.0, 1.5]
+    pose:
+      position: [0.4, 0, -0.75]
+      quaternion: [0, 0, 0.7071068, 0.7071068]
+  - name: box_1
+    visual:
+      path: object/box_01/box_01.gltf
+    collision:
+      path: "object/box_01/box_01.gltf"  # same as visual in this case
+    scale: [0.6, 0.6, 0.5]
+    pose:
+      position: [0.4, -0.1, 0]
+      quaternion: [0.5, 0.5, 0.5, 0.5]
+  - name: rack
+    visual:
+      path: object/storage_rack_02/storage_rack_02.gltf
+    collision:
+      path: "object/storage_rack_02/storage_rack_02.gltf"  # same as visual in this case
+    scale: [1.0, 1.0, 1.2]
+    pose:
+      position: [-1.3, -0.1, -0.7]
+      quaternion: [0.5, 0.5, 0.5, 0.5]

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/smallbox_distractor/10_scene_config.yaml

@@ -0,0 +1,298 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_01
+  pose:
+    position:
+    - 0.5540059208869934
+    - 0.3453783690929413
+    - 0.12628550827503204
+    quaternion:
+    - 0.955771803855896
+    - 4.656612873077393e-10
+    - 2.219451289420249e-09
+    - 0.2941097021102905
+  scale:
+  - 0.30462633472651585
+  - 0.4503056890001809
+  - 0.6995941077533729
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_02
+  pose:
+    position:
+    - 0.27282679080963135
+    - 0.3247530162334442
+    - 0.3824552595615387
+    quaternion:
+    - 0.9843308329582214
+    - -2.3283064365386963e-10
+    - 8.717506716493517e-10
+    - -0.1763322800397873
+  scale:
+  - 0.48187877729829126
+  - 0.5548228280451645
+  - 0.6028739189573185
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/051_large_clamp/collision.obj
+  name: large_clamp
+  pose:
+    position:
+    - 0.6507374048233032
+    - 0.26436543464660645
+    - 0.0047948057763278484
+    quaternion:
+    - 0.0034927770029753447
+    - 0.9787878394126892
+    - 0.204830601811409
+    - -0.002589120762422681
+  scale: 1.0
+  visual:
+    path: object/051_large_clamp/textured.obj
+- collision:
+    path: object/032_knife/collision.obj
+  name: knife
+  pose:
+    position:
+    - 0.13959355652332306
+    - -0.1456039547920227
+    - -0.006704706232994795
+    quaternion:
+    - 0.8540351986885071
+    - -0.0500582791864872
+    - -0.029334235936403275
+    - 0.516969621181488
+  scale: 1.0
+  visual:
+    path: object/032_knife/textured.obj
+- collision:
+    path: object/038_padlock/collision.obj
+  name: padlock
+  pose:
+    position:
+    - 0.058888789266347885
+    - 0.3259919583797455
+    - 0.0003714972117450088
+    quaternion:
+    - 0.9998327493667603
+    - 3.6139972507953644e-06
+    - -6.181653589010239e-07
+    - -0.01829713210463524
+  scale: 1.0
+  visual:
+    path: object/038_padlock/textured.obj
+- collision:
+    path: object/005_tomato_soup_can/collision.obj
+  name: tomato_soup_can
+  pose:
+    position:
+    - 0.5280516147613525
+    - -0.13761192560195923
+    - 0.03673742711544037
+    quaternion:
+    - 0.7122544646263123
+    - 0.0030311106238514185
+    - -0.003631005762144923
+    - -0.7019054889678955
+  scale: 1.0
+  visual:
+    path: object/005_tomato_soup_can/textured.obj
+- collision:
+    path: object/057_racquetball/collision.obj
+  name: racquetball
+  pose:
+    position:
+    - 0.47516927123069763
+    - -0.3109491169452667
+    - 0.013362742960453033
+    quaternion:
+    - 0.9950342774391174
+    - 0.055038727819919586
+    - -0.0804380252957344
+    - -0.02018539048731327
+  scale: 1.0
+  visual:
+    path: object/057_racquetball/textured.obj
+- collision:
+    path: object/054_softball/collision.obj
+  name: softball
+  pose:
+    position:
+    - 0.3860659897327423
+    - -0.018826313316822052
+    - 0.03258978947997093
+    quaternion:
+    - 0.7283158302307129
+    - 0.02213624119758606
+    - -0.01194368489086628
+    - 0.6847798824310303
+  scale: 1.0
+  visual:
+    path: object/054_softball/textured.obj
+- collision:
+    path: object/009_gelatin_box/collision.obj
+  name: gelatin_box
+  pose:
+    position:
+    - 0.05515049770474434
+    - 0.4038052558898926
+    - 0.00034619105281308293
+    quaternion:
+    - 0.006828893441706896
+    - -0.6510798335075378
+    - -0.7589545249938965
+    - -0.006042522378265858
+  scale: 1.0
+  visual:
+    path: object/009_gelatin_box/textured.obj
+- collision:
+    path: object/011_banana/collision.obj
+  name: banana
+  pose:
+    position:
+    - 0.5881876349449158
+    - 0.09575887024402618
+    - 0.004429987631738186
+    quaternion:
+    - 0.7235199809074402
+    - 0.00045461952686309814
+    - -0.0008089791517704725
+    - 0.6903027296066284
+  scale: 1.0
+  visual:
+    path: object/011_banana/textured.obj
+- collision:
+    path: object/043_phillips_screwdriver/collision.obj
+  name: phillips_screwdriver
+  pose:
+    position:
+    - 0.3318164348602295
+    - 0.34391456842422485
+    - 0.5161935687065125
+    quaternion:
+    - 0.9093779921531677
+    - 0.19456228613853455
+    - 0.050330422818660736
+    - 0.3642030358314514
+  scale: 1.0
+  visual:
+    path: object/043_phillips_screwdriver/textured.obj
+- collision:
+    path: object/073-a_lego_duplo/collision.obj
+  name: lego_duplo
+  pose:
+    position:
+    - 0.3287605047225952
+    - -0.3322675824165344
+    - -0.001962269190698862
+    quaternion:
+    - 0.9214631915092468
+    - -0.00017691310495138168
+    - -0.0002771954459603876
+    - 0.38846608996391296
+  scale: 1.0
+  visual:
+    path: object/073-a_lego_duplo/textured.obj
+- collision:
+    path: object/006_mustard_bottle/collision.obj
+  name: mustard_bottle
+  pose:
+    position:
+    - 0.3012140691280365
+    - -0.19351541996002197
+    - 0.0831894800066948
+    quaternion:
+    - 0.998798668384552
+    - -0.003416737075895071
+    - 0.00013295424287207425
+    - -0.04888187721371651
+  scale: 1.0
+  visual:
+    path: object/006_mustard_bottle/textured.obj
+- collision:
+    path: object/002_master_chef_can/collision.obj
+  name: master_chef_can
+  pose:
+    position:
+    - 0.2739158272743225
+    - 0.16811329126358032
+    - 0.056464310735464096
+    quaternion:
+    - 0.9971371293067932
+    - 3.3126998459920287e-06
+    - -1.9168946892023087e-06
+    - -0.07561670243740082
+  scale: 1.0
+  visual:
+    path: object/002_master_chef_can/textured.obj
+- collision:
+    path: object/036_wood_block/collision.obj
+  name: wood_block
+  pose:
+    position:
+    - 0.42733234167099
+    - -0.2404153198003769
+    - 0.0901753306388855
+    quaternion:
+    - 0.788737952709198
+    - -0.00010942301014438272
+    - -0.00404078746214509
+    - -0.6147165298461914
+  scale: 1.0
+  visual:
+    path: object/036_wood_block/textured.obj
+- collision:
+    path: object/012_strawberry/collision.obj
+  name: strawberry
+  pose:
+    position:
+    - 0.19788631796836853
+    - -0.364406555891037
+    - 0.008576838299632072
+    quaternion:
+    - 0.9993845224380493
+    - -0.019167844206094742
+    - 0.025167033076286316
+    - 0.015163440257310867
+  scale: 1.0
+  visual:
+    path: object/012_strawberry/textured.obj
+- collision:
+    path: object/072-c_toy_airplane/collision.obj
+  name: toy_airplane
+  pose:
+    position:
+    - 0.0575077198445797
+    - -0.5082716941833496
+    - 0.019499726593494415
+    quaternion:
+    - 0.9456946849822998
+    - 8.636110578663647e-06
+    - 1.4507357263937593e-05
+    - -0.3250561058521271
+  scale: 1.0
+  visual:
+    path: object/072-c_toy_airplane/textured.obj

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/smallbox_distractor/13_scene_config.yaml

@@ -0,0 +1,298 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_01
+  pose:
+    position:
+    - 0.2600131332874298
+    - 0.3242727220058441
+    - 0.12627248466014862
+    quaternion:
+    - 0.9969368577003479
+    - 2.3283064365386963e-10
+    - 1.9917933968827128e-10
+    - 0.07821343094110489
+  scale:
+  - 0.30462633472651585
+  - 0.4503056890001809
+  - 0.6995941077533729
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_02
+  pose:
+    position:
+    - 0.31212708353996277
+    - -0.03571797162294388
+    - 0.10678669065237045
+    quaternion:
+    - 0.9896991848945618
+    - 1.3969838619232178e-09
+    - -2.5556801119819283e-10
+    - -0.14316244423389435
+  scale:
+  - 0.48187877729829126
+  - 0.5548228280451645
+  - 0.6028739189573185
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/051_large_clamp/collision.obj
+  name: large_clamp
+  pose:
+    position:
+    - 0.30179834365844727
+    - -0.3673531413078308
+    - 0.004934901371598244
+    quaternion:
+    - 0.9214151501655579
+    - 0.01573387160897255
+    - 0.006530481856316328
+    - 0.3882060647010803
+  scale: 1.0
+  visual:
+    path: object/051_large_clamp/textured.obj
+- collision:
+    path: object/032_knife/collision.obj
+  name: knife
+  pose:
+    position:
+    - 0.590972900390625
+    - -0.3353188633918762
+    - -0.006698941346257925
+    quaternion:
+    - 0.7824130654335022
+    - -0.04494365304708481
+    - 0.03668520227074623
+    - -0.6200517416000366
+  scale: 1.0
+  visual:
+    path: object/032_knife/textured.obj
+- collision:
+    path: object/038_padlock/collision.obj
+  name: padlock
+  pose:
+    position:
+    - 0.5620276927947998
+    - 0.33525681495666504
+    - 0.0003732643090188503
+    quaternion:
+    - 0.9999450445175171
+    - 1.9050203263759613e-06
+    - -4.377681761980057e-06
+    - -0.010492338798940182
+  scale: 1.0
+  visual:
+    path: object/038_padlock/textured.obj
+- collision:
+    path: object/005_tomato_soup_can/collision.obj
+  name: tomato_soup_can
+  pose:
+    position:
+    - 0.48183348774909973
+    - -0.29772084951400757
+    - 0.036742474883794785
+    quaternion:
+    - 0.9364031553268433
+    - 0.004575126338750124
+    - 0.001217052573338151
+    - 0.35089439153671265
+  scale: 1.0
+  visual:
+    path: object/005_tomato_soup_can/textured.obj
+- collision:
+    path: object/057_racquetball/collision.obj
+  name: racquetball
+  pose:
+    position:
+    - 0.4179935157299042
+    - -0.12145572900772095
+    - 0.013357745483517647
+    quaternion:
+    - 0.7930589914321899
+    - -0.0027601830661296844
+    - -0.09742449969053268
+    - -0.6012974381446838
+  scale: 1.0
+  visual:
+    path: object/057_racquetball/textured.obj
+- collision:
+    path: object/054_softball/collision.obj
+  name: softball
+  pose:
+    position:
+    - -0.2997354567050934
+    - 0.4991663098335266
+    - -0.7519590258598328
+    quaternion:
+    - -0.29745084047317505
+    - -0.8697314858436584
+    - 0.37594035267829895
+    - 0.11729992181062698
+  scale: 1.0
+  visual:
+    path: object/054_softball/textured.obj
+- collision:
+    path: object/009_gelatin_box/collision.obj
+  name: gelatin_box
+  pose:
+    position:
+    - 0.6723349094390869
+    - -0.4518553614616394
+    - 0.0009576601441949606
+    quaternion:
+    - 0.995653510093689
+    - 5.730966222472489e-06
+    - -4.902940418105572e-07
+    - 0.09313605725765228
+  scale: 1.0
+  visual:
+    path: object/009_gelatin_box/textured.obj
+- collision:
+    path: object/011_banana/collision.obj
+  name: banana
+  pose:
+    position:
+    - 0.27068841457366943
+    - -0.13846950232982635
+    - 0.004433405585587025
+    quaternion:
+    - 0.9667468070983887
+    - -0.0018015876412391663
+    - -0.0028480058535933495
+    - -0.25571319460868835
+  scale: 1.0
+  visual:
+    path: object/011_banana/textured.obj
+- collision:
+    path: object/043_phillips_screwdriver/collision.obj
+  name: phillips_screwdriver
+  pose:
+    position:
+    - 0.2952132225036621
+    - 0.31410926580429077
+    - -8.021248504519463e-05
+    quaternion:
+    - -0.08763675391674042
+    - 0.044274117797613144
+    - -0.18019986152648926
+    - 0.9787173867225647
+  scale: 1.0
+  visual:
+    path: object/043_phillips_screwdriver/textured.obj
+- collision:
+    path: object/073-a_lego_duplo/collision.obj
+  name: lego_duplo
+  pose:
+    position:
+    - 0.31756454706192017
+    - 0.17813710868358612
+    - -0.0019623327534645796
+    quaternion:
+    - 0.8716660141944885
+    - -1.400848850607872e-05
+    - 2.8955109883099794e-06
+    - -0.4901004135608673
+  scale: 1.0
+  visual:
+    path: object/073-a_lego_duplo/textured.obj
+- collision:
+    path: object/006_mustard_bottle/collision.obj
+  name: mustard_bottle
+  pose:
+    position:
+    - 0.0867718979716301
+    - 0.1676323115825653
+    - 0.08319085836410522
+    quaternion:
+    - 0.8900477886199951
+    - -0.0030580703169107437
+    - 0.0015297516947612166
+    - -0.4558544456958771
+  scale: 1.0
+  visual:
+    path: object/006_mustard_bottle/textured.obj
+- collision:
+    path: object/002_master_chef_can/collision.obj
+  name: master_chef_can
+  pose:
+    position:
+    - 0.45520690083503723
+    - 0.2683074176311493
+    - 0.056465260684490204
+    quaternion:
+    - 0.8327399492263794
+    - 2.822984242811799e-06
+    - 2.4348264560103416e-07
+    - -0.5536643862724304
+  scale: 1.0
+  visual:
+    path: object/002_master_chef_can/textured.obj
+- collision:
+    path: object/036_wood_block/collision.obj
+  name: wood_block
+  pose:
+    position:
+    - 0.5919787883758545
+    - -0.09230861812829971
+    - 0.09017115086317062
+    quaternion:
+    - 0.987817645072937
+    - 0.001885376637801528
+    - -0.0035402229987084866
+    - -0.1555652916431427
+  scale: 1.0
+  visual:
+    path: object/036_wood_block/textured.obj
+- collision:
+    path: object/012_strawberry/collision.obj
+  name: strawberry
+  pose:
+    position:
+    - 0.5924925208091736
+    - 0.24831071496009827
+    - 0.008575117215514183
+    quaternion:
+    - 0.909085214138031
+    - -0.02766706794500351
+    - 0.015344343148171902
+    - 0.41540753841400146
+  scale: 1.0
+  visual:
+    path: object/012_strawberry/textured.obj
+- collision:
+    path: object/072-c_toy_airplane/collision.obj
+  name: toy_airplane
+  pose:
+    position:
+    - 0.4595275819301605
+    - 0.42760536074638367
+    - 0.01950046978890896
+    quaternion:
+    - 0.8649252653121948
+    - 7.10635504219681e-07
+    - -1.0786170605570078e-06
+    - 0.5019010901451111
+  scale: 1.0
+  visual:
+    path: object/072-c_toy_airplane/textured.obj

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/smallbox_distractor/18_scene_config.yaml

@@ -0,0 +1,298 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_01
+  pose:
+    position:
+    - 0.4446021020412445
+    - 0.29050955176353455
+    - 0.12626424431800842
+    quaternion:
+    - 0.9433392882347107
+    - 0.0
+    - 3.0377123039215803e-10
+    - -0.33182990550994873
+  scale:
+  - 0.30462633472651585
+  - 0.4503056890001809
+  - 0.6995941077533729
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_02
+  pose:
+    position:
+    - 0.46855005621910095
+    - -0.2516274154186249
+    - 0.10678362101316452
+    quaternion:
+    - 0.9293932318687439
+    - 2.3283064365386963e-09
+    - 3.0831870390102267e-10
+    - 0.369091659784317
+  scale:
+  - 0.48187877729829126
+  - 0.5548228280451645
+  - 0.6028739189573185
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/051_large_clamp/collision.obj
+  name: large_clamp
+  pose:
+    position:
+    - 0.2098422795534134
+    - -0.1291932910680771
+    - 0.004791269078850746
+    quaternion:
+    - -0.003990287892520428
+    - -0.9072166681289673
+    - -0.42064112424850464
+    - 0.0017297938466072083
+  scale: 1.0
+  visual:
+    path: object/051_large_clamp/textured.obj
+- collision:
+    path: object/032_knife/collision.obj
+  name: knife
+  pose:
+    position:
+    - 0.28637921810150146
+    - 0.01384325884282589
+    - -0.006703410763293505
+    quaternion:
+    - 0.9480249881744385
+    - -0.05482200160622597
+    - 0.018967915326356888
+    - -0.31286343932151794
+  scale: 1.0
+  visual:
+    path: object/032_knife/textured.obj
+- collision:
+    path: object/038_padlock/collision.obj
+  name: padlock
+  pose:
+    position:
+    - 0.13275587558746338
+    - -0.2956305742263794
+    - 0.00037525923107750714
+    quaternion:
+    - 0.9865192770957947
+    - 5.6782737374305725e-06
+    - -1.8726568669080734e-06
+    - 0.163645401597023
+  scale: 1.0
+  visual:
+    path: object/038_padlock/textured.obj
+- collision:
+    path: object/005_tomato_soup_can/collision.obj
+  name: tomato_soup_can
+  pose:
+    position:
+    - 0.7378512024879456
+    - 0.1887216418981552
+    - 0.019866012036800385
+    quaternion:
+    - -0.6632572412490845
+    - 0.39579665660858154
+    - 0.5805317759513855
+    - -0.2577165365219116
+  scale: 1.0
+  visual:
+    path: object/005_tomato_soup_can/textured.obj
+- collision:
+    path: object/057_racquetball/collision.obj
+  name: racquetball
+  pose:
+    position:
+    - 0.5852177739143372
+    - -0.2394147515296936
+    - 0.013357710093259811
+    quaternion:
+    - 0.9352325201034546
+    - 0.0803675726056099
+    - -0.055147092789411545
+    - 0.3403528332710266
+  scale: 1.0
+  visual:
+    path: object/057_racquetball/textured.obj
+- collision:
+    path: object/054_softball/collision.obj
+  name: softball
+  pose:
+    position:
+    - 0.37791121006011963
+    - -0.18030773103237152
+    - 0.2730855941772461
+    quaternion:
+    - 0.8899809718132019
+    - 0.015370525419712067
+    - -0.016068505123257637
+    - 0.45545536279678345
+  scale: 1.0
+  visual:
+    path: object/054_softball/textured.obj
+- collision:
+    path: object/009_gelatin_box/collision.obj
+  name: gelatin_box
+  pose:
+    position:
+    - 0.2939893305301666
+    - 0.22424477338790894
+    - 0.0009559107711538672
+    quaternion:
+    - 0.756985604763031
+    - 3.3548567444086075e-06
+    - 1.1468182492535561e-07
+    - -0.6534317135810852
+  scale: 1.0
+  visual:
+    path: object/009_gelatin_box/textured.obj
+- collision:
+    path: object/011_banana/collision.obj
+  name: banana
+  pose:
+    position:
+    - 0.2699192464351654
+    - -0.4690324366092682
+    - 0.004431434907019138
+    quaternion:
+    - 0.8259942531585693
+    - 0.0003224574029445648
+    - -0.0008735787123441696
+    - 0.5636776089668274
+  scale: 1.0
+  visual:
+    path: object/011_banana/textured.obj
+- collision:
+    path: object/043_phillips_screwdriver/collision.obj
+  name: phillips_screwdriver
+  pose:
+    position:
+    - 0.0712708830833435
+    - -0.18694385886192322
+    - 0.00015884707681834698
+    quaternion:
+    - 0.7834087014198303
+    - 0.05132182687520981
+    - 0.006559666711837053
+    - 0.6193495988845825
+  scale: 1.0
+  visual:
+    path: object/043_phillips_screwdriver/textured.obj
+- collision:
+    path: object/073-a_lego_duplo/collision.obj
+  name: lego_duplo
+  pose:
+    position:
+    - 0.4959663450717926
+    - -0.458866149187088
+    - -0.0019607827998697758
+    quaternion:
+    - 0.8269393444061279
+    - 5.000841338187456e-05
+    - 6.670382572337985e-05
+    - 0.5622912049293518
+  scale: 1.0
+  visual:
+    path: object/073-a_lego_duplo/textured.obj
+- collision:
+    path: object/006_mustard_bottle/collision.obj
+  name: mustard_bottle
+  pose:
+    position:
+    - 0.6654345989227295
+    - -0.11777448654174805
+    - 0.08319094032049179
+    quaternion:
+    - 0.7906532287597656
+    - -0.002683550352230668
+    - -0.0021238576155155897
+    - 0.6122546792030334
+  scale: 1.0
+  visual:
+    path: object/006_mustard_bottle/textured.obj
+- collision:
+    path: object/002_master_chef_can/collision.obj
+  name: master_chef_can
+  pose:
+    position:
+    - 0.20512913167476654
+    - 0.447907418012619
+    - 0.056465644389390945
+    quaternion:
+    - 0.9804720878601074
+    - 2.8952454158570617e-06
+    - -2.191954990848899e-06
+    - 0.19665849208831787
+  scale: 1.0
+  visual:
+    path: object/002_master_chef_can/textured.obj
+- collision:
+    path: object/036_wood_block/collision.obj
+  name: wood_block
+  pose:
+    position:
+    - 0.4926045835018158
+    - 0.36373525857925415
+    - 0.3693050742149353
+    quaternion:
+    - 0.7077661752700806
+    - -0.0038924370892345905
+    - -5.648715887218714e-05
+    - -0.7064360976219177
+  scale: 1.0
+  visual:
+    path: object/036_wood_block/textured.obj
+- collision:
+    path: object/012_strawberry/collision.obj
+  name: strawberry
+  pose:
+    position:
+    - 0.6029479503631592
+    - -0.3509550988674164
+    - 0.008256884291768074
+    quaternion:
+    - 0.8891028165817261
+    - -0.0734761506319046
+    - 0.010937608778476715
+    - -0.4516390264034271
+  scale: 1.0
+  visual:
+    path: object/012_strawberry/textured.obj
+- collision:
+    path: object/072-c_toy_airplane/collision.obj
+  name: toy_airplane
+  pose:
+    position:
+    - 0.566066563129425
+    - -0.460176944732666
+    - 0.019500385969877243
+    quaternion:
+    - 0.8678380846977234
+    - 7.897335308371112e-06
+    - -4.277069820091128e-06
+    - 0.4968472421169281
+  scale: 1.0
+  visual:
+    path: object/072-c_toy_airplane/textured.obj

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/smallbox_distractor/6_scene_config.yaml

@@ -0,0 +1,298 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_01
+  pose:
+    position:
+    - 0.3222593367099762
+    - -0.3457235097885132
+    - 0.1262739598751068
+    quaternion:
+    - 0.949219822883606
+    - -1.3969838619232178e-09
+    - -3.7562131183221936e-10
+    - -0.3146144151687622
+  scale:
+  - 0.30462633472651585
+  - 0.4503056890001809
+  - 0.6995941077533729
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_02
+  pose:
+    position:
+    - 0.481027215719223
+    - -0.024567749351263046
+    - 0.1067868322134018
+    quaternion:
+    - 0.9900256395339966
+    - 1.6298145055770874e-09
+    - -4.3155523599125445e-10
+    - -0.14088822901248932
+  scale:
+  - 0.48187877729829126
+  - 0.5548228280451645
+  - 0.6028739189573185
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/051_large_clamp/collision.obj
+  name: large_clamp
+  pose:
+    position:
+    - 0.1499818116426468
+    - 0.09657865762710571
+    - 0.004600871820002794
+    quaternion:
+    - 0.933480441570282
+    - -0.03696729242801666
+    - 0.014331860467791557
+    - -0.3564299941062927
+  scale: 1.0
+  visual:
+    path: object/051_large_clamp/textured.obj
+- collision:
+    path: object/032_knife/collision.obj
+  name: knife
+  pose:
+    position:
+    - 0.3910253643989563
+    - 0.13206909596920013
+    - 0.23240238428115845
+    quaternion:
+    - 0.8722466826438904
+    - -0.10972946882247925
+    - -0.0036878089886158705
+    - 0.4765833914279938
+  scale: 1.0
+  visual:
+    path: object/032_knife/textured.obj
+- collision:
+    path: object/038_padlock/collision.obj
+  name: padlock
+  pose:
+    position:
+    - 0.670044481754303
+    - 0.36275461316108704
+    - 0.0003735860518645495
+    quaternion:
+    - 0.9177653193473816
+    - 2.971850335597992e-06
+    - 4.7637149691581726e-07
+    - -0.3971234858036041
+  scale: 1.0
+  visual:
+    path: object/038_padlock/textured.obj
+- collision:
+    path: object/005_tomato_soup_can/collision.obj
+  name: tomato_soup_can
+  pose:
+    position:
+    - 0.1289377510547638
+    - -0.265663743019104
+    - 0.03666556626558304
+    quaternion:
+    - 0.9753833413124084
+    - 0.00400533014908433
+    - 0.00018187658861279488
+    - -0.22048020362854004
+  scale: 1.0
+  visual:
+    path: object/005_tomato_soup_can/textured.obj
+- collision:
+    path: object/057_racquetball/collision.obj
+  name: racquetball
+  pose:
+    position:
+    - 0.6248867511749268
+    - -0.17318613827228546
+    - 0.01335796806961298
+    quaternion:
+    - 0.9952068328857422
+    - 0.057292770594358444
+    - -0.0788535624742508
+    - 0.007947297766804695
+  scale: 1.0
+  visual:
+    path: object/057_racquetball/textured.obj
+- collision:
+    path: object/054_softball/collision.obj
+  name: softball
+  pose:
+    position:
+    - 0.49240392446517944
+    - -0.098780557513237
+    - 0.03258971497416496
+    quaternion:
+    - 0.822936475276947
+    - -0.007003158330917358
+    - -0.02415677160024643
+    - -0.5675767064094543
+  scale: 1.0
+  visual:
+    path: object/054_softball/textured.obj
+- collision:
+    path: object/009_gelatin_box/collision.obj
+  name: gelatin_box
+  pose:
+    position:
+    - 0.461259126663208
+    - -0.2755953073501587
+    - 0.030791644006967545
+    quaternion:
+    - 0.6426966190338135
+    - -0.639816403388977
+    - 0.29424235224723816
+    - -0.30165788531303406
+  scale: 1.0
+  visual:
+    path: object/009_gelatin_box/textured.obj
+- collision:
+    path: object/011_banana/collision.obj
+  name: banana
+  pose:
+    position:
+    - 0.4110216200351715
+    - 0.35490134358406067
+    - 0.00443665124475956
+    quaternion:
+    - 0.9503698348999023
+    - 3.54573130607605e-05
+    - -0.0033732284791767597
+    - 0.3111042082309723
+  scale: 1.0
+  visual:
+    path: object/011_banana/textured.obj
+- collision:
+    path: object/043_phillips_screwdriver/collision.obj
+  name: phillips_screwdriver
+  pose:
+    position:
+    - 0.28932085633277893
+    - -0.08201035112142563
+    - 0.00016026291996240616
+    quaternion:
+    - 0.9670155048370361
+    - 0.04959922283887863
+    - -0.014761464670300484
+    - 0.24940568208694458
+  scale: 1.0
+  visual:
+    path: object/043_phillips_screwdriver/textured.obj
+- collision:
+    path: object/073-a_lego_duplo/collision.obj
+  name: lego_duplo
+  pose:
+    position:
+    - 0.6968550682067871
+    - -0.4321824014186859
+    - -0.0019602645188570023
+    quaternion:
+    - 0.8572718501091003
+    - 3.327080048620701e-05
+    - 9.370414773002267e-07
+    - -0.5148642063140869
+  scale: 1.0
+  visual:
+    path: object/073-a_lego_duplo/textured.obj
+- collision:
+    path: object/006_mustard_bottle/collision.obj
+  name: mustard_bottle
+  pose:
+    position:
+    - 0.29827508330345154
+    - -0.41968485713005066
+    - 0.08319402486085892
+    quaternion:
+    - 0.982006847858429
+    - -0.003348998026922345
+    - -0.0006806309684179723
+    - 0.1888151317834854
+  scale: 1.0
+  visual:
+    path: object/006_mustard_bottle/textured.obj
+- collision:
+    path: object/002_master_chef_can/collision.obj
+  name: master_chef_can
+  pose:
+    position:
+    - 0.1292555183172226
+    - -0.42202019691467285
+    - 0.05646669864654541
+    quaternion:
+    - 0.7298344373703003
+    - 3.900931915268302e-06
+    - 3.832974471151829e-06
+    - -0.6836239695549011
+  scale: 1.0
+  visual:
+    path: object/002_master_chef_can/textured.obj
+- collision:
+    path: object/036_wood_block/collision.obj
+  name: wood_block
+  pose:
+    position:
+    - 0.6624081134796143
+    - 0.2338888794183731
+    - 0.09017322957515717
+    quaternion:
+    - 0.9026984572410583
+    - 0.0035555679351091385
+    - -0.001857698312960565
+    - 0.4302552342414856
+  scale: 1.0
+  visual:
+    path: object/036_wood_block/textured.obj
+- collision:
+    path: object/012_strawberry/collision.obj
+  name: strawberry
+  pose:
+    position:
+    - 0.6003867387771606
+    - -0.3430365025997162
+    - 0.008257033303380013
+    quaternion:
+    - 0.9331845641136169
+    - -0.057636748999357224
+    - -0.046866096556186676
+    - 0.35163646936416626
+  scale: 1.0
+  visual:
+    path: object/012_strawberry/textured.obj
+- collision:
+    path: object/072-c_toy_airplane/collision.obj
+  name: toy_airplane
+  pose:
+    position:
+    - 0.06322619318962097
+    - -0.2130347192287445
+    - 0.0006565345684066415
+    quaternion:
+    - -0.29697299003601074
+    - -0.2992590665817261
+    - 0.6475196480751038
+    - 0.6347987055778503
+  scale: 1.0
+  visual:
+    path: object/072-c_toy_airplane/textured.obj

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/smallbox_distractor/8_scene_config.yaml

@@ -0,0 +1,298 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_01
+  pose:
+    position:
+    - 0.37825292348861694
+    - 0.16329726576805115
+    - 0.1262717992067337
+    quaternion:
+    - 0.969598114490509
+    - 0.0
+    - -6.116351869422942e-11
+    - 0.24470341205596924
+  scale:
+  - 0.30462633472651585
+  - 0.4503056890001809
+  - 0.6995941077533729
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_02
+  pose:
+    position:
+    - 0.4816591441631317
+    - 0.3444681465625763
+    - 0.1067897379398346
+    quaternion:
+    - 0.991497278213501
+    - 1.862645149230957e-09
+    - 3.866261977236718e-09
+    - 0.1301281899213791
+  scale:
+  - 0.48187877729829126
+  - 0.5548228280451645
+  - 0.6028739189573185
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/051_large_clamp/collision.obj
+  name: large_clamp
+  pose:
+    position:
+    - 0.22649766504764557
+    - 0.3660420775413513
+    - 0.0047942474484443665
+    quaternion:
+    - -0.0006621364736929536
+    - 0.6380801796913147
+    - -0.7699576616287231
+    - -0.0042999982833862305
+  scale: 1.0
+  visual:
+    path: object/051_large_clamp/textured.obj
+- collision:
+    path: object/032_knife/collision.obj
+  name: knife
+  pose:
+    position:
+    - 0.5382602214813232
+    - 0.13345010578632355
+    - -0.0067017762921750546
+    quaternion:
+    - 0.8549917340278625
+    - -0.04925115033984184
+    - 0.030661150813102722
+    - -0.5153865814208984
+  scale: 1.0
+  visual:
+    path: object/032_knife/textured.obj
+- collision:
+    path: object/038_padlock/collision.obj
+  name: padlock
+  pose:
+    position:
+    - 0.5620970726013184
+    - -0.3338588774204254
+    - 0.00037482159677892923
+    quaternion:
+    - 0.7455541491508484
+    - 3.91155481338501e-06
+    - 4.93205152451992e-06
+    - -0.6664450764656067
+  scale: 1.0
+  visual:
+    path: object/038_padlock/textured.obj
+- collision:
+    path: object/005_tomato_soup_can/collision.obj
+  name: tomato_soup_can
+  pose:
+    position:
+    - 0.16778449714183807
+    - 0.1865750253200531
+    - 0.03673816844820976
+    quaternion:
+    - 0.9962206482887268
+    - 0.0047322167083621025
+    - -5.394988693296909e-05
+    - 0.08673030138015747
+  scale: 1.0
+  visual:
+    path: object/005_tomato_soup_can/textured.obj
+- collision:
+    path: object/057_racquetball/collision.obj
+  name: racquetball
+  pose:
+    position:
+    - 0.3258103132247925
+    - -0.2767982482910156
+    - 0.013363120146095753
+    quaternion:
+    - 0.9052622318267822
+    - 0.01858438551425934
+    - -0.0956725925207138
+    - -0.4135236144065857
+  scale: 1.0
+  visual:
+    path: object/057_racquetball/textured.obj
+- collision:
+    path: object/054_softball/collision.obj
+  name: softball
+  pose:
+    position:
+    - 0.6794442534446716
+    - -0.37263914942741394
+    - 0.03259354084730148
+    quaternion:
+    - 0.9393547773361206
+    - 0.015637263655662537
+    - -0.01970824971795082
+    - 0.34202316403388977
+  scale: 1.0
+  visual:
+    path: object/054_softball/textured.obj
+- collision:
+    path: object/009_gelatin_box/collision.obj
+  name: gelatin_box
+  pose:
+    position:
+    - 0.6688522696495056
+    - 0.3424641191959381
+    - 0.0009576840093359351
+    quaternion:
+    - 0.9925773739814758
+    - 2.238331944681704e-06
+    - -1.0965741239488125e-06
+    - 0.12161517888307571
+  scale: 1.0
+  visual:
+    path: object/009_gelatin_box/textured.obj
+- collision:
+    path: object/011_banana/collision.obj
+  name: banana
+  pose:
+    position:
+    - 0.6101178526878357
+    - -0.18726269900798798
+    - 0.004428462125360966
+    quaternion:
+    - 0.8621869683265686
+    - 0.0002595148980617523
+    - -0.0008918971288949251
+    - 0.5065892338752747
+  scale: 1.0
+  visual:
+    path: object/011_banana/textured.obj
+- collision:
+    path: object/043_phillips_screwdriver/collision.obj
+  name: phillips_screwdriver
+  pose:
+    position:
+    - 0.32951784133911133
+    - -0.3770958483219147
+    - 0.00016453256830573082
+    quaternion:
+    - 0.9927594661712646
+    - 0.041176386177539825
+    - -0.03133397921919823
+    - -0.10840417444705963
+  scale: 1.0
+  visual:
+    path: object/043_phillips_screwdriver/textured.obj
+- collision:
+    path: object/073-a_lego_duplo/collision.obj
+  name: lego_duplo
+  pose:
+    position:
+    - 0.3602128028869629
+    - 0.05884125083684921
+    - 0.0019344050670042634
+    quaternion:
+    - -0.5039743185043335
+    - 0.503972053527832
+    - 0.49599689245224
+    - -0.4959932267665863
+  scale: 1.0
+  visual:
+    path: object/073-a_lego_duplo/textured.obj
+- collision:
+    path: object/006_mustard_bottle/collision.obj
+  name: mustard_bottle
+  pose:
+    position:
+    - 0.3909037411212921
+    - -0.15876904129981995
+    - 0.08319000899791718
+    quaternion:
+    - 0.7571060657501221
+    - -0.002608793554827571
+    - 0.00221131625585258
+    - -0.6532832384109497
+  scale: 1.0
+  visual:
+    path: object/006_mustard_bottle/textured.obj
+- collision:
+    path: object/002_master_chef_can/collision.obj
+  name: master_chef_can
+  pose:
+    position:
+    - 0.07956720888614655
+    - -0.47045576572418213
+    - 0.05646609887480736
+    quaternion:
+    - 0.8410736322402954
+    - 4.7594658099114895e-06
+    - 3.2882962841540575e-06
+    - -0.5409208536148071
+  scale: 1.0
+  visual:
+    path: object/002_master_chef_can/textured.obj
+- collision:
+    path: object/036_wood_block/collision.obj
+  name: wood_block
+  pose:
+    position:
+    - 0.3544745147228241
+    - -0.027066651731729507
+    - 0.09017084538936615
+    quaternion:
+    - 0.7453569769859314
+    - 0.003932867664843798
+    - -0.0007846400840207934
+    - 0.6666537523269653
+  scale: 1.0
+  visual:
+    path: object/036_wood_block/textured.obj
+- collision:
+    path: object/012_strawberry/collision.obj
+  name: strawberry
+  pose:
+    position:
+    - 0.05693713203072548
+    - 0.2519106864929199
+    - 0.008573662489652634
+    quaternion:
+    - 0.9645155668258667
+    - -0.011449531652033329
+    - 0.029495861381292343
+    - -0.2621235251426697
+  scale: 1.0
+  visual:
+    path: object/012_strawberry/textured.obj
+- collision:
+    path: object/072-c_toy_airplane/collision.obj
+  name: toy_airplane
+  pose:
+    position:
+    - 0.04396650940179825
+    - 0.4770829677581787
+    - 0.019499460235238075
+    quaternion:
+    - 0.7658030986785889
+    - 4.197125235805288e-06
+    - -6.158588803373277e-06
+    - 0.6430752873420715
+  scale: 1.0
+  visual:
+    path: object/072-c_toy_airplane/textured.obj

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/legacy/__init__.py

@@ -0,0 +1,27 @@
+
+import os
+
+# Get the path to the envs directory
+ENVS_DIR = os.path.dirname(os.path.abspath(__file__))
+# Get the path to the assets directory
+ASSETS_DIR = os.path.join(ENVS_DIR, "assets")
+
+# You might also want to add specific asset paths
+ROBOT_ASSETS_DIR = os.path.join(ASSETS_DIR, "robot")
+
+# Helper function to get specific asset paths
+def get_asset_path(*paths):
+    """
+    Get the full path to an asset file or directory
+    Args:
+        *paths: Path components to join with the assets directory
+    Returns:
+        str: Full path to the asset
+    """
+    return os.path.join(ASSETS_DIR, *paths)
+
+# Export the environment classes
+from . import random_obstacle_reach_env
+from . import object_pick_env
+# from . import scene_generator_env
+from . import shelf_env

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/legacy/object_pick_env.py

@@ -0,0 +1,426 @@
+import sapien.core as sapien
+from sapien.core import Pose
+
+import os
+import numpy as np
+from collections import OrderedDict
+from mani_skill.utils.structs.pose import vectorize_pose
+from mani_skill.utils.registration import register_env
+from msx_envs.legacy.random_obstacle_reach_env import RandomObstacleReachEnv
+import yaml
+from msx_envs.legacy import ENVS_DIR
+
+import trimesh
+import copy
+
+
+OBJECT_CONFIG_PATH = os.path.join(ENVS_DIR, "env_config")
+@register_env("CustomizedPick-v0", max_episode_steps=500)
+class ObjectPickEnv(RandomObstacleReachEnv):
+    def __init__(self, *args, object_config_path=OBJECT_CONFIG_PATH, create_obstacle_point_cloud=True, **kwargs):
+        # Set these attributes before calling super().__init__
+        self.create_obstacle_point_cloud = create_obstacle_point_cloud
+        self.obstacle_point_cloud = None  # Initialize as None instead of empty list or array
+        
+        # Get all yaml files from object_config_path
+        self.object_config_files = []
+        for file in os.listdir(object_config_path):
+            if file.endswith('.yaml') or file.endswith('.yml'):
+                self.object_config_files.append(os.path.join(object_config_path, file))
+        
+        self.current_config_index = 0  # Add counter
+        
+        super().__init__(*args, **kwargs)
+        
+        # These can be set after super().__init__
+        self.goal_thresh = 0.02
+        self.min_goal_dist = 0.4
+
+    def get_next_object_config(self):
+        """Load the next object configuration file and cycle back to the beginning if at the end."""
+        if not self.object_config_files:
+            raise ValueError("No object configuration files found")
+            
+        with open(self.object_config_files[self.current_config_index], 'r') as f:
+            config = yaml.safe_load(f)
+            # # print("file name: ", self.object_config_files[self.current_config_index])
+
+        self.object_path_prefix = os.path.join(ENVS_DIR, "assets")    
+        # Update index for next time, cycling back to 0 if we reach the end
+        self.current_config_index = (self.current_config_index + 1) % len(self.object_config_files)
+        
+        return config
+
+    def _load_actors(self):
+        self._add_ground(render=self.bg_name is None, altitude=-0.8)
+        self.goal_site = self._build_sphere_site(radius=0.01)
+        
+        # Clear previous obstacles
+        self.obstacles = []
+        obstacle_points = []  # Rename for clarity
+        self.primary_objects_ids = []
+        
+        # Create YCB objects from config first
+        object_configs = self.get_next_object_config()
+        ycb_points = self._create_ycb_objects(object_configs)  # Capture returned points
+        
+        # Process each obstacle configuration
+        for obstacle_config in self.obstacle_configs:
+            obstacle_type = obstacle_config.get('type', 'box')
+            if obstacle_type == 'box':
+                obstacle, points = self._create_box_obstacle(obstacle_config)
+            elif obstacle_type == 'sphere':
+                obstacle, points = self._create_sphere_obstacle(obstacle_config)
+            elif obstacle_type == 'mesh':
+                obstacle, points = self._create_mesh_obstacle(obstacle_config)
+            else:
+                raise ValueError(f"Unsupported obstacle type: {obstacle_type}")
+            
+            self.obstacles.append(obstacle)
+            obstacle_points.append(points)
+        
+        # Combine both sources of point clouds
+        point_cloud_sources = []
+        if obstacle_points:
+            point_cloud_sources.append(np.vstack(obstacle_points))
+        if ycb_points is not None:
+            point_cloud_sources.append(ycb_points)
+            
+        if point_cloud_sources:
+            self.obstacle_point_cloud = np.vstack(point_cloud_sources)
+        else:
+            self.obstacle_point_cloud = np.array([])
+
+    def _create_point_cloud_from_mesh(self, mesh_path, scale, obj_config):
+        # Load the mesh and get the geometry if it's a scene
+        loaded = trimesh.load(mesh_path)
+        if isinstance(loaded, trimesh.Scene):
+            # Get the first mesh from the scene
+            mesh = next(iter(loaded.geometry.values()))
+        else:
+            mesh = loaded
+        
+        # Scale the mesh if needed
+        if not np.allclose(scale, 1.0):
+            mesh.apply_scale(scale)
+        # Sample points from the mesh surface
+        # points, _ = trimesh.sample.sample_surface(mesh, 200)  # Sample points from mesh surface
+        # volume = mesh.volume
+        bbox = mesh.bounding_box
+        volume = bbox.volume
+        n_points = max(900, int(volume * 10000))            
+
+        # Sample surface points
+        surface_points, _ = trimesh.sample.sample_surface(mesh, n_points)
+        points = surface_points
+        
+        # Transform points to world coordinates using object's pose
+        obj_pos = np.array(obj_config['pose']['position'])
+        obj_quat = np.array(obj_config['pose']['quaternion'])
+        # Create transformation matrix
+        transform = trimesh.transformations.quaternion_matrix(obj_quat)
+        transform[:3, 3] = obj_pos
+        # Apply transformation to points
+        points = trimesh.transform_points(points, transform)
+        
+        ### debug for max object height
+        # Get the maximum z-coordinate from the transformed points
+        max_z = np.max(points[:, 2]) if points.size > 0 else 0
+        total_height = max_z  # Store the maximum height of this object
+        self.max_object_height = max(self.max_object_height, total_height)
+        # # print("object height: ", total_height)
+        return points
+    
+    def _create_ycb_objects(self, object_configs):
+        self.ycb_objects = {}
+        all_ycb_points = []
+        self.max_object_height = 0
+        for obj_config in object_configs['objects']:
+            builder = self._scene.create_actor_builder()
+            
+            # Handle scale that can be either float or list
+            scale = obj_config['scale']
+            if isinstance(scale, (int, float)):
+                scale = [float(scale)] * 3
+            
+            # Add visual mesh if specified
+            if 'visual' in obj_config:
+                builder.add_visual_from_file(
+                    filename=os.path.join(self.object_path_prefix, obj_config['visual']['path']),
+                    scale=scale
+                )
+            
+            # Add collision mesh (required)
+            collision_config = obj_config['collision']
+            collision_path = os.path.join(self.object_path_prefix, collision_config['path'])
+            
+            # Check if the path is a directory containing multiple obj files
+            if os.path.isdir(collision_path):
+                collision_paths = [os.path.join(collision_path, f) for f in os.listdir(collision_path) 
+                                  if f.endswith('.obj')]
+            else:
+                collision_paths = [collision_path]
+            
+            # Create point cloud using trimesh if required
+            if self.create_obstacle_point_cloud:
+                for collision_path in collision_paths:
+                    points = self._create_point_cloud_from_mesh(collision_path, scale, obj_config)
+                    # # print("object name: ", obj_config['name'])
+                    # # print("object points size: ", points.shape)
+                    all_ycb_points.append(points)  # Append transformed points
+            
+            ###################
+            for collision_path in collision_paths:
+                builder.add_multiple_collisions_from_file(
+                    filename=collision_path,
+                    scale=scale,
+                    material=None,
+                    density=collision_config.get('density', 1000),
+                )
+            ###################
+            
+            # Build actor as static or dynamic based on config
+            if obj_config.get('static', True):
+                obj = builder.build_static(obj_config['name'])
+                # print(obj_config['name'], " is static")
+            else:
+                obj = builder.build(obj_config['name'])
+                # print(obj_config['name'], " is dynamic")
+            
+            # Set pose from config
+            obj.set_pose(Pose(
+                obj_config['pose']['position'],
+                obj_config['pose']['quaternion']
+            ))
+            
+            if obj.name == "table": # TODO, send this by variable
+                self.primary_objects_ids.append(obj.id)
+            
+            # Store reference to object and its point cloud
+            setattr(self, f"ycb_object_{obj_config['name']}", obj)
+            self.ycb_objects[obj_config['name']] = {
+                'actor': obj,
+                'points': points,
+                'position': np.array(obj_config['pose']['position']),
+                'quaternion': np.array(obj_config['pose']['quaternion'])
+            }
+        
+        # Return the point cloud instead of setting it directly
+        if all_ycb_points:
+            return np.vstack(all_ycb_points)
+        return None
+
+    # def _initialize_task(self, max_trials=100, verbose=False):
+    #     initial_qpos = np.array([0.0, -0.3, 0, -np.pi*2/3, 0, np.pi / 2, np.pi / 4, 0.05, 0.05])
+    #     joint_states = None
+    #     # Sample a goal position far enough from robot start point
+    #     found_valid_goal = False
+    #     while not found_valid_goal:
+    #         for i in range(max_trials):
+    #             goal_x = self._episode_rng.uniform(0.2, 0.7)
+    #             goal_y = self._episode_rng.uniform(-0.5, 0.5)
+    #             # goal_y = -0.5 #Concept
+    #             goal_z = self._episode_rng.uniform(0.2, 0.25)
+    #             goal_pos = np.hstack([goal_x, goal_y, goal_z])
+    #             if np.linalg.norm(goal_pos - self.tcp.pose.p) > self.min_goal_dist:
+    #                 if verbose:
+    #                     # print(f"Found a valid goal at {i}-th trial")
+    #                 break
+    #         base_quat = np.array([0, 1, 0, 0])  # Your original quaternion
+    #         #self._generate_perturbed_quaternion(base_quat)
+    #         goal_pose = sapien.Pose(goal_pos, base_quat)
+    #         with self.use_ee_controller() as ee_controller:
+    #             joint_states = ee_controller.compute_ik(goal_pose, 
+    #                                                 initial_qpos=initial_qpos)
+    #         if joint_states is not None:
+    #             self.goal_pos = goal_pos
+    #             self.goal_site.set_pose(Pose(self.goal_pos))
+    #             self.goal_rot = base_quat
+
+    #             # Backup current robot qpos before testing goal pose
+    #             current_qpos = self.agent.robot.get_qpos().copy()
+    #             # Temporarily set agent to goal pose joint state to check collision
+    #             joint_states = np.concatenate([joint_states, np.array([0.04, 0.04])])
+    #             self.agent.reset(joint_states)
+    #             self._scene.step()
+    #             collided = self._evaluate_collided(primary_objects_ids = self.primary_objects_ids)
+    #             # # print("!!!!!!! collision!!!!! give up goal!!!")
+    #             if collided is None:
+    #                 found_valid_goal = True
+    #                 # print("goal_pos: ", goal_pos)
+    #             # Restore the robot to its original position after collision check
+    #             self.agent.reset(current_qpos)
+    #             self._scene.step()
+    
+    def _initialize_task(self, max_trials=100, verbose=False):
+        initial_qpos = np.array([0.0, -0.3, 0, -np.pi*2/3, 0, np.pi / 2, np.pi / 4, 0.05, 0.05])
+        joint_states = None
+        # Sample a goal position far enough from robot start point
+        found_valid = False
+        current_qpos = self.agent.robot.get_qpos().copy()
+
+        while not found_valid:
+            for i in range(max_trials):
+                goal_x = self._episode_rng.uniform(0.2, 0.7)
+                goal_y = self._episode_rng.uniform(-0.5, 0.5)
+                # goal_y = -0.5 #Concept
+                goal_z = self._episode_rng.uniform(0.2, 0.25)
+
+                goal_pos = np.hstack([goal_x, goal_y, goal_z])
+                if np.linalg.norm(goal_pos - self.tcp.pose.p) > self.min_goal_dist:
+                    if verbose:
+                        pass
+                        # print(f"Found a valid goal at {i}-th trial")
+                    break
+
+            base_quat = np.array([0, 1, 0, 0])
+            #self._generate_perturbed_quaternion(base_quat)
+            goal_pose = sapien.Pose(goal_pos, base_quat)
+            found_valid, joint_states = self._check_robot_pose_valid(goal_pose, initial_qpos, current_qpos)
+            # print("goal qpos is: ", goal_pose, "valid?", found_valid)
+            
+        if found_valid:
+                self.goal_pos = goal_pos
+                self.goal_site.set_pose(Pose(self.goal_pos))
+                self.goal_rot = base_quat
+                qpos = np.concatenate([joint_states, np.array([0.04, 0.04])])
+                self.goal_joint_state = qpos
+                # print("goal qpos is: ", qpos)
+
+
+    def _initialize_agent(self):
+        """Initialize agent with uniform random joint positions."""
+        self.agent.set_control_mode(self._control_mode)
+        if self.robot_uid in ("panda", "pandasphere"):
+            ## IK
+            initial_qpos = np.array(
+                [1.0, -0.3, -0.29, -2.46, 0.2, 2.7, 0.11, 0.05, 0.05]
+            )
+            joint_states = None
+            found_valid_start = False
+            while not found_valid_start:
+                ##### RANDOM ENVIRONMENT #####
+                start_x = self._episode_rng.uniform(0.2, 0.5)
+                start_y =self._episode_rng.uniform(-0.6, 0.6)
+                start_z = self._episode_rng.uniform(0.2, 0.3) # for full observation
+
+                # ##### CONCEPT ENVIRONMENT #####
+                # if self._episode_rng.random() < 0.5:
+                #     start_x = self._episode_rng.uniform(0.2, 0.3)
+                # else:
+                #     start_x = self._episode_rng.uniform(0.5, 0.65)
+                # start_y = 0.55
+                # start_z = 0.25
+
+                start_pos = np.hstack([start_x, start_y, start_z])
+                # Create a sapien.Pose object using the position (keep default orientation)
+                start_pose = sapien.Pose(start_pos, [0, 1, 0, 0])
+                
+                found_valid_start, joint_states = self._check_robot_pose_valid(start_pose, initial_qpos)
+                if found_valid_start:
+                    # print("found valid start pose: ", start_pose)
+                    qpos = np.concatenate([joint_states, np.array([0.04, 0.04])])
+                    self.agent.reset(qpos)
+                    break
+
+            self.agent.robot.set_pose(Pose([0, 0, 0])) # set base pose
+        else:
+            raise NotImplementedError(self.robot_uid)
+        
+    
+    def _check_robot_pose_valid(self, robot_pose, initial_qpos, current_qpos = None):
+        # get controller and ik from agent
+        robot_pose_valid = False
+        with self.use_ee_controller() as ee_controller:
+            joint_states = ee_controller.compute_ik(robot_pose, 
+                                                    initial_qpos=initial_qpos)
+        
+        if joint_states is not None:
+            # print("start joint states before collision checking: ", joint_states)
+            qpos = joint_states
+            qpos = np.concatenate([joint_states, np.array([0.04, 0.04])])
+            self.agent.reset(qpos)# warning: potential issue here, we change the joint state of the agent
+            self._scene.step()
+            collided = self._evaluate_collided(primary_objects_ids = self.primary_objects_ids)
+            if collided is None:
+                robot_pose_valid = True
+                # # print("start_pos: ", robot_pose)
+        if current_qpos is not None:
+            self.agent.reset(current_qpos)# change it back to the original qpos
+        else:
+            self.agent.reset(initial_qpos)# change it back to the original qpos
+        self._scene.step()
+        return (robot_pose_valid, joint_states if robot_pose_valid else None)
+    
+    def _get_obs_extra(self) -> OrderedDict:
+        collided = self._evaluate_collided(primary_objects_ids = self.primary_objects_ids)
+        obs = OrderedDict(
+            tcp_pose=vectorize_pose(self.tcp.pose),
+            goal_pos=self.goal_pos,
+            goal_pose=np.concatenate([self.goal_pos, self.goal_rot]),
+            goal_qpos=self.goal_joint_state,
+            collision = False if collided is None else True,
+        )
+        if self._obs_mode in ["state", "state_dict"]:
+            obs.update(
+                tcp_to_goal_pos=self.goal_pos - self.tcp.pose.p,
+            )
+        if self.create_obstacle_point_cloud:
+            # # # print("obstacle_point_cloud is: ", self.obstacle_point_cloud.shape)
+            obs.update({
+                'obstacle_point_cloud': self.obstacle_point_cloud
+            })
+        return obs
+        
+    def evaluate(self, **kwargs):
+        is_obj_placed = self.check_obj_placed()
+        is_robot_static = self.check_robot_static()
+        return dict(
+            is_obj_placed=is_obj_placed,
+            is_robot_static=is_robot_static,
+            success=is_obj_placed and is_robot_static,
+        )
+    
+    def _evaluate_collided(self, primary_objects_ids: list[int]):
+        """Acertain if the robot gripper collided with another object that is not one of the targets."""
+        def robot_actor_contact_info(robot_id_and_primary_object_blacklist: set[str], robot_links, contact: sapien.Contact):
+            for robot_link in robot_links:
+                # Get collision between the robot and an object that is not the robot or a primary manipulation object.
+                collided = (
+                    (robot_link == contact.actor0.id or robot_link == contact.actor1.id)
+                    and (
+                        (contact_obj := contact.actor0).id not in robot_id_and_primary_object_blacklist
+                        or (contact_obj := contact.actor1).id not in robot_id_and_primary_object_blacklist
+                    )
+                )
+                # # TODO: a temporary fix for the table collision
+                # if robot_link == (10 or 11 or 12) and contact_obj.name == "table":
+                #     collided = True
+                if collided:
+                    # # # print("collided: ", collided, "robot_link: ", robot_link, "contact_obj: ", contact_obj.name)
+
+                    return collided, robot_link, contact_obj.name
+            return False, None, None
+        # contact pairs
+        contacts = self._scene.get_contacts()
+        # blacklist of objects that the robot should not check against
+        blacklist = set(self.agent.robot_link_ids)
+        blacklist.update(primary_objects_ids)
+        # robot links filtering out the links that are the robot's connection with the arena floor
+        checked_robot_links = set([l.id for l in self.agent.robot.get_links() if "wheel" not in l.name])
+        for contact in contacts:
+            collided, robot_link, obj_id = robot_actor_contact_info(blacklist, checked_robot_links, contact)
+            if collided:
+                return f"{obj_id}:{robot_link}"
+        return None
+    
+    def _evaluate_grasped_wrong_target(self):
+        """Acertain if the robot grasped an object that is not the target."""
+        grasped_target = self.agent.check_grasp(self._get_primary_object(), max_angle=30)
+        if grasped_target:
+            return 'target'
+        for obj, _ in self._placed_objects:
+            if obj.name != self._get_primary_object().name:
+                if self.agent.check_grasp(obj, max_angle=30):
+                    return 'wrong_target'
+        return None

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/legacy/object_pick_env.yaml

@@ -0,0 +1,21 @@
+objects:
+  - name: table
+    visual:
+      path: /home/xuan/Code/maniskill2_benchmark/cfdp/envs/assets/object/table/desktable_shifted.glb
+    collision:
+      path: "/home/xuan/Code/maniskill2_benchmark/cfdp/envs/assets/object/table/desktable_shifted.obj"  # same as visual in this case
+    scale: [2.0, 1.0, 1.5]
+    pose:
+      position: [0.4, 0, 0]
+      quaternion: [0, 0, 0.7071068, 0.7071068]
+  
+  - name: object_banana
+    visual:
+      path: /home/xuan/Code/maniskill2_benchmark/cfdp/envs/assets/object/011_banana/textured.obj
+    collision:
+      path: /home/xuan/Code/maniskill2_benchmark/cfdp/envs/assets/object/011_banana/collision.obj
+    scale: [1.0, 1.0, 1.0]
+    pose:
+      position: [0.5, 0.2, 0.1]
+      quaternion: [1, 0, 0, 0]
+  

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/legacy/random_obstacle_reach_env.py

@@ -0,0 +1,482 @@
+from collections import OrderedDict
+
+import numpy as np
+import sapien.core as sapien
+from sapien.core import Pose
+from transforms3d.euler import euler2quat
+import copy
+import torch
+
+import trimesh
+
+from mani_skill.utils.registration import register_env
+from mani_skill.envs.scenes.base_env import SceneManipulationEnv
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils.sapien_utils import (
+    look_at,
+)
+from mani_skill.utils.structs.pose import vectorize_pose
+from contextlib import contextmanager
+
+#This environment aims to collect classical motion planning data
+@register_env("RandomObstacleReach-v0", max_episode_steps=200)
+class RandomObstacleReachEnv(SceneManipulationEnv):
+    goal_thresh = 0.025
+    min_goal_dist = 0.3
+
+    def __init__(self, *args, obj_init_rot_z=True, obstacle_configs=None, **kwargs):
+        self.obj_init_rot_z = obj_init_rot_z
+        self.cube_half_size = np.array([0.02] * 3, np.float32)
+        self.obstacle_configs = obstacle_configs if obstacle_configs else []
+        self.obstacle_point_cloud = None
+        self.obstacles = []
+        super().__init__(*args, **kwargs)
+    
+    @contextmanager
+    def use_ee_controller(self):
+        if self._control_mode != "pd_ee_target_delta_pos":
+            self.agent.set_control_mode("pd_ee_target_delta_pos")
+        ee_controller = self.agent.controller.controllers['arm']
+        try:
+            yield ee_controller
+        finally:
+            self.agent.set_control_mode(self._control_mode)
+
+    def _load_actors(self):
+        self._add_ground(render=self.bg_name is None)
+        self.goal_site = self._build_sphere_site(radius=0.01)
+        self.obstacle_point_cloud = None
+        
+        # Clear previous obstacles
+        self.obstacles = []
+        all_points = []
+        if (self._episode_rng.random() < 0.1):
+            print("Randomly skipping obstacle generation for this episode")
+            return
+        else:
+            print("Generating obstacles")
+
+        # # Random chance to skip adding obstacles
+        # if hasattr(self, '_episode_rng'):
+        #     # Use the environment's RNG if available
+        #     skip_obstacles = self._episode_rng.random() < 0.3  # 30% chance to skip obstacles
+        # else:
+        #     # Fallback to numpy's global RNG
+        #     skip_obstacles = np.random.random() < 0.3
+            
+        # if skip_obstacles:
+        #     print("Randomly skipping obstacle generation for this episode")
+        #     self.obstacle_configs = []
+        # Process each obstacle configuration
+        for obstacle_config in self.obstacle_configs:
+            obstacle_type = obstacle_config.get('type', 'box')
+            if obstacle_type == 'box':
+                obstacle, points = self._create_box_obstacle(obstacle_config)
+            elif obstacle_type == 'sphere':
+                obstacle, points = self._create_sphere_obstacle(obstacle_config)
+            elif obstacle_type == 'mesh':
+                obstacle, points = self._create_mesh_obstacle(obstacle_config)
+            else:
+                raise ValueError(f"Unsupported obstacle type: {obstacle_type}")
+            
+            self.obstacles.append(obstacle)
+            all_points.append(points)
+            
+        if all_points:
+            new_points = np.vstack(all_points)
+            if self.obstacle_point_cloud is None:
+                self.obstacle_point_cloud = new_points
+            else:
+                self.obstacle_point_cloud = np.vstack([self.obstacle_point_cloud, new_points])
+
+    def _create_box_obstacle(self, config):
+        obstacle = self._build_box(
+            half_size=config['half_size'],
+            color=config.get('color', (1, 0, 0)),
+            name=config.get('name', 'box_obstacle'),
+            static=True
+        )
+        obstacle.set_pose(sapien.Pose(config['pose'], [1,0,0,0]))
+        
+        # Generate point cloud
+        box = trimesh.creation.box(np.array(config['half_size']) * 2)
+        points, _ = trimesh.sample.sample_surface(box, config.get('n_points', 500))
+        points += config['pose'][:3]
+        
+        return obstacle, points
+
+    def _create_sphere_obstacle(self, config):
+        radius = config['radius']
+        builder = self._scene.create_actor_builder()
+        builder.add_sphere_collision(radius=radius)
+        
+        material = self._renderer.create_material()
+        material.set_base_color(np.hstack([config.get('color', (1, 0, 0)), 1.0]))
+        
+        builder.add_sphere_visual(
+            radius=radius,
+            material=material
+        )
+        obstacle = builder.build_static(config.get('name', 'sphere_obstacle'))
+        obstacle.set_pose(sapien.Pose(config['pose']))
+        
+        # Generate point cloud
+        sphere = trimesh.creation.icosphere(radius=radius)
+        points, _ = trimesh.sample.sample_surface(sphere, config.get('n_points', 500))
+        points += config['pose'][:3]
+        
+        return obstacle, points
+
+    def _create_mesh_obstacle(self, config):
+        raise NotImplementedError("create_mesh_obstacle method needs to be implemented")
+        mesh_path = config['mesh_path']
+        scale = config.get('scale', 1.0)
+        
+        # Load mesh using trimesh
+        mesh = trimesh.load(mesh_path)
+        if scale != 1.0:
+            mesh.apply_scale(scale)
+        
+        # Create SAPIEN actor
+        builder = self._scene.create_actor_builder()
+        builder.add_mesh_collision_from_file(mesh_path, scale=scale)
+        builder.add_visual_from_file(
+            mesh_path,
+            material=self._renderer.create_material(
+                base_color=np.hstack([config.get('color', (1, 0, 0)), 1.0])
+            ),
+            scale=scale
+        )
+        obstacle = builder.build_static(config.get('name', 'mesh_obstacle'))
+        obstacle.set_pose(sapien.Pose(config['pose']))
+        
+        # Generate point cloud
+        points, _ = trimesh.sample.sample_surface(mesh, config.get('n_points', 500))
+        points += config['pose'][:3]
+        
+        return obstacle, points
+
+    def _build_box(
+        self,
+        half_size,
+        color=(1, 0, 0),
+        name="box",
+        static=False,
+        render_material = None,
+    ):
+        if render_material is None:
+            render_material = self._renderer.create_material()
+            render_material.set_base_color(np.hstack([color, 1.0]))
+
+        builder = self._scene.create_actor_builder()
+        builder.add_box_collision(half_size=half_size)
+        builder.add_box_visual(half_size=half_size, material=render_material)
+        if static:
+            return builder.build_static(name)
+        else:
+            return builder.build(name)
+
+    def _generate_perturbed_quaternion(self, base_quat, max_angle_deviation=0.05):
+        """Generate a quaternion that's slightly different from the base quaternion.
+        
+        Args:
+            base_quat: Base quaternion [w, x, y, z]
+            max_angle_deviation: Maximum angle deviation in radians (default: 0.05 ≈ 2.9 degrees)
+        
+        Returns:
+            Perturbed quaternion as numpy array
+        """
+        # Ensure base_quat is properly formatted and normalized
+        if len(base_quat) != 4:
+            base_quat = np.array([1., 0., 0., 0.])
+        else:
+            base_quat = base_quat / np.linalg.norm(base_quat)
+        
+        # Generate smaller random rotation
+        angle = self._episode_rng.uniform(-max_angle_deviation, max_angle_deviation)
+        
+        # Generate random axis biased towards the original orientation
+        random_axis = self._episode_rng.normal(0, 0.1, 3)  # Smaller standard deviation
+        random_axis = random_axis / np.linalg.norm(random_axis)
+        
+        # Create quaternion for small rotation
+        s = np.cos(angle/2)
+        v = random_axis * np.sin(angle/2)
+        delta_quat = np.array([s, v[0], v[1], v[2]])
+        
+        # Multiply quaternions (quaternion composition)
+        w1, x1, y1, z1 = base_quat
+        w2, x2, y2, z2 = delta_quat
+        result_quat = np.array([
+            w1*w2 - x1*x2 - y1*y2 - z1*z2,
+            w1*x2 + x1*w2 + y1*z2 - z1*y2,
+            w1*y2 - x1*z2 + y1*w2 + z1*x2,
+            w1*z2 + x1*y2 - y1*x2 + z1*w2
+        ])
+        
+        # Normalize the resulting quaternion
+        return result_quat / np.linalg.norm(result_quat)
+    
+    ### Shelf Initialization ###
+    def _initialize_agent(self):
+        """Initialize agent with uniform random joint positions."""
+        # create a ee controller and use it for ik computation
+        self.agent.set_control_mode(self._control_mode)
+        if np.random.random() < 0.5:   
+            # set the control mode to pd_ee_pose to get IK solution
+            # self.agent.set_control_mode("pd_ee_target_delta_pos")
+            # controller = self.agent.controller.controllers['arm'] # has to be ee_controller
+            initial_qpos = np.array([1.0, 1.49, -1.78, -1.42, 0.50, 2.74, 1.77, 0.05, 0.05])
+            joint_states = None
+            while joint_states is None:
+                start_x = self._episode_rng.uniform(0.2, 0.7)
+                start_y =  self._episode_rng.uniform(-0.5, 0.5)
+                start_z = self._episode_rng.uniform(0.05, 0.80)
+                start_pos = np.hstack([start_x, start_y, start_z])
+                start_pose = sapien.Pose(start_pos, [0, 1, 0, 0])
+                with self.use_ee_controller() as ee_controller:
+                    joint_states = ee_controller.compute_ik(start_pose, 
+                                                    initial_qpos=initial_qpos)
+                if joint_states is not None:
+                    qpos = joint_states
+            qpos = np.concatenate([qpos, np.array([0.04, 0.04])])
+            self.agent.reset(qpos)
+            self.agent.robot.set_pose(Pose([0, 0, 0])) # set base pose
+        else:
+            print("Initializing agent with fixed joint positions")
+            qpos = np.array([0.0, 0, 0, -np.pi * 2 / 3, 0, np.pi * 2 / 3, np.pi / 4, 0.04, 0.04])
+            # Define noise ranges for each joint (7 joints)
+            joint_noise_ranges = [
+                (-np.pi/2, np.pi/2),    # joint 1
+                (-np.pi/5, np.pi/5),    # joint 2
+                (-0.01, 0.01),    # joint 3
+                (-0.01, 0.01),    # joint 4
+                (-0.01, 0.01),    # joint 5
+                (-0.01, 0.01),    # joint 6
+                (-0.01, 0.01),    # joint 7
+            ]
+            # Apply random noise to each joint individually
+            for i, (low, high) in enumerate(joint_noise_ranges):
+                qpos[i] += self._episode_rng.uniform(low=low, high=high)
+
+        self.agent.reset(qpos)
+        self.agent.robot.set_pose(Pose([0, 0, 0])) # set base pose        
+
+    def _initialize_task(self, max_trials=100, verbose=False):
+        initial_qpos = np.array([0.20, 1.49, -1.78, -1.42, 0.50, 2.74, 1.77, 0.05, 0.05])
+        joint_states = None
+        # Sample a goal position far enough from robot start point
+        while joint_states is None:
+            for i in range(max_trials):
+                goal_x = self._episode_rng.uniform(0.2, 0.7)
+                goal_y = self._episode_rng.uniform(-0.65, 0.65)
+                goal_z = self._episode_rng.uniform(0.05, 0.80)
+                goal_pos = np.hstack([goal_x, goal_y, goal_z])
+                if np.linalg.norm(goal_pos - self.tcp.pose.p) > self.min_goal_dist:
+                    if verbose:
+                        print(f"Found a valid goal at {i}-th trial")
+                    break
+            base_quat = np.array([0.5, 0.5, -0.5, 0.5])  # Your original quaternion
+            #self._generate_perturbed_quaternion(base_quat)
+            goal_pose = sapien.Pose(goal_pos, base_quat)
+            with self.use_ee_controller() as ee_controller:
+                joint_states = ee_controller.compute_ik(goal_pose, 
+                                                    initial_qpos=initial_qpos)
+            if joint_states is not None:
+                self.goal_pos = goal_pos
+                self.goal_site.set_pose(Pose(self.goal_pos))
+                self.goal_rot = base_quat
+      
+    def _initialize_actors(self):
+        pass
+
+    # Normal pick and place
+    # def _initialize_agent(self):
+    #     """Initialize agent with uniform random joint positions."""
+    #     if np.random.random() < 0.5:
+    #         original_agent_control_mode = self._control_mode # back up the original control mode
+    #         # set the control mode to pd_ee_pose to get IK solution
+    #         self.agent.set_control_mode("pd_ee_target_delta_pos")
+    #         controller = self.agent.controller.controllers['arm'] # has to be ee_controller
+    #         initial_qpos = np.array(
+    #                 [0.0, -0.1, 0, -np.pi*2/3, 0, np.pi / 2, np.pi / 4, 0.04, 0.04]
+    #             )
+    #         joint_states = None
+    #         while joint_states is None:
+    #             start_x = self._episode_rng.uniform(0.1, 0.9)
+    #             start_y = self._episode_rng.uniform(-0.7, 0.7)
+    #             start_z = self._episode_rng.uniform(0.1, 0.5)
+    #             start_pos = np.hstack([start_x, start_y, start_z])
+    #             start_pose = sapien.Pose(start_pos, [0, 1, 0, 0])
+    #             joint_states = controller.compute_ik(start_pose, 
+    #                                                 initial_qpos=initial_qpos)
+    #             if joint_states is not None:
+    #                 qpos = joint_states
+    #         qpos = np.concatenate([qpos, np.array([0.04, 0.04])])
+    #         self.agent.reset(qpos)
+    #         self.agent.robot.set_pose(Pose([0, 0, 0])) # set base pose
+    #         self.agent.set_control_mode(original_agent_control_mode)
+    #     else:
+    #         print("Initializing agent with fixed joint positions")
+    #         qpos = np.array([0.0, 0, 0, -np.pi * 2 / 3, 0, np.pi * 2 / 3, np.pi / 4, 0.04, 0.04])
+    #         # Define noise ranges for each joint (7 joints)
+    #         joint_noise_ranges = [
+    #             (-np.pi/2, np.pi/2),    # joint 1
+    #             (-np.pi/5, np.pi/5),    # joint 2
+    #             (-0.01, 0.01),    # joint 3
+    #             (-0.01, 0.01),    # joint 4
+    #             (-0.01, 0.01),    # joint 5
+    #             (-0.01, 0.01),    # joint 6
+    #             (-0.01, 0.01),    # joint 7
+    #         ]
+            
+    #         # Apply random noise to each joint individually
+    #         for i, (low, high) in enumerate(joint_noise_ranges):
+    #             qpos[i] += self._episode_rng.uniform(low=low, high=high)
+
+    #     self.agent.reset(qpos)
+    #     self.agent.robot.set_pose(Pose([0, 0, 0])) # set base pose
+
+    # def _initialize_task(self, max_trials=100, verbose=False):
+    #     original_agent_control_mode = self._control_mode # back up the original control mode
+    #     # set the control mode to pd_ee_pose to get IK solution
+    #     self.agent.set_control_mode("pd_ee_target_delta_pos")
+    #     controller = self.agent.controller.controllers['arm'] # has to be ee_controller
+    #     # initial_qpos = np.array(
+    #     #         [1.0, -0.3, -0.29, -2.46, 0.2, 2.7, 0.11, 0.05, 0.05]
+    #     #     )
+    #     initial_qpos = np.array([0.0, -0.3, 0, -np.pi*2/3, 0, np.pi / 2, np.pi / 4, 0.05, 0.05])
+    #     joint_states = None
+    #     # Sample a goal position far enough from robot start point
+    #     while joint_states is None:
+    #         for i in range(max_trials):
+    #             goal_x = self._episode_rng.uniform(0.1, 0.9)
+    #             goal_y = self._episode_rng.uniform(-0.65, 0.65)
+    #             goal_z = self._episode_rng.uniform(0.1, 0.3)
+    #             goal_pos = np.hstack([goal_x, goal_y, goal_z])
+    #             if np.linalg.norm(goal_pos - self.tcp.pose.p) > self.min_goal_dist:
+    #                 if verbose:
+    #                     print(f"Found a valid goal at {i}-th trial")
+    #                 break
+    #         base_quat = np.array([0, 1, 0, 0])  # Your original quaternion
+    #         #self._generate_perturbed_quaternion(base_quat)
+    #         goal_pose = sapien.Pose(goal_pos, base_quat)
+    #         joint_states = controller.compute_ik(goal_pose, 
+    #                                             initial_qpos=initial_qpos)
+    #         if joint_states is not None:
+    #             self.goal_pos = goal_pos
+    #             self.goal_site.set_pose(Pose(self.goal_pos))
+    #             self.goal_rot = base_quat
+        
+    #     self.agent.set_control_mode(original_agent_control_mode)
+
+    def _get_obs_extra(self, info) -> OrderedDict:
+        obs = OrderedDict(
+            tcp_pose=vectorize_pose(self.tcp.pose),
+            goal_pos=self.goal_pos,
+            goal_pose=np.concatenate([self.goal_pos, self.goal_rot]),
+        )
+        if self._obs_mode in ["state", "state_dict"]:
+            obs.update(
+                tcp_to_goal_pos=self.goal_pos - self.tcp.pose.p.numpy() if hasattr(self.tcp.pose.p, "numpy") else np.array(self.tcp.pose.p),
+            )
+        return obs
+
+    def check_obj_placed(self):
+        try:
+            return np.linalg.norm(self.goal_pos - self.tcp.pose.p) <= self.goal_thresh
+        except:
+            # raise RuntimeWarning("Failed to get robot tcp position")
+            return False
+
+    def check_robot_static(self, thresh=0.2):
+        # Assume that the last two DoF is gripper
+        qvel = self.agent.robot.get_qvel()[:-2]
+        if hasattr(qvel, "cpu"):  # torch.Tensor
+            qvel = qvel.detach().cpu().numpy()
+        return np.max(np.abs(qvel)) <= thresh
+
+    def evaluate(self, **kwargs):
+        if not hasattr(self, "goal_site"):
+            info = dict(
+            is_obj_placed=False,
+            is_robot_static=False,
+            success=False,
+        )
+        else:
+            is_obj_placed = self.check_obj_placed()
+            is_robot_static = self.check_robot_static()
+            info = dict(
+                is_obj_placed=is_obj_placed,
+                is_robot_static=is_robot_static,
+                success=is_obj_placed and is_robot_static,
+            )
+        info["success"] = torch.tensor([int(info["success"])], dtype=torch.bool, device="cpu")
+        return info
+
+    def compute_dense_reward(self, info, **kwargs):
+        # well it's not a dense reward so far
+        reward = 0.0
+
+        if info["success"]:
+            reward += 5
+            return reward
+        
+        return reward
+
+    def get_points_for_mp(self):
+        # return obstacle points
+        pass
+
+    def compute_normalized_dense_reward(self, **kwargs):
+        return self.compute_dense_reward(**kwargs) / 5.0
+
+    def render_human(self):
+        if not hasattr(self, "goal_site") or (self.goal_site is None):
+            return super().render_human()
+        self.goal_site.unhide_visual()
+        ret = super().render_human()
+        self.goal_site.hide_visual()
+        return ret
+
+    def render_rgb_array(self):
+        self.goal_site.unhide_visual()
+        ret = super().render_rgb_array()
+        self.goal_site.hide_visual()
+        return ret
+
+    def get_state(self) -> np.ndarray:
+        state = super().get_state()
+        return np.hstack([state, self.goal_pos])
+
+    def set_state(self, state):
+        self.goal_pos = state[-3:]
+        super().set_state(state[:-3])
+
+    def _register_cameras(self):
+        pose = look_at([1.3, 0.4, 0.8], [0.0, 0, 0.1])
+        return CameraConfig(
+            "base_camera", pose.p, pose.q, 128, 128, np.pi / 2, 0.01, 10
+        )
+
+    def _register_render_cameras(self):
+        if self.robot_uid in ("panda", "pandasphere"):
+            # pose = look_at([1.3, 0.4, 0.8], [0.0, 0.0, 0.4])
+            pose = look_at([2.0, 0.5, 0.6], [0, -0.1, 0.2])
+        else:
+            pose = look_at([0.5, 0.5, 1.0], [0.0, 0.0, 0.5])
+        return CameraConfig("render_camera", pose.p, pose.q, 1024, 1024, 1, 0.01, 15)
+
+    def _setup_viewer(self):
+        super()._setup_viewer()
+        self._viewer.set_camera_xyz(1.3, 0, 1.0)
+        self._viewer.set_camera_rpy(0, -0.5, 3.14)
+
+    def _build_sphere_site(self, radius, color=(0, 1, 0), name="goal_site"):
+        """Build a sphere site (visual only). Used to indicate goal position."""
+        builder = self.scene.create_actor_builder()
+        builder.add_sphere_visual(radius=radius, material=sapien.render.RenderMaterial(base_color=[0.8, 0.4, 0.3, 0.5]))
+        sphere = builder.build_static(name)
+        return sphere
+
+

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/legacy/scene_generator_env.py

@@ -0,0 +1,583 @@
+from collections import defaultdict
+from functools import partial
+import os
+import pathlib
+from typing import Callable, Final, Literal
+
+
+import numpy as np
+import json
+import sapien.core as sapien
+from transforms3d.euler import euler2quat
+from sapien.core import Pose
+from transforms3d.quaternions import qmult
+
+import yaml
+from mani_skill2 import format_path
+from mani_skill2.envs.sapien_env import BaseEnv
+from mani_skill2.utils.io_utils import load_json
+from mani_skill2.utils.geometry import get_axis_aligned_bbox_for_actor
+from mani_skill2.utils.registration import register_env
+from mani_skill2.sensors.camera import CameraConfig
+from mani_skill2.utils.sapien_utils import (
+    look_at,
+    vectorize_pose,
+)
+from cfdp.utils.object_placement import PlacementBounds, ObjectBoundingBox, find_valid_position_2d
+
+
+from cfdp.envs import assets
+from cfdp.envs.random_obstacle_reach_env import RandomObstacleReachEnv
+
+
+OUT_OF_BOUNDS: Final = np.array([0, 0, -900])
+OBJECTS_KEY = 'objects'
+
+@register_env(
+    "SceneGenerator-v0",
+    max_episode_steps=1,
+)
+class SceneGeneratorEnv(RandomObstacleReachEnv):
+    """This environment generates actors at runtime and outputs the new scene to a YAML config.
+
+    This config can be retrieved in info['gen_scene'] on reset.
+    """
+    def __init__(
+        self,
+        *args, 
+        distractor_count: int,
+        object_place_bounds: tuple[tuple[float, float], tuple[float, float], tuple[float]] | None = None,
+        asset_root=str(pathlib.Path(assets.__file__).parent),
+        base_object_config_path: str | pathlib.Path,
+        model_config="asset_tables.yaml",
+        scene_config_serialization_mode: Literal["yaml", "json", "dict"] = "yaml",
+        distractor_rotation_axes: tuple[bool, bool, bool] = (False, False, True),
+        minimum_object_aabb_separation=0.05, # this can be below 0
+        table_scale: list[float, float] = [1.0, 1.0],
+        **kwargs
+
+    ):
+        self.asset_root = asset_root
+        self.model_configs = model_config 
+        self.base_scene_config_path=base_object_config_path
+        self.table_scale = table_scale
+
+        model_db_path = self._get_asset_path(self.model_configs)
+        # Load object configurations before calling parent's __init__
+        with open(model_db_path, 'r') as f:
+            self.model_db = yaml.safe_load(f)
+
+        object_config_path = self._get_asset_path(self.base_scene_config_path)
+
+        # Load object configurations before calling parent's __init__
+        with open(object_config_path, 'r') as f:
+            self.base_object_configs = yaml.safe_load(f)
+        self.base_object_configs[OBJECTS_KEY] = _key_hierarchy_dict(self.base_object_configs[OBJECTS_KEY])
+
+        self._initial_actor_states = {}
+        self._distractor_count = distractor_count
+        self._object_place_bounds = object_place_bounds
+        self._minimum_object_aabb_separation = minimum_object_aabb_separation
+
+        self.scene_serializer_func: Callable[[str], dict]
+        if scene_config_serialization_mode == "json":
+            self.scene_serializer_func = partial(
+                json.dumps,
+                allow_nan=False,
+            )
+        elif scene_config_serialization_mode == "yaml":
+            self.scene_serializer_func = partial(
+                yaml.dump,
+                encoding='utf-8',
+                allow_unicode=True,
+                # sort_keys=False,
+                # default_flow_style=None,
+                # indent=4,
+                # width=120,
+            )
+        elif scene_config_serialization_mode == "dict":
+            # Just passthrough
+            self.scene_serializer_func = lambda d: d
+        else:
+            raise ValueError("Invalid serialization mode. Choose from 'json', 'yaml', or 'dict'")
+
+        self.new_distractors = []
+        self._generated_object_configs = {
+            OBJECTS_KEY: defaultdict(dict),
+        }
+        self._generated_object_configs[OBJECTS_KEY].update(self.base_object_configs[OBJECTS_KEY])
+        
+        self.ycb_objects: dict[str, sapien.Actor] = {}
+        self.obstacle_actors: dict[str, sapien.Actor] = {}
+        self.distractor_rotation_axes = distractor_rotation_axes
+
+        super().__init__(*args, **kwargs)
+        self.goal_thresh = 0.01
+        self.min_goal_dist = 0.2
+
+    def _get_asset_path(self, asset):
+        resolved_asset = format_path(asset)
+        return (
+            str(pathlib.Path(self.asset_root) / resolved_asset) 
+            if not os.path.isabs(asset) 
+            else resolved_asset
+        )
+    
+    def _settle(self, t):
+        # step the simulation and let the scene settle for t seconds
+        settle(self, t)
+
+    def _load_actors(self):
+        """Load actors only, state is set later in _initialize()."""
+        self._add_ground(render=self.bg_name is None, altitude=-0.8)
+        self.goal_site = self._build_sphere_site(radius=0.01)
+        
+        # Clear previous obstacles
+        self.obstacles = []
+        all_points = []
+
+        self._load_base_scene_actors()
+        self._load_new_obstacles()
+        self._load_new_ycb_distractors()
+        
+        # Process each obstacle configuration
+        for obstacle_config in self.obstacle_configs:
+            obstacle_type = obstacle_config.get('type', 'box')
+            if obstacle_type == 'box':
+                obstacle, points = self._create_box_obstacle(obstacle_config)
+            elif obstacle_type == 'sphere':
+                obstacle, points = self._create_sphere_obstacle(obstacle_config)
+            elif obstacle_type == 'mesh':
+                obstacle, points = self._create_mesh_obstacle(obstacle_config)
+            else:
+                raise ValueError(f"Unsupported obstacle type: {obstacle_type}")
+            
+            self.obstacles.append(obstacle)
+            all_points.append(points)
+            
+        if all_points:
+            self.obstacle_point_cloud = np.vstack(all_points)
+
+    def _initialize_actors(self):
+        """Initialize the actor state."""
+        super()._initialize_actors()
+
+        self._initialize_base_scene_actors()
+        if self._object_place_bounds is None:
+            # self._discover_table_bounds()
+            self._scale_table_bounds(scales=self.table_scale)
+        self._initialize_new_scene_actors()
+
+    def _discover_table_bounds(self):
+        """Discover the bounds of the table."""
+        bbox_min, bbox_max = get_axis_aligned_bbox_for_actor(self.ycb_objects['table'])
+        self._object_place_bounds = [bbox_min[:2].tolist(), bbox_max[:2].tolist(), [2]]
+
+    def _scale_table_bounds(self, scales: list[float] = [1.0, 1.0]):
+        """Scale the table bounds by the given factors.
+        
+        Args:
+            scales: Scale factors [scale_x, scale_y] for x and y dimensions
+        """
+        scale_x, scale_y = scales
+        bbox_min, bbox_max = get_axis_aligned_bbox_for_actor(self.ycb_objects['table'])
+        center_x = (bbox_max[0] + bbox_min[0]) / 2
+        center_y = (bbox_max[1] + bbox_min[1]) / 2
+        
+        half_width = (bbox_max[0] - bbox_min[0]) / 2
+        half_length = (bbox_max[1] - bbox_min[1]) / 2
+        
+        scaled_min = [
+            center_x - half_width * scale_x,
+            center_y - half_length * scale_y
+        ]
+        scaled_max = [
+            center_x + half_width * scale_x,
+            center_y + half_length * scale_y
+        ]
+        
+        self._object_place_bounds = [scaled_min, scaled_max, [2]]
+
+    def _set_env_ycb_obj_attr(self, name, obj):
+        setattr(self, f"ycb_object_{name}", obj)
+        self.ycb_objects[name] = obj
+    
+    def _set_env_obstacle_obj_attr(self, name, obj):
+        setattr(self, f"obstacle_object_{name}", obj)
+        self.obstacle_actors[name] = obj
+
+    def _load_actor_helper(self,
+        scene: sapien.Scene,
+        scale: float | tuple[float, float, float] | None = None,
+        physical_material: sapien.PhysicalMaterial = None,
+        density: float | None = None,
+        visual_mesh_path: str | None = None,
+        collision_mesh_path: str | None = None,
+    ):
+        """Load an actor from a model ID."""
+        builder = scene.create_actor_builder()
+
+        if isinstance(scale, (int, float)):
+            scale = (scale, scale, scale)
+        
+        if visual_mesh_path is not None:
+            obj_visual_path = self._get_asset_path(visual_mesh_path)
+            builder.add_visual_from_file(
+                filename=obj_visual_path, 
+                scale=scale
+            )
+        
+        obj_collision_path = self._get_asset_path(collision_mesh_path)
+        builder.add_multiple_collisions_from_file(
+            filename=obj_collision_path,
+            scale=scale,
+            material=physical_material,
+            density=density or 1000,
+        )
+
+        return builder
+
+    def _load_base_scene_actors(self):
+        for name, obj_config in self.base_object_configs[OBJECTS_KEY].items():
+            builder = self._load_actor_helper(
+                scene=self._scene,
+                scale = obj_config.get('scale', [1.0]*3),
+                visual_mesh_path=obj_config.get('visual', {}).get('path'),
+                collision_mesh_path = obj_config.get('collision', {}).get('path'),
+            )
+            # Build actor as static or dynamic based on config
+            if obj_config.get('static', True):
+                obj = builder.build_static(name)
+            else:
+                obj = builder.build(name)
+
+            # Set these object somewhere far away
+            # obj.set_pose(sapien.Pose(OUT_OF_BOUNDS))
+            self._set_env_ycb_obj_attr(name, obj)
+
+    def _load_new_ycb_distractors(self):
+        ycb_asset_table = self.model_db['ycb']
+        model_keys = list(ycb_asset_table.keys())
+        self.new_distractors = [
+            str(s) 
+            for s 
+            in self._episode_rng.choice(
+                model_keys, 
+                self._distractor_count, 
+                replace=False
+            )
+        ]
+
+        for name in self.new_distractors:
+            scale=ycb_asset_table[name].get('scale', 1.0)
+            visual_mesh_path=ycb_asset_table[name].get('visual_mesh_path')
+            collision_mesh_path=ycb_asset_table[name].get('collision_mesh_path')
+            builder = self._load_actor_helper(
+                scene=self._scene,
+                scale=scale,
+                visual_mesh_path=visual_mesh_path,
+                collision_mesh_path=collision_mesh_path,
+            )
+            obj = builder.build(name)
+            # Set these object somewhere far away
+            # obj.set_pose(sapien.Pose(OUT_OF_BOUNDS))
+            self._set_env_ycb_obj_attr(name, obj)
+
+            self._generated_object_configs[OBJECTS_KEY][name].update(
+                {
+                    'visual': {
+                        'path': visual_mesh_path,
+                    },
+                    'collision': {
+                        'path': collision_mesh_path,
+                    },
+                    'scale': scale,
+                }
+            )
+    
+    def _load_new_obstacles(self):
+        obstacle_asset_table = self.model_db['obstacles']
+        if obstacle_asset_table is None:
+            self.new_obstacles = []
+            return
+        model_keys = list(obstacle_asset_table.keys())
+        self.new_obstacles = [str(s) for s in model_keys]
+        
+        for name in self.new_obstacles:
+            # scale = [np.random.uniform(low=0.4, high=0.6),
+            #      np.random.uniform(low=0.4, high=0.7),
+            #      np.random.uniform(low=0.6, high=1.1)]
+            scale = [np.random.uniform(low=0.3, high=0.5),
+                 np.random.uniform(low=0.4, high=0.6),
+                 np.random.uniform(low=0.4, high=0.9)]
+            print("scale: ", scale)
+            scale=obstacle_asset_table[name].get('scale', scale)
+            visual_mesh_path=obstacle_asset_table[name].get('visual_mesh_path')
+            collision_mesh_path=obstacle_asset_table[name].get('collision_mesh_path')
+            builder = self._load_actor_helper(
+                scene=self._scene,
+                scale=scale,
+                visual_mesh_path=visual_mesh_path,
+                collision_mesh_path=collision_mesh_path,
+            )
+            obj = builder.build(name)
+            # Set these object somewhere far away
+            # obj.set_pose(sapien.Pose(OUT_OF_BOUNDS))
+            # self._set_env_ycb_obj_attr(name, obj)
+            self._set_env_obstacle_obj_attr(name, obj)
+
+            self._generated_object_configs[OBJECTS_KEY][name].update(
+                {
+                    'visual': {
+                        'path': visual_mesh_path,
+                    },
+                    'collision': {
+                        'path': collision_mesh_path,
+                    },
+                    'scale': scale,
+                }
+            )
+
+    def _initialize_base_scene_actors(self):
+        actors = {a.name: a for a in self.get_actors()}
+
+        for name, obj_config in self.base_object_configs[OBJECTS_KEY].items():
+            obj = actors.get(name)
+            assert isinstance(obj, (sapien.Actor, sapien.ActorStatic))
+            obj.set_pose(sapien.Pose(
+                obj_config['pose']['position'], 
+                obj_config['pose']['quaternion']
+            ))
+
+    def _initialize_new_scene_actors(self):
+        """Set the initial state of the newly generated objects."""
+        assert self._object_place_bounds is not None, f"Table bounds must be initialized."
+        placed_objects = [
+            (actor, ObjectBoundingBox(*(local_bbox_for_actor(actor=actor))))
+            for actor
+            in [self.ycb_objects[actor_name] for actor_name in self.base_object_configs[OBJECTS_KEY] if actor_name != 'table']
+        ]
+        placement_bounds=PlacementBounds(*self._object_place_bounds)
+
+        for actor_name in self.new_distractors:
+            actor = self.ycb_objects[actor_name]
+            actor.set_pose(sapien.Pose([100, 100, -50]))
+
+
+        placed_obstacles = [(actor, ObjectBoundingBox(*(local_bbox_for_actor(actor=actor)))) for actor in self.obstacle_actors.values()]
+        for obs_actor_name in self.new_obstacles:
+            obs_actor = self.obstacle_actors[obs_actor_name]
+            # Generate random yaw angle between -30 and 30 degrees
+            yaw = self._episode_rng.uniform(-np.pi/4, np.pi/4)
+            # Create quaternion with only yaw rotation
+            quat = euler2quat(0, 0, yaw)
+            obs_actor.set_pose(sapien.Pose(obs_actor.pose.p, quat))
+            bb_min, bb_max = local_bbox_for_actor(actor=obs_actor)
+            bbox = ObjectBoundingBox(bb_min, bb_max)
+            success = False
+            while not success:
+                valid_position_2d = find_valid_position_2d(
+                    placement_bounds=placement_bounds,
+                    actor=obs_actor,
+                    actor_local_bbox=bbox,
+                    placed_objects=placed_obstacles,
+                    rng=self._episode_rng,
+                    retries=5000, # worst case
+                    # minimum_aabb_separation=self._minimum_object_aabb_separation,
+                    minimum_aabb_separation=0.03,
+                )  
+                z = (- bb_min[2])
+                valid_position = np.hstack([valid_position_2d, z])
+                print(f"Valid position1: {valid_position}")
+                obs_actor.set_pose(sapien.Pose(valid_position, quat))
+                self._settle_distractor(distractor_obj=obs_actor, motion_lock_axes=(1, 1, 0, 1, 1, 1))
+                if obs_actor.pose.p[2] > 0 and obs_actor.pose.p[2] < 0.4: # if z is unnormal resample it
+                    success = True
+                    
+        for actor_name in self.new_distractors:
+            actor = self.ycb_objects[actor_name]
+            euler = np.random.uniform(low=-np.pi/2, high=np.pi/2, size=(3,))
+            euler = np.multiply(euler, np.array(self.distractor_rotation_axes, dtype=np.int8))
+            quat = euler2quat(*euler)
+            actor.set_pose(sapien.Pose(actor.pose.p, quat))
+            bb_min, bb_max = local_bbox_for_actor(actor=actor)
+            bbox = ObjectBoundingBox(bb_min, bb_max)
+            valid_position_2d = find_valid_position_2d(
+                placement_bounds=placement_bounds,
+                actor=actor,
+                actor_local_bbox=bbox,
+                placed_objects=placed_objects,
+                rng=self._episode_rng,
+                retries=1000, # worst case
+                minimum_aabb_separation=self._minimum_object_aabb_separation,
+            )
+            ground_level = 0
+            # Move up by the min z of the bounding box
+            z = ground_level + (- bb_min[2])
+            # just be lazy and give a little more height
+            z += 0.05
+            # If there is less than 0 separation we may want objects to be more likely to stack
+            if self._minimum_object_aabb_separation < 0:
+                z += 0.3
+            # valid_position = self._find_valid_position(placed_objects, distractor_model_id, distractor_model_scale, self._distractor_pos_random, retries=100000)
+            if valid_position_2d is None:
+                print(f"Warning: Default to placing randomly. Could not find a valid position for distractor {actor_name} after maximum attempts.")
+                valid_position_2d = placement_bounds.random_in(rng=self._episode_rng)
+                ## HACK: add extra height to hopefully stack up
+                z += 0.3
+            valid_position = np.hstack([valid_position_2d, z])
+            # Find a valid position
+            actor.set_pose(sapien.Pose(valid_position, actor.pose.q))
+            self._settle_distractor(distractor_obj=actor)
+
+            # get updated AABB
+            final_bbox = ObjectBoundingBox(*(local_bbox_for_actor(actor=actor)))
+            placed_objects = placed_objects + [(actor, final_bbox)]
+
+        # Unlock motion
+        for actor_name, actor in self.ycb_objects.items():
+            if isinstance(actor, sapien.ActorStatic):
+                continue
+            actor.lock_motion(0, 0, 0, 0, 0, 0)
+            actor.set_velocity(np.zeros(3))
+            actor.set_angular_velocity(np.zeros(3))
+            self._settle(0.5)
+
+        lin_vel, ang_vel = 0.0, 0.0
+        for actor_name, actor in self.ycb_objects.items():
+            if isinstance(actor, sapien.ActorStatic):
+                continue
+            lin_vel += np.linalg.norm(actor.velocity)
+            ang_vel += np.linalg.norm(actor.angular_velocity)
+        if lin_vel > 1e-3 or ang_vel > 1e-2:
+            self._settle(1.5)
+        
+        for obs_actor_name in self.new_obstacles:
+            obs_actor = self.obstacle_actors[obs_actor_name]
+            print("pose at the end: ", obs_actor.pose)
+        
+
+    def _serialize_actors(self) -> dict:
+        """Serialize the actors to a hierarchy.
+
+        This is useful for saving and loading the scene state. Example:
+        ```yaml
+        # yaml
+        objects:
+            -   name: table
+                visual:
+                    path: object/table/desktable.glb
+                collision:
+                    path: "object/table/desktable.obj"  # same as visual in this case
+                    scale: [2.0, 1.0, 1.5]
+                    pose:
+                        position: [0.4, 0, -0.75]
+                        quaternion: [0, 0, 0.7071068, 0.7071068]
+        ```
+        """
+        actors_dict = self._generated_object_configs.copy()
+        for actor_name, actor in self.ycb_objects.items():
+            actors_dict[OBJECTS_KEY][actor_name].update({
+
+                'pose': {
+                    'position': actor.pose.p.tolist(),
+                    'quaternion': actor.pose.q.tolist(),
+                }
+            })
+
+        for obstacle_name, obstacle in self.obstacle_actors.items():
+            actors_dict[OBJECTS_KEY][obstacle_name].update({
+                'pose': {
+                    'position': obstacle.pose.p.tolist(),
+                    'quaternion': obstacle.pose.q.tolist(),
+                }
+            })
+        # convert back to list version
+        actors_dict[OBJECTS_KEY] = _list_hierarchy_dict(actors_dict[OBJECTS_KEY])
+
+        return self.scene_serializer_func(actors_dict)
+
+
+    def reset(self, seed=None, options=None):
+        obs, info = super().reset(seed, options)
+        info['scene_config'] = self._serialize_actors()
+        return obs, info
+    
+    def _settle_distractor(
+        self,
+        distractor_obj: sapien.Actor,
+        motion_lock_axes=(1, 1, 0, 0, 0, 0),
+    ):
+        return settle_distractor(
+            env=self, 
+            distractor_obj=distractor_obj, 
+            t=0.5,
+            drop_height=0.5,
+            unlock_at_end=False,
+            motion_lock_axes=motion_lock_axes,
+        )
+    
+    def _initialize_agent(self):
+        """Higher EE pos."""
+        qpos = np.array(
+            [0.0, 0, 0, -np.pi * 2 / 3, 0, np.pi * 2 / 3, np.pi / 4, 0.04, 0.04]
+        )
+        # fmt: on
+        qpos[:-2] += self._episode_rng.normal(
+            0, self.robot_init_qpos_noise, len(qpos) - 2
+        )
+        self.agent.reset(qpos)
+        self.agent.robot.set_pose(Pose([0, 0, 0]))
+        #make the robot invisible
+        for actor in self.agent.robot.get_links():
+            actor.hide_visual()
+    
+    def _register_render_cameras(self):
+        if self.robot_uid == "panda":
+            # pose = look_at([1.3, 0.4, 0.8], [0.0, 0.0, 0.4])
+            # pose = look_at([-0.2, 0.0, 1.5], [0.4, 0.0, 0.0])# Top-down view
+            pose = look_at([2.0, 0.5, 0.6], [0, -0.1, 0.2]) #side view
+        return CameraConfig("render_camera", pose.p, pose.q, 1024, 1024, 1, 0.01, 10)
+
+def _list_hierarchy_dict(dict_obj: dict):
+    return [{'name': k, **v} for k, v in dict_obj.items() if isinstance(v, dict)]
+
+def _key_hierarchy_dict(list_obj: list, on_key: str = 'name'):
+    return {v[on_key]: v for v in list_obj if v.get(on_key) is not None}
+
+
+def settle_distractor(
+    env: BaseEnv,
+    distractor_obj: sapien.Actor,
+    t: float,
+    drop_height: float = 0.5,
+    unlock_at_end: bool = False,
+    motion_lock_axes: tuple[int, int, int, int, int, int] = (1, 1, 0, 1, 1, 0),
+    up: np.ndarray = np.array([0., 0., 1.]),
+):
+    drop = up * drop_height
+    distractor_obj.set_pose(sapien.Pose(distractor_obj.pose.p + drop, distractor_obj.pose.q))
+    distractor_obj.set_velocity(np.zeros(3))
+    distractor_obj.set_angular_velocity(np.zeros(3))
+    # Lock x and y and pitch and roll
+    assert len(motion_lock_axes) == 6, f"`{motion_lock_axes=}` must be a tuple of length 6"
+    distractor_obj.lock_motion(*motion_lock_axes)
+
+    # Let distractor objects fall onto the table
+    settle(env, t)
+
+    if unlock_at_end:
+        distractor_obj.lock_motion(*[0]*6)
+
+
+def settle(env: BaseEnv, t):
+    # step the simulation and let the scene settle for t seconds
+    sim_steps = int(env.sim_freq * t)
+    for _ in range(sim_steps):
+        env._scene.step()
+
+def local_bbox_for_actor(actor: sapien.Actor) -> tuple[np.ndarray, np.ndarray]:
+    mins, maxs = get_axis_aligned_bbox_for_actor(actor)
+    mins -= actor.pose.p
+    maxs -= actor.pose.p
+    return mins, maxs

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/legacy/shelf_env.py

@@ -0,0 +1,173 @@
+import sapien.core as sapien
+from sapien.core import Pose
+
+import os
+import numpy as np
+from collections import OrderedDict
+from mani_skill.utils.structs.pose import vectorize_pose
+from mani_skill.utils.registration import register_env
+from msx_envs.legacy.object_pick_env import ObjectPickEnv
+import yaml
+from msx_envs.legacy import ENVS_DIR
+
+import trimesh
+import copy
+
+OBJECT_CONFIG_PATH = os.path.join(ENVS_DIR, "env_config")
+@register_env("ShelfPick-v0", max_episode_steps=500)
+class ShelfPickEnv(ObjectPickEnv):
+    def __init__(self, *args, object_config_path=OBJECT_CONFIG_PATH, create_obstacle_point_cloud=True, is_demo = False, **kwargs):
+        
+        # Call super().__init__ after setting necessary attributes
+        self.is_demo = is_demo # set spefic start pose for demo, this variable is not existed in init function, but it calls initialze_episode
+        super().__init__(*args, object_config_path=object_config_path, create_obstacle_point_cloud=create_obstacle_point_cloud,**kwargs)
+        
+        # These can be set after super().__init__
+        self.goal_thresh = 0.02
+        self.min_goal_dist = 0.4
+        
+    def obtain_collision_spheres(self):
+        """Extract collision sphere information from all robot links.
+        
+        This method is a wrapper around the agent's obtain_collision_spheres method,
+        which returns a dictionary of collision spheres for each link in the robot.
+        
+        Returns:
+            dict: A dictionary mapping link names to lists of (position, radius) tuples,
+                 where position is the global 3D coordinates and radius is in meters.
+                 Format: {'link_name': [(np.array([x, y, z]), radius), ...]}
+        """
+        return self.agent.obtain_collision_spheres()
+
+    def _initialize_task(self, max_trials=100, verbose=False):
+        initial_qpos = np.array([0.20, 1.49, -1.78, -1.42, 0.50, 2.74, 1.77, 0.05, 0.05])
+        joint_states = None
+        # Sample a goal position far enough from robot start point
+        found_valid = False
+        current_qpos = self.agent.robot.get_qpos().copy()
+
+        if self.is_demo:
+            goal_x = self._episode_rng.uniform(0.45, 0.55)
+            goal_y = self._episode_rng.uniform(-0.4, -0.5)
+            goal_z = self._episode_rng.uniform(0.3, 0.4)
+            goal_pos = np.hstack([goal_x, goal_y, goal_z])
+            base_quat = np.array([0.5, 0.5, -0.5, 0.5])
+            goal_pose = sapien.Pose(goal_pos, base_quat)
+                    
+            # Check if this is a valid starting position
+            found_valid, joint_states = self._check_robot_pose_valid(goal_pose, initial_qpos, current_qpos)
+                
+            print(f"Valid task goal pose {goal_pose} joint_states: {joint_states}")
+
+        while not found_valid:
+            for i in range(max_trials):
+                ##### Shelf Environment #####
+                goal_x = self._episode_rng.uniform(0.4, 0.6)
+                goal_y = self._episode_rng.uniform(-0.5, -0.55)
+                goal_z = self._episode_rng.uniform(0.4, 0.6)
+
+                goal_pos = np.hstack([goal_x, goal_y, goal_z])
+                if np.linalg.norm(goal_pos - self.tcp.pose.p) > self.min_goal_dist:
+                    if verbose:
+                        print(f"Found a valid goal at {i}-th trial")
+                    break
+
+            base_quat = np.array([0.5, 0.5, -0.5, 0.5])
+            #self._generate_perturbed_quaternion(base_quat)
+            goal_pose = sapien.Pose(goal_pos, base_quat)
+            found_valid, joint_states = self._check_robot_pose_valid(goal_pose, initial_qpos, current_qpos)
+            print("goal qpos is: ", goal_pose, "valid?", found_valid)
+            
+        if found_valid:
+                self.goal_pos = goal_pos
+                self.goal_site.set_pose(Pose(self.goal_pos))
+                self.goal_rot = base_quat
+                qpos = np.concatenate([joint_states, np.array([0.04, 0.04])])
+                self.goal_joint_state = qpos
+                print("goal qpos is: ", qpos)
+
+    
+    def _initialize_agent(self):
+        # create a ee controller and use it for ik computation
+        self.agent.set_control_mode(self._control_mode)
+        initial_qpos = np.array(
+            [1.0, 1.49, -1.78, -1.42, 0.50, 2.74, 1.77, 0.05, 0.05]
+        )
+        
+        found_valid = False
+        if self.is_demo:
+            # In demo mode, position the robot above the Rubik's cube for grasping
+            for obj_name, obj_config in self.ycb_objects.items():
+                if obj_name == "rubiks_cube":
+                    # Get the cube's position and orientation
+                    obj_position = obj_config['position']
+                    obj_quaternion = obj_config['quaternion']
+                    
+                    # Position the robot above the cube with matching orientation
+                    start_position = obj_position.copy()
+                    start_position[2] += 0.15
+                    start_pose = sapien.Pose(start_position, [0, 1, 0, 0])
+                    
+                    # Check if this is a valid starting position
+                    found_valid, joint_states = self._check_robot_pose_valid(start_pose, initial_qpos)
+                    print(f"Valid starting position for {obj_name}: {found_valid}, joint_states: {joint_states}, start_pose: {start_pose}")
+                    
+        while not found_valid:
+            start_x = self._episode_rng.uniform(0.3, 0.35)
+            start_y =  self._episode_rng.uniform(0.2, 0.5)
+            start_z = self._episode_rng.uniform(0.3, 0.35) # for full observation
+
+            start_pos = np.hstack([start_x, start_y, start_z])
+            # Create a sapien.Pose object using the position (keep default orientation)
+            start_pose = sapien.Pose(start_pos, [0, 1, 0, 0])
+            
+            found_valid, joint_states = self._check_robot_pose_valid(start_pose, initial_qpos)
+            
+        if found_valid:
+            qpos = np.concatenate([joint_states, np.array([0.04, 0.04])])
+            self.agent.reset(qpos)# warning: potential issue here, we change the joint state of the agent
+        self.agent.robot.set_pose(Pose([0, 0, 0])) # set base pose
+    
+    def _get_obs_extra(self) -> OrderedDict:
+        collided = self._evaluate_collided(primary_objects_ids = self.primary_objects_ids)
+        obs = OrderedDict(
+            tcp_pose=vectorize_pose(self.tcp.pose),
+            goal_pos=self.goal_pos,
+            goal_pose=np.concatenate([self.goal_pos, self.goal_rot]),
+            goal_qpos=self.goal_joint_state,
+            collision = False if collided is None else True,
+        )
+        if self._obs_mode in ["state", "state_dict"]:
+            obs.update(
+                tcp_to_goal_pos=self.goal_pos - self.tcp.pose.p,
+            )
+        if self.create_obstacle_point_cloud:
+            # print("obstacle_point_cloud is: ", self.obstacle_point_cloud.shape)
+            obs.update({
+                'obstacle_point_cloud': self.obstacle_point_cloud
+            })
+        return obs
+
+
+    def _evaluate_collided(self, primary_objects_ids: list[int]):
+        """Acertain if the robot gripper collided with another object that is not one of the targets."""
+        def robot_actor_contact_info(robot_id_and_primary_object_blacklist: set[str], robot_links, contact: sapien.Contact):
+            for robot_link in robot_links:
+                # Get collision between the robot and an object that is not the robot or a primary manipulation object.
+                collided = (
+                    (robot_link == contact.actor0.id or robot_link == contact.actor1.id)
+                    and (
+                        (contact_obj := contact.actor0).id not in robot_id_and_primary_object_blacklist
+                        or (contact_obj := contact.actor1).id not in robot_id_and_primary_object_blacklist
+                    )
+                )
+
+                # # TODO: a temporary fix for the table collision
+                # if robot_link == (10 or 11 or 12) and contact_obj.name == "table":
+                #     collided = True
+                
+                if collided:
+                    print("collided: ", collided, "robot_link: ", robot_link, "contact_obj: ", contact_obj.name)
+
+                    return collided, robot_link, contact_obj.name
+            return False, None, None