Add files using upload-large-folder tool

.gitattributes

@@ -229,3 +229,85 @@ maniskill3_environment_assets/robots/dclaw/meshes/visual/link_2.glb filter=lfs d
 maniskill3_environment_assets/robots/dclaw/meshes/visual/base_link.glb filter=lfs diff=lfs merge=lfs -text
 maniskill3_environment_assets/environment_maps/default.hdr filter=lfs diff=lfs merge=lfs -text
 project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/_C.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/maniskill2-scene-2.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/sciurus17_description/meshes/collision/Base.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/sciurus17_description/meshes/collision/Body.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/sciurus17_description/meshes/visual/Base.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/realsense2_description/meshes/plug.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/sciurus17_description/meshes/visual/Body.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/realsense2_description/meshes/d435.dae filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/franka_description/meshes/visual/link4.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/ability_hand/meshes/visual/FB_palm_ref.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/allegro/meshes/visual/base_link_left.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/ability_hand/meshes/visual/FB_palm_ref_MIR.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/ability_hand/meshes/visual/wristmesh.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/allegro/meshes/visual/link_12.0_right.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/allegro/meshes/visual/link_12.0_left.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/coffee_machine/coffee_machine.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/racks/dish_rack.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/environment_maps/default.hdr filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/fetch/fetch_description/meshes/estop_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/fetch/fetch_description/meshes/r_wheel_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/fetch/fetch_description/meshes/head_pan_link_collision.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_palm_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_five_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_knee_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_knee_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_six_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_hip_pitch_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_shoulder_pitch_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_elbow_roll_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_shoulder_roll_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_shoulder_pitch_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_ankle_roll_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_one_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_hip_yaw_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/head_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_four_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_hip_yaw_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/torso_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/pelvis.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_one_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_four_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/right_hip_pitch_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_elbow_roll_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/edu/lower_link.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/edu/middle_link.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/pro/int_sim.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/pro/detailed/SIM__BL-Finger_Tip.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/pro/detailed/SIM__BL-Finger_Proximal.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/pro/prox-sim.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/edu/upper_link.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/pro/detailed/SIM__BL-Finger_Tip_without_tip.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/pro/center_axis_sim.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/pro/detailed/SIM__BL-Finger_Intermediate.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/pro/detailed/SIM__BL-Finger_Base.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/allegro/meshes/visual/base_link.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/high_table_boundary.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/SIM_BL_FINGER_TIP_LINK.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/finger_padding.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/BL-M_Table_ASM_small.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/BL-M_Table_ASM_big.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/SIM__BL-Finger_Base.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/SIM__BL-Finger_Proximal.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/object_containment_sim.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/trifinger/robot_properties_fingers/meshes/SIM__BL-Finger_Intermediate.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/franka_description/meshes/visual/hand.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/dclaw/meshes/visual/link_3.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/realsense2_description/meshes/d415.stl filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/franka_description/meshes/visual/link0.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/franka_description/meshes/visual/link1.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/franka_description/meshes/visual/link2.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/franka_description/meshes/visual/link5.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/franka_description/meshes/visual/link6.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/franka_description/meshes/visual/link7.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/panda/franka_description/meshes/visual/link3.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/pelvis_contour_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/g1_humanoid/meshes/left_three_link.STL filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/xarm7/meshes/visual/link1.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/xarm7/meshes/visual/link7.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/dclaw/meshes/visual/link_1.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/dclaw/meshes/visual/base_link.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/dclaw/meshes/visual/link_2.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/xarm7/meshes/visual/link_base.glb filter=lfs diff=lfs merge=lfs -text
+project/ManiSkill3/src/maniskill3_environment/mani_skill/assets/robots/xarm7/meshes/visual/link3.glb filter=lfs diff=lfs merge=lfs -text

CAD/R20/xyz_19.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b52775b1821c7f34dae249d5d217a809339b258ccc7fc3688bd8a877db75e19
+size 1572992

CAD/R20/xyz_27.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9dac0c440b3e3d43f9e956fbdc6dca77eddbf803ef1b2c380133def5e829cdde
+size 1572992

CAD/R20/xyz_29.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1441b52de2fd80d9443c6411ba0bf5a756a273dfa938abad70fbf212bffe0ac
+size 1572992

CAD/R20/xyz_31.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3df33f983413a0360d806325b4553891ff22201d7e1ec803e4f262b9681f7284
+size 1572992

CAD/R20/xyz_36.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8023ea9f9e95abfa9312578092ccac4539ca38eee42e3b4cc682d0bc93841c8
+size 1572992

CAD/R20/xyz_39.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26d9648c8d1827c405d9fda895a529302befa1ea11114e94dcc3a3d5dd242824
+size 1572992

CAD/R20/xyz_4.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1607101c37f4aefef3d28c7ea2584d8630a8d7dc04cd840b80a7db5b59738ad9
+size 1572992

CAD/R20/xyz_41.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:044bcee56a1cb96ccb2840bb62959a0a0a23f8d61cfe5498f5e24e75b749e9ad
+size 1572992

CAD/R274/xyz_10.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce76f5b1ab3c7296bb72875646e2bc1ae83a94c4fdf68fe1730e8c43e6214231
+size 1572992

CAD/R274/xyz_21.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec726442fb13131e7a36c0865c91eaa17b418562ad19cca02f03dac45c1b71bd
+size 1572992

CAD/R274/xyz_35.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:80b5bd3dcfb9a54b4361c53648f26a367eb60b42cff49c58045fe8008493e6ec
+size 1572992

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

@@ -0,0 +1,16 @@
+import warnings
+
+from .compilers.C import msvc
+
+__all__ = ["MSVCCompiler"]
+
+MSVCCompiler = msvc.Compiler
+
+
+def __getattr__(name):
+    if name == '_get_vc_env':
+        warnings.warn(
+            "_get_vc_env is private; find an alternative (pypa/distutils#340)"
+        )
+        return msvc._get_vc_env
+    raise AttributeError(name)

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

@@ -0,0 +1,289 @@
+"""distutils.core
+
+The only module that needs to be imported to use the Distutils; provides
+the 'setup' function (which is to be called from the setup script).  Also
+indirectly provides the Distribution and Command classes, although they are
+really defined in distutils.dist and distutils.cmd.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import tokenize
+from collections.abc import Iterable
+
+from .cmd import Command
+from .debug import DEBUG
+
+# Mainly import these so setup scripts can "from distutils.core import" them.
+from .dist import Distribution
+from .errors import (
+    CCompilerError,
+    DistutilsArgError,
+    DistutilsError,
+    DistutilsSetupError,
+)
+from .extension import Extension
+
+__all__ = ['Distribution', 'Command', 'Extension', 'setup']
+
+# This is a barebones help message generated displayed when the user
+# runs the setup script with no arguments at all.  More useful help
+# is generated with various --help options: global help, list commands,
+# and per-command help.
+USAGE = """\
+usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
+   or: %(script)s --help [cmd1 cmd2 ...]
+   or: %(script)s --help-commands
+   or: %(script)s cmd --help
+"""
+
+
+def gen_usage(script_name):
+    script = os.path.basename(script_name)
+    return USAGE % locals()
+
+
+# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'.
+_setup_stop_after = None
+_setup_distribution = None
+
+# Legal keyword arguments for the setup() function
+setup_keywords = (
+    'distclass',
+    'script_name',
+    'script_args',
+    'options',
+    'name',
+    'version',
+    'author',
+    'author_email',
+    'maintainer',
+    'maintainer_email',
+    'url',
+    'license',
+    'description',
+    'long_description',
+    'keywords',
+    'platforms',
+    'classifiers',
+    'download_url',
+    'requires',
+    'provides',
+    'obsoletes',
+)
+
+# Legal keyword arguments for the Extension constructor
+extension_keywords = (
+    'name',
+    'sources',
+    'include_dirs',
+    'define_macros',
+    'undef_macros',
+    'library_dirs',
+    'libraries',
+    'runtime_library_dirs',
+    'extra_objects',
+    'extra_compile_args',
+    'extra_link_args',
+    'swig_opts',
+    'export_symbols',
+    'depends',
+    'language',
+)
+
+
+def setup(**attrs):  # noqa: C901
+    """The gateway to the Distutils: do everything your setup script needs
+    to do, in a highly flexible and user-driven way.  Briefly: create a
+    Distribution instance; find and parse config files; parse the command
+    line; run each Distutils command found there, customized by the options
+    supplied to 'setup()' (as keyword arguments), in config files, and on
+    the command line.
+
+    The Distribution instance might be an instance of a class supplied via
+    the 'distclass' keyword argument to 'setup'; if no such class is
+    supplied, then the Distribution class (in dist.py) is instantiated.
+    All other arguments to 'setup' (except for 'cmdclass') are used to set
+    attributes of the Distribution instance.
+
+    The 'cmdclass' argument, if supplied, is a dictionary mapping command
+    names to command classes.  Each command encountered on the command line
+    will be turned into a command class, which is in turn instantiated; any
+    class found in 'cmdclass' is used in place of the default, which is
+    (for command 'foo_bar') class 'foo_bar' in module
+    'distutils.command.foo_bar'.  The command class must provide a
+    'user_options' attribute which is a list of option specifiers for
+    'distutils.fancy_getopt'.  Any command-line options between the current
+    and the next command are used to set attributes of the current command
+    object.
+
+    When the entire command-line has been successfully parsed, calls the
+    'run()' method on each command object in turn.  This method will be
+    driven entirely by the Distribution object (which each command object
+    has a reference to, thanks to its constructor), and the
+    command-specific options that became attributes of each command
+    object.
+    """
+
+    global _setup_stop_after, _setup_distribution
+
+    # Determine the distribution class -- either caller-supplied or
+    # our Distribution (see below).
+    klass = attrs.get('distclass')
+    if klass:
+        attrs.pop('distclass')
+    else:
+        klass = Distribution
+
+    if 'script_name' not in attrs:
+        attrs['script_name'] = os.path.basename(sys.argv[0])
+    if 'script_args' not in attrs:
+        attrs['script_args'] = sys.argv[1:]
+
+    # Create the Distribution instance, using the remaining arguments
+    # (ie. everything except distclass) to initialize it
+    try:
+        _setup_distribution = dist = klass(attrs)
+    except DistutilsSetupError as msg:
+        if 'name' not in attrs:
+            raise SystemExit(f"error in setup command: {msg}")
+        else:
+            raise SystemExit("error in {} setup command: {}".format(attrs['name'], msg))
+
+    if _setup_stop_after == "init":
+        return dist
+
+    # Find and parse the config file(s): they will override options from
+    # the setup script, but be overridden by the command line.
+    dist.parse_config_files()
+
+    if DEBUG:
+        print("options (after parsing config files):")
+        dist.dump_option_dicts()
+
+    if _setup_stop_after == "config":
+        return dist
+
+    # Parse the command line and override config files; any
+    # command-line errors are the end user's fault, so turn them into
+    # SystemExit to suppress tracebacks.
+    try:
+        ok = dist.parse_command_line()
+    except DistutilsArgError as msg:
+        raise SystemExit(gen_usage(dist.script_name) + f"\nerror: {msg}")
+
+    if DEBUG:
+        print("options (after parsing command line):")
+        dist.dump_option_dicts()
+
+    if _setup_stop_after == "commandline":
+        return dist
+
+    # And finally, run all the commands found on the command line.
+    if ok:
+        return run_commands(dist)
+
+    return dist
+
+
+# setup ()
+
+
+def run_commands(dist):
+    """Given a Distribution object run all the commands,
+    raising ``SystemExit`` errors in the case of failure.
+
+    This function assumes that either ``sys.argv`` or ``dist.script_args``
+    is already set accordingly.
+    """
+    try:
+        dist.run_commands()
+    except KeyboardInterrupt:
+        raise SystemExit("interrupted")
+    except OSError as exc:
+        if DEBUG:
+            sys.stderr.write(f"error: {exc}\n")
+            raise
+        else:
+            raise SystemExit(f"error: {exc}")
+
+    except (DistutilsError, CCompilerError) as msg:
+        if DEBUG:
+            raise
+        else:
+            raise SystemExit("error: " + str(msg))
+
+    return dist
+
+
+def run_setup(script_name, script_args: Iterable[str] | None = None, stop_after="run"):
+    """Run a setup script in a somewhat controlled environment, and
+    return the Distribution instance that drives things.  This is useful
+    if you need to find out the distribution meta-data (passed as
+    keyword args from 'script' to 'setup()', or the contents of the
+    config files or command-line.
+
+    'script_name' is a file that will be read and run with 'exec()';
+    'sys.argv[0]' will be replaced with 'script' for the duration of the
+    call.  'script_args' is a list of strings; if supplied,
+    'sys.argv[1:]' will be replaced by 'script_args' for the duration of
+    the call.
+
+    'stop_after' tells 'setup()' when to stop processing; possible
+    values:
+      init
+        stop after the Distribution instance has been created and
+        populated with the keyword arguments to 'setup()'
+      config
+        stop after config files have been parsed (and their data
+        stored in the Distribution instance)
+      commandline
+        stop after the command-line ('sys.argv[1:]' or 'script_args')
+        have been parsed (and the data stored in the Distribution)
+      run [default]
+        stop after all commands have been run (the same as if 'setup()'
+        had been called in the usual way
+
+    Returns the Distribution instance, which provides all information
+    used to drive the Distutils.
+    """
+    if stop_after not in ('init', 'config', 'commandline', 'run'):
+        raise ValueError(f"invalid value for 'stop_after': {stop_after!r}")
+
+    global _setup_stop_after, _setup_distribution
+    _setup_stop_after = stop_after
+
+    save_argv = sys.argv.copy()
+    g = {'__file__': script_name, '__name__': '__main__'}
+    try:
+        try:
+            sys.argv[0] = script_name
+            if script_args is not None:
+                sys.argv[1:] = script_args
+            # tokenize.open supports automatic encoding detection
+            with tokenize.open(script_name) as f:
+                code = f.read().replace(r'\r\n', r'\n')
+                exec(code, g)
+        finally:
+            sys.argv = save_argv
+            _setup_stop_after = None
+    except SystemExit:
+        # Hmm, should we do something if exiting with a non-zero code
+        # (ie. error)?
+        pass
+
+    if _setup_distribution is None:
+        raise RuntimeError(
+            "'distutils.core.setup()' was never called -- "
+            f"perhaps '{script_name}' is not a Distutils setup script?"
+        )
+
+    # I wonder if the setup script's namespace -- g and l -- would be of
+    # any interest to callers?
+    # print "_setup_distribution:", _setup_distribution
+    return _setup_distribution
+
+
+# run_setup ()

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

@@ -0,0 +1,1386 @@
+"""distutils.dist
+
+Provides the Distribution class, which represents the module distribution
+being built/installed/distributed.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import pathlib
+import re
+import sys
+import warnings
+from collections.abc import Iterable, MutableMapping
+from email import message_from_file
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Literal,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from packaging.utils import canonicalize_name, canonicalize_version
+
+from ._log import log
+from .debug import DEBUG
+from .errors import (
+    DistutilsArgError,
+    DistutilsClassError,
+    DistutilsModuleError,
+    DistutilsOptionError,
+)
+from .fancy_getopt import FancyGetopt, translate_longopt
+from .util import check_environ, rfc822_escape, strtobool
+
+if TYPE_CHECKING:
+    from _typeshed import SupportsWrite
+    from typing_extensions import TypeAlias
+
+    # type-only import because of mutual dependence between these modules
+    from .cmd import Command
+
+_CommandT = TypeVar("_CommandT", bound="Command")
+_OptionsList: TypeAlias = list[
+    Union[tuple[str, Union[str, None], str, int], tuple[str, Union[str, None], str]]
+]
+
+
+# Regex to define acceptable Distutils command names.  This is not *quite*
+# the same as a Python NAME -- I don't allow leading underscores.  The fact
+# that they're very similar is no coincidence; the default naming scheme is
+# to look for a Python module named after the command.
+command_re = re.compile(r'^[a-zA-Z]([a-zA-Z0-9_]*)$')
+
+
+def _ensure_list(value: str | Iterable[str], fieldname) -> str | list[str]:
+    if isinstance(value, str):
+        # a string containing comma separated values is okay.  It will
+        # be converted to a list by Distribution.finalize_options().
+        pass
+    elif not isinstance(value, list):
+        # passing a tuple or an iterator perhaps, warn and convert
+        typename = type(value).__name__
+        msg = "Warning: '{fieldname}' should be a list, got type '{typename}'"
+        msg = msg.format(**locals())
+        log.warning(msg)
+        value = list(value)
+    return value
+
+
+class Distribution:
+    """The core of the Distutils.  Most of the work hiding behind 'setup'
+    is really done within a Distribution instance, which farms the work out
+    to the Distutils commands specified on the command line.
+
+    Setup scripts will almost never instantiate Distribution directly,
+    unless the 'setup()' function is totally inadequate to their needs.
+    However, it is conceivable that a setup script might wish to subclass
+    Distribution for some specialized purpose, and then pass the subclass
+    to 'setup()' as the 'distclass' keyword argument.  If so, it is
+    necessary to respect the expectations that 'setup' has of Distribution.
+    See the code for 'setup()', in core.py, for details.
+    """
+
+    # 'global_options' describes the command-line options that may be
+    # supplied to the setup script prior to any actual commands.
+    # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
+    # these global options.  This list should be kept to a bare minimum,
+    # since every global option is also valid as a command option -- and we
+    # don't want to pollute the commands with too many options that they
+    # have minimal control over.
+    # The fourth entry for verbose means that it can be repeated.
+    global_options: ClassVar[_OptionsList] = [
+        ('verbose', 'v', "run verbosely (default)", 1),
+        ('quiet', 'q', "run quietly (turns verbosity off)"),
+        ('dry-run', 'n', "don't actually do anything"),
+        ('help', 'h', "show detailed help message"),
+        ('no-user-cfg', None, 'ignore pydistutils.cfg in your home directory'),
+    ]
+
+    # 'common_usage' is a short (2-3 line) string describing the common
+    # usage of the setup script.
+    common_usage: ClassVar[str] = """\
+Common commands: (see '--help-commands' for more)
+
+  setup.py build      will build the package underneath 'build/'
+  setup.py install    will install the package
+"""
+
+    # options that are not propagated to the commands
+    display_options: ClassVar[_OptionsList] = [
+        ('help-commands', None, "list all available commands"),
+        ('name', None, "print package name"),
+        ('version', 'V', "print package version"),
+        ('fullname', None, "print <package name>-<version>"),
+        ('author', None, "print the author's name"),
+        ('author-email', None, "print the author's email address"),
+        ('maintainer', None, "print the maintainer's name"),
+        ('maintainer-email', None, "print the maintainer's email address"),
+        ('contact', None, "print the maintainer's name if known, else the author's"),
+        (
+            'contact-email',
+            None,
+            "print the maintainer's email address if known, else the author's",
+        ),
+        ('url', None, "print the URL for this package"),
+        ('license', None, "print the license of the package"),
+        ('licence', None, "alias for --license"),
+        ('description', None, "print the package description"),
+        ('long-description', None, "print the long package description"),
+        ('platforms', None, "print the list of platforms"),
+        ('classifiers', None, "print the list of classifiers"),
+        ('keywords', None, "print the list of keywords"),
+        ('provides', None, "print the list of packages/modules provided"),
+        ('requires', None, "print the list of packages/modules required"),
+        ('obsoletes', None, "print the list of packages/modules made obsolete"),
+    ]
+    display_option_names: ClassVar[list[str]] = [
+        translate_longopt(x[0]) for x in display_options
+    ]
+
+    # negative options are options that exclude other options
+    negative_opt: ClassVar[dict[str, str]] = {'quiet': 'verbose'}
+
+    # -- Creation/initialization methods -------------------------------
+
+    # Can't Unpack a TypedDict with optional properties, so using Any instead
+    def __init__(self, attrs: MutableMapping[str, Any] | None = None) -> None:  # noqa: C901
+        """Construct a new Distribution instance: initialize all the
+        attributes of a Distribution, and then use 'attrs' (a dictionary
+        mapping attribute names to values) to assign some of those
+        attributes their "real" values.  (Any attributes not mentioned in
+        'attrs' will be assigned to some null value: 0, None, an empty list
+        or dictionary, etc.)  Most importantly, initialize the
+        'command_obj' attribute to the empty dictionary; this will be
+        filled in with real command objects by 'parse_command_line()'.
+        """
+
+        # Default values for our command-line options
+        self.verbose = True
+        self.dry_run = False
+        self.help = False
+        for attr in self.display_option_names:
+            setattr(self, attr, False)
+
+        # Store the distribution meta-data (name, version, author, and so
+        # forth) in a separate object -- we're getting to have enough
+        # information here (and enough command-line options) that it's
+        # worth it.  Also delegate 'get_XXX()' methods to the 'metadata'
+        # object in a sneaky and underhanded (but efficient!) way.
+        self.metadata = DistributionMetadata()
+        for basename in self.metadata._METHOD_BASENAMES:
+            method_name = "get_" + basename
+            setattr(self, method_name, getattr(self.metadata, method_name))
+
+        # 'cmdclass' maps command names to class objects, so we
+        # can 1) quickly figure out which class to instantiate when
+        # we need to create a new command object, and 2) have a way
+        # for the setup script to override command classes
+        self.cmdclass: dict[str, type[Command]] = {}
+
+        # 'command_packages' is a list of packages in which commands
+        # are searched for.  The factory for command 'foo' is expected
+        # to be named 'foo' in the module 'foo' in one of the packages
+        # named here.  This list is searched from the left; an error
+        # is raised if no named package provides the command being
+        # searched for.  (Always access using get_command_packages().)
+        self.command_packages: str | list[str] | None = None
+
+        # 'script_name' and 'script_args' are usually set to sys.argv[0]
+        # and sys.argv[1:], but they can be overridden when the caller is
+        # not necessarily a setup script run from the command-line.
+        self.script_name: str | os.PathLike[str] | None = None
+        self.script_args: list[str] | None = None
+
+        # 'command_options' is where we store command options between
+        # parsing them (from config files, the command-line, etc.) and when
+        # they are actually needed -- ie. when the command in question is
+        # instantiated.  It is a dictionary of dictionaries of 2-tuples:
+        #   command_options = { command_name : { option : (source, value) } }
+        self.command_options: dict[str, dict[str, tuple[str, str]]] = {}
+
+        # 'dist_files' is the list of (command, pyversion, file) that
+        # have been created by any dist commands run so far. This is
+        # filled regardless of whether the run is dry or not. pyversion
+        # gives sysconfig.get_python_version() if the dist file is
+        # specific to a Python version, 'any' if it is good for all
+        # Python versions on the target platform, and '' for a source
+        # file. pyversion should not be used to specify minimum or
+        # maximum required Python versions; use the metainfo for that
+        # instead.
+        self.dist_files: list[tuple[str, str, str]] = []
+
+        # These options are really the business of various commands, rather
+        # than of the Distribution itself.  We provide aliases for them in
+        # Distribution as a convenience to the developer.
+        self.packages = None
+        self.package_data: dict[str, list[str]] = {}
+        self.package_dir = None
+        self.py_modules = None
+        self.libraries = None
+        self.headers = None
+        self.ext_modules = None
+        self.ext_package = None
+        self.include_dirs = None
+        self.extra_path = None
+        self.scripts = None
+        self.data_files = None
+        self.password = ''
+
+        # And now initialize bookkeeping stuff that can't be supplied by
+        # the caller at all.  'command_obj' maps command names to
+        # Command instances -- that's how we enforce that every command
+        # class is a singleton.
+        self.command_obj: dict[str, Command] = {}
+
+        # 'have_run' maps command names to boolean values; it keeps track
+        # of whether we have actually run a particular command, to make it
+        # cheap to "run" a command whenever we think we might need to -- if
+        # it's already been done, no need for expensive filesystem
+        # operations, we just check the 'have_run' dictionary and carry on.
+        # It's only safe to query 'have_run' for a command class that has
+        # been instantiated -- a false value will be inserted when the
+        # command object is created, and replaced with a true value when
+        # the command is successfully run.  Thus it's probably best to use
+        # '.get()' rather than a straight lookup.
+        self.have_run: dict[str, bool] = {}
+
+        # Now we'll use the attrs dictionary (ultimately, keyword args from
+        # the setup script) to possibly override any or all of these
+        # distribution options.
+
+        if attrs:
+            # Pull out the set of command options and work on them
+            # specifically.  Note that this order guarantees that aliased
+            # command options will override any supplied redundantly
+            # through the general options dictionary.
+            options = attrs.get('options')
+            if options is not None:
+                del attrs['options']
+                for command, cmd_options in options.items():
+                    opt_dict = self.get_option_dict(command)
+                    for opt, val in cmd_options.items():
+                        opt_dict[opt] = ("setup script", val)
+
+            if 'licence' in attrs:
+                attrs['license'] = attrs['licence']
+                del attrs['licence']
+                msg = "'licence' distribution option is deprecated; use 'license'"
+                warnings.warn(msg)
+
+            # Now work on the rest of the attributes.  Any attribute that's
+            # not already defined is invalid!
+            for key, val in attrs.items():
+                if hasattr(self.metadata, "set_" + key):
+                    getattr(self.metadata, "set_" + key)(val)
+                elif hasattr(self.metadata, key):
+                    setattr(self.metadata, key, val)
+                elif hasattr(self, key):
+                    setattr(self, key, val)
+                else:
+                    msg = f"Unknown distribution option: {key!r}"
+                    warnings.warn(msg)
+
+        # no-user-cfg is handled before other command line args
+        # because other args override the config files, and this
+        # one is needed before we can load the config files.
+        # If attrs['script_args'] wasn't passed, assume false.
+        #
+        # This also make sure we just look at the global options
+        self.want_user_cfg = True
+
+        if self.script_args is not None:
+            # Coerce any possible iterable from attrs into a list
+            self.script_args = list(self.script_args)
+            for arg in self.script_args:
+                if not arg.startswith('-'):
+                    break
+                if arg == '--no-user-cfg':
+                    self.want_user_cfg = False
+                    break
+
+        self.finalize_options()
+
+    def get_option_dict(self, command):
+        """Get the option dictionary for a given command.  If that
+        command's option dictionary hasn't been created yet, then create it
+        and return the new dictionary; otherwise, return the existing
+        option dictionary.
+        """
+        dict = self.command_options.get(command)
+        if dict is None:
+            dict = self.command_options[command] = {}
+        return dict
+
+    def dump_option_dicts(self, header=None, commands=None, indent: str = "") -> None:
+        from pprint import pformat
+
+        if commands is None:  # dump all command option dicts
+            commands = sorted(self.command_options.keys())
+
+        if header is not None:
+            self.announce(indent + header)
+            indent = indent + "  "
+
+        if not commands:
+            self.announce(indent + "no commands known yet")
+            return
+
+        for cmd_name in commands:
+            opt_dict = self.command_options.get(cmd_name)
+            if opt_dict is None:
+                self.announce(indent + f"no option dict for '{cmd_name}' command")
+            else:
+                self.announce(indent + f"option dict for '{cmd_name}' command:")
+                out = pformat(opt_dict)
+                for line in out.split('\n'):
+                    self.announce(indent + "  " + line)
+
+    # -- Config file finding/parsing methods ---------------------------
+
+    def find_config_files(self):
+        """Find as many configuration files as should be processed for this
+        platform, and return a list of filenames in the order in which they
+        should be parsed.  The filenames returned are guaranteed to exist
+        (modulo nasty race conditions).
+
+        There are multiple possible config files:
+        - distutils.cfg in the Distutils installation directory (i.e.
+          where the top-level Distutils __inst__.py file lives)
+        - a file in the user's home directory named .pydistutils.cfg
+          on Unix and pydistutils.cfg on Windows/Mac; may be disabled
+          with the ``--no-user-cfg`` option
+        - setup.cfg in the current directory
+        - a file named by an environment variable
+        """
+        check_environ()
+        files = [str(path) for path in self._gen_paths() if os.path.isfile(path)]
+
+        if DEBUG:
+            self.announce("using config files: {}".format(', '.join(files)))
+
+        return files
+
+    def _gen_paths(self):
+        # The system-wide Distutils config file
+        sys_dir = pathlib.Path(sys.modules['distutils'].__file__).parent
+        yield sys_dir / "distutils.cfg"
+
+        # The per-user config file
+        prefix = '.' * (os.name == 'posix')
+        filename = prefix + 'pydistutils.cfg'
+        if self.want_user_cfg:
+            with contextlib.suppress(RuntimeError):
+                yield pathlib.Path('~').expanduser() / filename
+
+        # All platforms support local setup.cfg
+        yield pathlib.Path('setup.cfg')
+
+        # Additional config indicated in the environment
+        with contextlib.suppress(TypeError):
+            yield pathlib.Path(os.getenv("DIST_EXTRA_CONFIG"))
+
+    def parse_config_files(self, filenames=None):  # noqa: C901
+        from configparser import ConfigParser
+
+        # Ignore install directory options if we have a venv
+        if sys.prefix != sys.base_prefix:
+            ignore_options = [
+                'install-base',
+                'install-platbase',
+                'install-lib',
+                'install-platlib',
+                'install-purelib',
+                'install-headers',
+                'install-scripts',
+                'install-data',
+                'prefix',
+                'exec-prefix',
+                'home',
+                'user',
+                'root',
+            ]
+        else:
+            ignore_options = []
+
+        ignore_options = frozenset(ignore_options)
+
+        if filenames is None:
+            filenames = self.find_config_files()
+
+        if DEBUG:
+            self.announce("Distribution.parse_config_files():")
+
+        parser = ConfigParser()
+        for filename in filenames:
+            if DEBUG:
+                self.announce(f"  reading {filename}")
+            parser.read(filename, encoding='utf-8')
+            for section in parser.sections():
+                options = parser.options(section)
+                opt_dict = self.get_option_dict(section)
+
+                for opt in options:
+                    if opt != '__name__' and opt not in ignore_options:
+                        val = parser.get(section, opt)
+                        opt = opt.replace('-', '_')
+                        opt_dict[opt] = (filename, val)
+
+            # Make the ConfigParser forget everything (so we retain
+            # the original filenames that options come from)
+            parser.__init__()
+
+        # If there was a "global" section in the config file, use it
+        # to set Distribution options.
+
+        if 'global' in self.command_options:
+            for opt, (_src, val) in self.command_options['global'].items():
+                alias = self.negative_opt.get(opt)
+                try:
+                    if alias:
+                        setattr(self, alias, not strtobool(val))
+                    elif opt in ('verbose', 'dry_run'):  # ugh!
+                        setattr(self, opt, strtobool(val))
+                    else:
+                        setattr(self, opt, val)
+                except ValueError as msg:
+                    raise DistutilsOptionError(msg)
+
+    # -- Command-line parsing methods ----------------------------------
+
+    def parse_command_line(self):
+        """Parse the setup script's command line, taken from the
+        'script_args' instance attribute (which defaults to 'sys.argv[1:]'
+        -- see 'setup()' in core.py).  This list is first processed for
+        "global options" -- options that set attributes of the Distribution
+        instance.  Then, it is alternately scanned for Distutils commands
+        and options for that command.  Each new command terminates the
+        options for the previous command.  The allowed options for a
+        command are determined by the 'user_options' attribute of the
+        command class -- thus, we have to be able to load command classes
+        in order to parse the command line.  Any error in that 'options'
+        attribute raises DistutilsGetoptError; any error on the
+        command-line raises DistutilsArgError.  If no Distutils commands
+        were found on the command line, raises DistutilsArgError.  Return
+        true if command-line was successfully parsed and we should carry
+        on with executing commands; false if no errors but we shouldn't
+        execute commands (currently, this only happens if user asks for
+        help).
+        """
+        #
+        # We now have enough information to show the Macintosh dialog
+        # that allows the user to interactively specify the "command line".
+        #
+        toplevel_options = self._get_toplevel_options()
+
+        # We have to parse the command line a bit at a time -- global
+        # options, then the first command, then its options, and so on --
+        # because each command will be handled by a different class, and
+        # the options that are valid for a particular class aren't known
+        # until we have loaded the command class, which doesn't happen
+        # until we know what the command is.
+
+        self.commands = []
+        parser = FancyGetopt(toplevel_options + self.display_options)
+        parser.set_negative_aliases(self.negative_opt)
+        parser.set_aliases({'licence': 'license'})
+        args = parser.getopt(args=self.script_args, object=self)
+        option_order = parser.get_option_order()
+        logging.getLogger().setLevel(logging.WARN - 10 * self.verbose)
+
+        # for display options we return immediately
+        if self.handle_display_options(option_order):
+            return
+        while args:
+            args = self._parse_command_opts(parser, args)
+            if args is None:  # user asked for help (and got it)
+                return
+
+        # Handle the cases of --help as a "global" option, ie.
+        # "setup.py --help" and "setup.py --help command ...".  For the
+        # former, we show global options (--verbose, --dry-run, etc.)
+        # and display-only options (--name, --version, etc.); for the
+        # latter, we omit the display-only options and show help for
+        # each command listed on the command line.
+        if self.help:
+            self._show_help(
+                parser, display_options=len(self.commands) == 0, commands=self.commands
+            )
+            return
+
+        # Oops, no commands found -- an end-user error
+        if not self.commands:
+            raise DistutilsArgError("no commands supplied")
+
+        # All is well: return true
+        return True
+
+    def _get_toplevel_options(self):
+        """Return the non-display options recognized at the top level.
+
+        This includes options that are recognized *only* at the top
+        level as well as options recognized for commands.
+        """
+        return self.global_options + [
+            (
+                "command-packages=",
+                None,
+                "list of packages that provide distutils commands",
+            ),
+        ]
+
+    def _parse_command_opts(self, parser, args):  # noqa: C901
+        """Parse the command-line options for a single command.
+        'parser' must be a FancyGetopt instance; 'args' must be the list
+        of arguments, starting with the current command (whose options
+        we are about to parse).  Returns a new version of 'args' with
+        the next command at the front of the list; will be the empty
+        list if there are no more commands on the command line.  Returns
+        None if the user asked for help on this command.
+        """
+        # late import because of mutual dependence between these modules
+        from distutils.cmd import Command
+
+        # Pull the current command from the head of the command line
+        command = args[0]
+        if not command_re.match(command):
+            raise SystemExit(f"invalid command name '{command}'")
+        self.commands.append(command)
+
+        # Dig up the command class that implements this command, so we
+        # 1) know that it's a valid command, and 2) know which options
+        # it takes.
+        try:
+            cmd_class = self.get_command_class(command)
+        except DistutilsModuleError as msg:
+            raise DistutilsArgError(msg)
+
+        # Require that the command class be derived from Command -- want
+        # to be sure that the basic "command" interface is implemented.
+        if not issubclass(cmd_class, Command):
+            raise DistutilsClassError(
+                f"command class {cmd_class} must subclass Command"
+            )
+
+        # Also make sure that the command object provides a list of its
+        # known options.
+        if not (
+            hasattr(cmd_class, 'user_options')
+            and isinstance(cmd_class.user_options, list)
+        ):
+            msg = (
+                "command class %s must provide "
+                "'user_options' attribute (a list of tuples)"
+            )
+            raise DistutilsClassError(msg % cmd_class)
+
+        # If the command class has a list of negative alias options,
+        # merge it in with the global negative aliases.
+        negative_opt = self.negative_opt
+        if hasattr(cmd_class, 'negative_opt'):
+            negative_opt = negative_opt.copy()
+            negative_opt.update(cmd_class.negative_opt)
+
+        # Check for help_options in command class.  They have a different
+        # format (tuple of four) so we need to preprocess them here.
+        if hasattr(cmd_class, 'help_options') and isinstance(
+            cmd_class.help_options, list
+        ):
+            help_options = fix_help_options(cmd_class.help_options)
+        else:
+            help_options = []
+
+        # All commands support the global options too, just by adding
+        # in 'global_options'.
+        parser.set_option_table(
+            self.global_options + cmd_class.user_options + help_options
+        )
+        parser.set_negative_aliases(negative_opt)
+        (args, opts) = parser.getopt(args[1:])
+        if hasattr(opts, 'help') and opts.help:
+            self._show_help(parser, display_options=False, commands=[cmd_class])
+            return
+
+        if hasattr(cmd_class, 'help_options') and isinstance(
+            cmd_class.help_options, list
+        ):
+            help_option_found = 0
+            for help_option, _short, _desc, func in cmd_class.help_options:
+                if hasattr(opts, parser.get_attr_name(help_option)):
+                    help_option_found = 1
+                    if callable(func):
+                        func()
+                    else:
+                        raise DistutilsClassError(
+                            f"invalid help function {func!r} for help option '{help_option}': "
+                            "must be a callable object (function, etc.)"
+                        )
+
+            if help_option_found:
+                return
+
+        # Put the options from the command-line into their official
+        # holding pen, the 'command_options' dictionary.
+        opt_dict = self.get_option_dict(command)
+        for name, value in vars(opts).items():
+            opt_dict[name] = ("command line", value)
+
+        return args
+
+    def finalize_options(self) -> None:
+        """Set final values for all the options on the Distribution
+        instance, analogous to the .finalize_options() method of Command
+        objects.
+        """
+        for attr in ('keywords', 'platforms'):
+            value = getattr(self.metadata, attr)
+            if value is None:
+                continue
+            if isinstance(value, str):
+                value = [elm.strip() for elm in value.split(',')]
+                setattr(self.metadata, attr, value)
+
+    def _show_help(
+        self, parser, global_options=True, display_options=True, commands: Iterable = ()
+    ):
+        """Show help for the setup script command-line in the form of
+        several lists of command-line options.  'parser' should be a
+        FancyGetopt instance; do not expect it to be returned in the
+        same state, as its option table will be reset to make it
+        generate the correct help text.
+
+        If 'global_options' is true, lists the global options:
+        --verbose, --dry-run, etc.  If 'display_options' is true, lists
+        the "display-only" options: --name, --version, etc.  Finally,
+        lists per-command help for every command name or command class
+        in 'commands'.
+        """
+        # late import because of mutual dependence between these modules
+        from distutils.cmd import Command
+        from distutils.core import gen_usage
+
+        if global_options:
+            if display_options:
+                options = self._get_toplevel_options()
+            else:
+                options = self.global_options
+            parser.set_option_table(options)
+            parser.print_help(self.common_usage + "\nGlobal options:")
+            print()
+
+        if display_options:
+            parser.set_option_table(self.display_options)
+            parser.print_help(
+                "Information display options (just display information, ignore any commands)"
+            )
+            print()
+
+        for command in commands:
+            if isinstance(command, type) and issubclass(command, Command):
+                klass = command
+            else:
+                klass = self.get_command_class(command)
+            if hasattr(klass, 'help_options') and isinstance(klass.help_options, list):
+                parser.set_option_table(
+                    klass.user_options + fix_help_options(klass.help_options)
+                )
+            else:
+                parser.set_option_table(klass.user_options)
+            parser.print_help(f"Options for '{klass.__name__}' command:")
+            print()
+
+        print(gen_usage(self.script_name))
+
+    def handle_display_options(self, option_order):
+        """If there were any non-global "display-only" options
+        (--help-commands or the metadata display options) on the command
+        line, display the requested info and return true; else return
+        false.
+        """
+        from distutils.core import gen_usage
+
+        # User just wants a list of commands -- we'll print it out and stop
+        # processing now (ie. if they ran "setup --help-commands foo bar",
+        # we ignore "foo bar").
+        if self.help_commands:
+            self.print_commands()
+            print()
+            print(gen_usage(self.script_name))
+            return 1
+
+        # If user supplied any of the "display metadata" options, then
+        # display that metadata in the order in which the user supplied the
+        # metadata options.
+        any_display_options = 0
+        is_display_option = set()
+        for option in self.display_options:
+            is_display_option.add(option[0])
+
+        for opt, val in option_order:
+            if val and opt in is_display_option:
+                opt = translate_longopt(opt)
+                value = getattr(self.metadata, "get_" + opt)()
+                if opt in ('keywords', 'platforms'):
+                    print(','.join(value))
+                elif opt in ('classifiers', 'provides', 'requires', 'obsoletes'):
+                    print('\n'.join(value))
+                else:
+                    print(value)
+                any_display_options = 1
+
+        return any_display_options
+
+    def print_command_list(self, commands, header, max_length) -> None:
+        """Print a subset of the list of all commands -- used by
+        'print_commands()'.
+        """
+        print(header + ":")
+
+        for cmd in commands:
+            klass = self.cmdclass.get(cmd)
+            if not klass:
+                klass = self.get_command_class(cmd)
+            try:
+                description = klass.description
+            except AttributeError:
+                description = "(no description available)"
+
+            print(f"  {cmd:<{max_length}}  {description}")
+
+    def print_commands(self) -> None:
+        """Print out a help message listing all available commands with a
+        description of each.  The list is divided into "standard commands"
+        (listed in distutils.command.__all__) and "extra commands"
+        (mentioned in self.cmdclass, but not a standard command).  The
+        descriptions come from the command class attribute
+        'description'.
+        """
+        import distutils.command
+
+        std_commands = distutils.command.__all__
+        is_std = set(std_commands)
+
+        extra_commands = [cmd for cmd in self.cmdclass.keys() if cmd not in is_std]
+
+        max_length = 0
+        for cmd in std_commands + extra_commands:
+            if len(cmd) > max_length:
+                max_length = len(cmd)
+
+        self.print_command_list(std_commands, "Standard commands", max_length)
+        if extra_commands:
+            print()
+            self.print_command_list(extra_commands, "Extra commands", max_length)
+
+    def get_command_list(self):
+        """Get a list of (command, description) tuples.
+        The list is divided into "standard commands" (listed in
+        distutils.command.__all__) and "extra commands" (mentioned in
+        self.cmdclass, but not a standard command).  The descriptions come
+        from the command class attribute 'description'.
+        """
+        # Currently this is only used on Mac OS, for the Mac-only GUI
+        # Distutils interface (by Jack Jansen)
+        import distutils.command
+
+        std_commands = distutils.command.__all__
+        is_std = set(std_commands)
+
+        extra_commands = [cmd for cmd in self.cmdclass.keys() if cmd not in is_std]
+
+        rv = []
+        for cmd in std_commands + extra_commands:
+            klass = self.cmdclass.get(cmd)
+            if not klass:
+                klass = self.get_command_class(cmd)
+            try:
+                description = klass.description
+            except AttributeError:
+                description = "(no description available)"
+            rv.append((cmd, description))
+        return rv
+
+    # -- Command class/object methods ----------------------------------
+
+    def get_command_packages(self):
+        """Return a list of packages from which commands are loaded."""
+        pkgs = self.command_packages
+        if not isinstance(pkgs, list):
+            if pkgs is None:
+                pkgs = ''
+            pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
+            if "distutils.command" not in pkgs:
+                pkgs.insert(0, "distutils.command")
+            self.command_packages = pkgs
+        return pkgs
+
+    def get_command_class(self, command: str) -> type[Command]:
+        """Return the class that implements the Distutils command named by
+        'command'.  First we check the 'cmdclass' dictionary; if the
+        command is mentioned there, we fetch the class object from the
+        dictionary and return it.  Otherwise we load the command module
+        ("distutils.command." + command) and fetch the command class from
+        the module.  The loaded class is also stored in 'cmdclass'
+        to speed future calls to 'get_command_class()'.
+
+        Raises DistutilsModuleError if the expected module could not be
+        found, or if that module does not define the expected class.
+        """
+        klass = self.cmdclass.get(command)
+        if klass:
+            return klass
+
+        for pkgname in self.get_command_packages():
+            module_name = f"{pkgname}.{command}"
+            klass_name = command
+
+            try:
+                __import__(module_name)
+                module = sys.modules[module_name]
+            except ImportError:
+                continue
+
+            try:
+                klass = getattr(module, klass_name)
+            except AttributeError:
+                raise DistutilsModuleError(
+                    f"invalid command '{command}' (no class '{klass_name}' in module '{module_name}')"
+                )
+
+            self.cmdclass[command] = klass
+            return klass
+
+        raise DistutilsModuleError(f"invalid command '{command}'")
+
+    @overload
+    def get_command_obj(
+        self, command: str, create: Literal[True] = True
+    ) -> Command: ...
+    @overload
+    def get_command_obj(
+        self, command: str, create: Literal[False]
+    ) -> Command | None: ...
+    def get_command_obj(self, command: str, create: bool = True) -> Command | None:
+        """Return the command object for 'command'.  Normally this object
+        is cached on a previous call to 'get_command_obj()'; if no command
+        object for 'command' is in the cache, then we either create and
+        return it (if 'create' is true) or return None.
+        """
+        cmd_obj = self.command_obj.get(command)
+        if not cmd_obj and create:
+            if DEBUG:
+                self.announce(
+                    "Distribution.get_command_obj(): "
+                    f"creating '{command}' command object"
+                )
+
+            klass = self.get_command_class(command)
+            cmd_obj = self.command_obj[command] = klass(self)
+            self.have_run[command] = False
+
+            # Set any options that were supplied in config files
+            # or on the command line.  (NB. support for error
+            # reporting is lame here: any errors aren't reported
+            # until 'finalize_options()' is called, which means
+            # we won't report the source of the error.)
+            options = self.command_options.get(command)
+            if options:
+                self._set_command_options(cmd_obj, options)
+
+        return cmd_obj
+
+    def _set_command_options(self, command_obj, option_dict=None):  # noqa: C901
+        """Set the options for 'command_obj' from 'option_dict'.  Basically
+        this means copying elements of a dictionary ('option_dict') to
+        attributes of an instance ('command').
+
+        'command_obj' must be a Command instance.  If 'option_dict' is not
+        supplied, uses the standard option dictionary for this command
+        (from 'self.command_options').
+        """
+        command_name = command_obj.get_command_name()
+        if option_dict is None:
+            option_dict = self.get_option_dict(command_name)
+
+        if DEBUG:
+            self.announce(f"  setting options for '{command_name}' command:")
+        for option, (source, value) in option_dict.items():
+            if DEBUG:
+                self.announce(f"    {option} = {value} (from {source})")
+            try:
+                bool_opts = [translate_longopt(o) for o in command_obj.boolean_options]
+            except AttributeError:
+                bool_opts = []
+            try:
+                neg_opt = command_obj.negative_opt
+            except AttributeError:
+                neg_opt = {}
+
+            try:
+                is_string = isinstance(value, str)
+                if option in neg_opt and is_string:
+                    setattr(command_obj, neg_opt[option], not strtobool(value))
+                elif option in bool_opts and is_string:
+                    setattr(command_obj, option, strtobool(value))
+                elif hasattr(command_obj, option):
+                    setattr(command_obj, option, value)
+                else:
+                    raise DistutilsOptionError(
+                        f"error in {source}: command '{command_name}' has no such option '{option}'"
+                    )
+            except ValueError as msg:
+                raise DistutilsOptionError(msg)
+
+    @overload
+    def reinitialize_command(
+        self, command: str, reinit_subcommands: bool = False
+    ) -> Command: ...
+    @overload
+    def reinitialize_command(
+        self, command: _CommandT, reinit_subcommands: bool = False
+    ) -> _CommandT: ...
+    def reinitialize_command(
+        self, command: str | Command, reinit_subcommands=False
+    ) -> Command:
+        """Reinitializes a command to the state it was in when first
+        returned by 'get_command_obj()': ie., initialized but not yet
+        finalized.  This provides the opportunity to sneak option
+        values in programmatically, overriding or supplementing
+        user-supplied values from the config files and command line.
+        You'll have to re-finalize the command object (by calling
+        'finalize_options()' or 'ensure_finalized()') before using it for
+        real.
+
+        'command' should be a command name (string) or command object.  If
+        'reinit_subcommands' is true, also reinitializes the command's
+        sub-commands, as declared by the 'sub_commands' class attribute (if
+        it has one).  See the "install" command for an example.  Only
+        reinitializes the sub-commands that actually matter, ie. those
+        whose test predicates return true.
+
+        Returns the reinitialized command object.
+        """
+        from distutils.cmd import Command
+
+        if not isinstance(command, Command):
+            command_name = command
+            command = self.get_command_obj(command_name)
+        else:
+            command_name = command.get_command_name()
+
+        if not command.finalized:
+            return command
+        command.initialize_options()
+        command.finalized = False
+        self.have_run[command_name] = False
+        self._set_command_options(command)
+
+        if reinit_subcommands:
+            for sub in command.get_sub_commands():
+                self.reinitialize_command(sub, reinit_subcommands)
+
+        return command
+
+    # -- Methods that operate on the Distribution ----------------------
+
+    def announce(self, msg, level: int = logging.INFO) -> None:
+        log.log(level, msg)
+
+    def run_commands(self) -> None:
+        """Run each command that was seen on the setup script command line.
+        Uses the list of commands found and cache of command objects
+        created by 'get_command_obj()'.
+        """
+        for cmd in self.commands:
+            self.run_command(cmd)
+
+    # -- Methods that operate on its Commands --------------------------
+
+    def run_command(self, command: str) -> None:
+        """Do whatever it takes to run a command (including nothing at all,
+        if the command has already been run).  Specifically: if we have
+        already created and run the command named by 'command', return
+        silently without doing anything.  If the command named by 'command'
+        doesn't even have a command object yet, create one.  Then invoke
+        'run()' on that command object (or an existing one).
+        """
+        # Already been here, done that? then return silently.
+        if self.have_run.get(command):
+            return
+
+        log.info("running %s", command)
+        cmd_obj = self.get_command_obj(command)
+        cmd_obj.ensure_finalized()
+        cmd_obj.run()
+        self.have_run[command] = True
+
+    # -- Distribution query methods ------------------------------------
+
+    def has_pure_modules(self) -> bool:
+        return len(self.packages or self.py_modules or []) > 0
+
+    def has_ext_modules(self) -> bool:
+        return self.ext_modules and len(self.ext_modules) > 0
+
+    def has_c_libraries(self) -> bool:
+        return self.libraries and len(self.libraries) > 0
+
+    def has_modules(self) -> bool:
+        return self.has_pure_modules() or self.has_ext_modules()
+
+    def has_headers(self) -> bool:
+        return self.headers and len(self.headers) > 0
+
+    def has_scripts(self) -> bool:
+        return self.scripts and len(self.scripts) > 0
+
+    def has_data_files(self) -> bool:
+        return self.data_files and len(self.data_files) > 0
+
+    def is_pure(self) -> bool:
+        return (
+            self.has_pure_modules()
+            and not self.has_ext_modules()
+            and not self.has_c_libraries()
+        )
+
+    # -- Metadata query methods ----------------------------------------
+
+    # If you're looking for 'get_name()', 'get_version()', and so forth,
+    # they are defined in a sneaky way: the constructor binds self.get_XXX
+    # to self.metadata.get_XXX.  The actual code is in the
+    # DistributionMetadata class, below.
+    if TYPE_CHECKING:
+        # Unfortunately this means we need to specify them manually or not expose statically
+        def _(self) -> None:
+            self.get_name = self.metadata.get_name
+            self.get_version = self.metadata.get_version
+            self.get_fullname = self.metadata.get_fullname
+            self.get_author = self.metadata.get_author
+            self.get_author_email = self.metadata.get_author_email
+            self.get_maintainer = self.metadata.get_maintainer
+            self.get_maintainer_email = self.metadata.get_maintainer_email
+            self.get_contact = self.metadata.get_contact
+            self.get_contact_email = self.metadata.get_contact_email
+            self.get_url = self.metadata.get_url
+            self.get_license = self.metadata.get_license
+            self.get_licence = self.metadata.get_licence
+            self.get_description = self.metadata.get_description
+            self.get_long_description = self.metadata.get_long_description
+            self.get_keywords = self.metadata.get_keywords
+            self.get_platforms = self.metadata.get_platforms
+            self.get_classifiers = self.metadata.get_classifiers
+            self.get_download_url = self.metadata.get_download_url
+            self.get_requires = self.metadata.get_requires
+            self.get_provides = self.metadata.get_provides
+            self.get_obsoletes = self.metadata.get_obsoletes
+
+        # Default attributes generated in __init__ from self.display_option_names
+        help_commands: bool
+        name: str | Literal[False]
+        version: str | Literal[False]
+        fullname: str | Literal[False]
+        author: str | Literal[False]
+        author_email: str | Literal[False]
+        maintainer: str | Literal[False]
+        maintainer_email: str | Literal[False]
+        contact: str | Literal[False]
+        contact_email: str | Literal[False]
+        url: str | Literal[False]
+        license: str | Literal[False]
+        licence: str | Literal[False]
+        description: str | Literal[False]
+        long_description: str | Literal[False]
+        platforms: str | list[str] | Literal[False]
+        classifiers: str | list[str] | Literal[False]
+        keywords: str | list[str] | Literal[False]
+        provides: list[str] | Literal[False]
+        requires: list[str] | Literal[False]
+        obsoletes: list[str] | Literal[False]
+
+
+class DistributionMetadata:
+    """Dummy class to hold the distribution meta-data: name, version,
+    author, and so forth.
+    """
+
+    _METHOD_BASENAMES = (
+        "name",
+        "version",
+        "author",
+        "author_email",
+        "maintainer",
+        "maintainer_email",
+        "url",
+        "license",
+        "description",
+        "long_description",
+        "keywords",
+        "platforms",
+        "fullname",
+        "contact",
+        "contact_email",
+        "classifiers",
+        "download_url",
+        # PEP 314
+        "provides",
+        "requires",
+        "obsoletes",
+    )
+
+    def __init__(
+        self, path: str | bytes | os.PathLike[str] | os.PathLike[bytes] | None = None
+    ) -> None:
+        if path is not None:
+            self.read_pkg_file(open(path))
+        else:
+            self.name: str | None = None
+            self.version: str | None = None
+            self.author: str | None = None
+            self.author_email: str | None = None
+            self.maintainer: str | None = None
+            self.maintainer_email: str | None = None
+            self.url: str | None = None
+            self.license: str | None = None
+            self.description: str | None = None
+            self.long_description: str | None = None
+            self.keywords: str | list[str] | None = None
+            self.platforms: str | list[str] | None = None
+            self.classifiers: str | list[str] | None = None
+            self.download_url: str | None = None
+            # PEP 314
+            self.provides: str | list[str] | None = None
+            self.requires: str | list[str] | None = None
+            self.obsoletes: str | list[str] | None = None
+
+    def read_pkg_file(self, file: IO[str]) -> None:
+        """Reads the metadata values from a file object."""
+        msg = message_from_file(file)
+
+        def _read_field(name: str) -> str | None:
+            value = msg[name]
+            if value and value != "UNKNOWN":
+                return value
+            return None
+
+        def _read_list(name):
+            values = msg.get_all(name, None)
+            if values == []:
+                return None
+            return values
+
+        metadata_version = msg['metadata-version']
+        self.name = _read_field('name')
+        self.version = _read_field('version')
+        self.description = _read_field('summary')
+        # we are filling author only.
+        self.author = _read_field('author')
+        self.maintainer = None
+        self.author_email = _read_field('author-email')
+        self.maintainer_email = None
+        self.url = _read_field('home-page')
+        self.license = _read_field('license')
+
+        if 'download-url' in msg:
+            self.download_url = _read_field('download-url')
+        else:
+            self.download_url = None
+
+        self.long_description = _read_field('description')
+        self.description = _read_field('summary')
+
+        if 'keywords' in msg:
+            self.keywords = _read_field('keywords').split(',')
+
+        self.platforms = _read_list('platform')
+        self.classifiers = _read_list('classifier')
+
+        # PEP 314 - these fields only exist in 1.1
+        if metadata_version == '1.1':
+            self.requires = _read_list('requires')
+            self.provides = _read_list('provides')
+            self.obsoletes = _read_list('obsoletes')
+        else:
+            self.requires = None
+            self.provides = None
+            self.obsoletes = None
+
+    def write_pkg_info(self, base_dir: str | os.PathLike[str]) -> None:
+        """Write the PKG-INFO file into the release tree."""
+        with open(
+            os.path.join(base_dir, 'PKG-INFO'), 'w', encoding='UTF-8'
+        ) as pkg_info:
+            self.write_pkg_file(pkg_info)
+
+    def write_pkg_file(self, file: SupportsWrite[str]) -> None:
+        """Write the PKG-INFO format data to a file object."""
+        version = '1.0'
+        if (
+            self.provides
+            or self.requires
+            or self.obsoletes
+            or self.classifiers
+            or self.download_url
+        ):
+            version = '1.1'
+
+        # required fields
+        file.write(f'Metadata-Version: {version}\n')
+        file.write(f'Name: {self.get_name()}\n')
+        file.write(f'Version: {self.get_version()}\n')
+
+        def maybe_write(header, val):
+            if val:
+                file.write(f"{header}: {val}\n")
+
+        # optional fields
+        maybe_write("Summary", self.get_description())
+        maybe_write("Home-page", self.get_url())
+        maybe_write("Author", self.get_contact())
+        maybe_write("Author-email", self.get_contact_email())
+        maybe_write("License", self.get_license())
+        maybe_write("Download-URL", self.download_url)
+        maybe_write("Description", rfc822_escape(self.get_long_description() or ""))
+        maybe_write("Keywords", ",".join(self.get_keywords()))
+
+        self._write_list(file, 'Platform', self.get_platforms())
+        self._write_list(file, 'Classifier', self.get_classifiers())
+
+        # PEP 314
+        self._write_list(file, 'Requires', self.get_requires())
+        self._write_list(file, 'Provides', self.get_provides())
+        self._write_list(file, 'Obsoletes', self.get_obsoletes())
+
+    def _write_list(self, file, name, values):
+        values = values or []
+        for value in values:
+            file.write(f'{name}: {value}\n')
+
+    # -- Metadata query methods ----------------------------------------
+
+    def get_name(self) -> str:
+        return self.name or "UNKNOWN"
+
+    def get_version(self) -> str:
+        return self.version or "0.0.0"
+
+    def get_fullname(self) -> str:
+        return self._fullname(self.get_name(), self.get_version())
+
+    @staticmethod
+    def _fullname(name: str, version: str) -> str:
+        """
+        >>> DistributionMetadata._fullname('setup.tools', '1.0-2')
+        'setup_tools-1.0.post2'
+        >>> DistributionMetadata._fullname('setup-tools', '1.2post2')
+        'setup_tools-1.2.post2'
+        >>> DistributionMetadata._fullname('setup-tools', '1.0-r2')
+        'setup_tools-1.0.post2'
+        >>> DistributionMetadata._fullname('setup.tools', '1.0.post')
+        'setup_tools-1.0.post0'
+        >>> DistributionMetadata._fullname('setup.tools', '1.0+ubuntu-1')
+        'setup_tools-1.0+ubuntu.1'
+        """
+        return "{}-{}".format(
+            canonicalize_name(name).replace('-', '_'),
+            canonicalize_version(version, strip_trailing_zero=False),
+        )
+
+    def get_author(self) -> str | None:
+        return self.author
+
+    def get_author_email(self) -> str | None:
+        return self.author_email
+
+    def get_maintainer(self) -> str | None:
+        return self.maintainer
+
+    def get_maintainer_email(self) -> str | None:
+        return self.maintainer_email
+
+    def get_contact(self) -> str | None:
+        return self.maintainer or self.author
+
+    def get_contact_email(self) -> str | None:
+        return self.maintainer_email or self.author_email
+
+    def get_url(self) -> str | None:
+        return self.url
+
+    def get_license(self) -> str | None:
+        return self.license
+
+    get_licence = get_license
+
+    def get_description(self) -> str | None:
+        return self.description
+
+    def get_long_description(self) -> str | None:
+        return self.long_description
+
+    def get_keywords(self) -> str | list[str]:
+        return self.keywords or []
+
+    def set_keywords(self, value: str | Iterable[str]) -> None:
+        self.keywords = _ensure_list(value, 'keywords')
+
+    def get_platforms(self) -> str | list[str] | None:
+        return self.platforms
+
+    def set_platforms(self, value: str | Iterable[str]) -> None:
+        self.platforms = _ensure_list(value, 'platforms')
+
+    def get_classifiers(self) -> str | list[str]:
+        return self.classifiers or []
+
+    def set_classifiers(self, value: str | Iterable[str]) -> None:
+        self.classifiers = _ensure_list(value, 'classifiers')
+
+    def get_download_url(self) -> str | None:
+        return self.download_url
+
+    # PEP 314
+    def get_requires(self) -> str | list[str]:
+        return self.requires or []
+
+    def set_requires(self, value: Iterable[str]) -> None:
+        import distutils.versionpredicate
+
+        for v in value:
+            distutils.versionpredicate.VersionPredicate(v)
+        self.requires = list(value)
+
+    def get_provides(self) -> str | list[str]:
+        return self.provides or []
+
+    def set_provides(self, value: Iterable[str]) -> None:
+        value = [v.strip() for v in value]
+        for v in value:
+            import distutils.versionpredicate
+
+            distutils.versionpredicate.split_provision(v)
+        self.provides = value
+
+    def get_obsoletes(self) -> str | list[str]:
+        return self.obsoletes or []
+
+    def set_obsoletes(self, value: Iterable[str]) -> None:
+        import distutils.versionpredicate
+
+        for v in value:
+            distutils.versionpredicate.VersionPredicate(v)
+        self.obsoletes = list(value)
+
+
+def fix_help_options(options):
+    """Convert a 4-tuple 'help_options' list as found in various command
+    classes to the 3-tuple form required by FancyGetopt.
+    """
+    return [opt[0:3] for opt in options]

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

@@ -0,0 +1,471 @@
+"""distutils.fancy_getopt
+
+Wrapper around the standard getopt module that provides the following
+additional features:
+  * short and long options are tied together
+  * options have help strings, so fancy_getopt could potentially
+    create a complete usage summary
+  * options set attributes of a passed-in object
+"""
+
+from __future__ import annotations
+
+import getopt
+import re
+import string
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+from .errors import DistutilsArgError, DistutilsGetoptError
+
+# Much like command_re in distutils.core, this is close to but not quite
+# the same as a Python NAME -- except, in the spirit of most GNU
+# utilities, we use '-' in place of '_'.  (The spirit of LISP lives on!)
+# The similarities to NAME are again not a coincidence...
+longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)'
+longopt_re = re.compile(rf'^{longopt_pat}$')
+
+# For recognizing "negative alias" options, eg. "quiet=!verbose"
+neg_alias_re = re.compile(f"^({longopt_pat})=!({longopt_pat})$")
+
+# This is used to translate long options to legitimate Python identifiers
+# (for use as attributes of some object).
+longopt_xlate = str.maketrans('-', '_')
+
+
+class FancyGetopt:
+    """Wrapper around the standard 'getopt()' module that provides some
+    handy extra functionality:
+      * short and long options are tied together
+      * options have help strings, and help text can be assembled
+        from them
+      * options set attributes of a passed-in object
+      * boolean options can have "negative aliases" -- eg. if
+        --quiet is the "negative alias" of --verbose, then "--quiet"
+        on the command line sets 'verbose' to false
+    """
+
+    def __init__(self, option_table=None):
+        # The option table is (currently) a list of tuples.  The
+        # tuples may have 3 or four values:
+        #   (long_option, short_option, help_string [, repeatable])
+        # if an option takes an argument, its long_option should have '='
+        # appended; short_option should just be a single character, no ':'
+        # in any case.  If a long_option doesn't have a corresponding
+        # short_option, short_option should be None.  All option tuples
+        # must have long options.
+        self.option_table = option_table
+
+        # 'option_index' maps long option names to entries in the option
+        # table (ie. those 3-tuples).
+        self.option_index = {}
+        if self.option_table:
+            self._build_index()
+
+        # 'alias' records (duh) alias options; {'foo': 'bar'} means
+        # --foo is an alias for --bar
+        self.alias = {}
+
+        # 'negative_alias' keeps track of options that are the boolean
+        # opposite of some other option
+        self.negative_alias = {}
+
+        # These keep track of the information in the option table.  We
+        # don't actually populate these structures until we're ready to
+        # parse the command-line, since the 'option_table' passed in here
+        # isn't necessarily the final word.
+        self.short_opts = []
+        self.long_opts = []
+        self.short2long = {}
+        self.attr_name = {}
+        self.takes_arg = {}
+
+        # And 'option_order' is filled up in 'getopt()'; it records the
+        # original order of options (and their values) on the command-line,
+        # but expands short options, converts aliases, etc.
+        self.option_order = []
+
+    def _build_index(self):
+        self.option_index.clear()
+        for option in self.option_table:
+            self.option_index[option[0]] = option
+
+    def set_option_table(self, option_table):
+        self.option_table = option_table
+        self._build_index()
+
+    def add_option(self, long_option, short_option=None, help_string=None):
+        if long_option in self.option_index:
+            raise DistutilsGetoptError(
+                f"option conflict: already an option '{long_option}'"
+            )
+        else:
+            option = (long_option, short_option, help_string)
+            self.option_table.append(option)
+            self.option_index[long_option] = option
+
+    def has_option(self, long_option):
+        """Return true if the option table for this parser has an
+        option with long name 'long_option'."""
+        return long_option in self.option_index
+
+    def get_attr_name(self, long_option):
+        """Translate long option name 'long_option' to the form it
+        has as an attribute of some object: ie., translate hyphens
+        to underscores."""
+        return long_option.translate(longopt_xlate)
+
+    def _check_alias_dict(self, aliases, what):
+        assert isinstance(aliases, dict)
+        for alias, opt in aliases.items():
+            if alias not in self.option_index:
+                raise DistutilsGetoptError(
+                    f"invalid {what} '{alias}': option '{alias}' not defined"
+                )
+            if opt not in self.option_index:
+                raise DistutilsGetoptError(
+                    f"invalid {what} '{alias}': aliased option '{opt}' not defined"
+                )
+
+    def set_aliases(self, alias):
+        """Set the aliases for this option parser."""
+        self._check_alias_dict(alias, "alias")
+        self.alias = alias
+
+    def set_negative_aliases(self, negative_alias):
+        """Set the negative aliases for this option parser.
+        'negative_alias' should be a dictionary mapping option names to
+        option names, both the key and value must already be defined
+        in the option table."""
+        self._check_alias_dict(negative_alias, "negative alias")
+        self.negative_alias = negative_alias
+
+    def _grok_option_table(self):  # noqa: C901
+        """Populate the various data structures that keep tabs on the
+        option table.  Called by 'getopt()' before it can do anything
+        worthwhile.
+        """
+        self.long_opts = []
+        self.short_opts = []
+        self.short2long.clear()
+        self.repeat = {}
+
+        for option in self.option_table:
+            if len(option) == 3:
+                long, short, help = option
+                repeat = 0
+            elif len(option) == 4:
+                long, short, help, repeat = option
+            else:
+                # the option table is part of the code, so simply
+                # assert that it is correct
+                raise ValueError(f"invalid option tuple: {option!r}")
+
+            # Type- and value-check the option names
+            if not isinstance(long, str) or len(long) < 2:
+                raise DistutilsGetoptError(
+                    f"invalid long option '{long}': must be a string of length >= 2"
+                )
+
+            if not ((short is None) or (isinstance(short, str) and len(short) == 1)):
+                raise DistutilsGetoptError(
+                    f"invalid short option '{short}': must a single character or None"
+                )
+
+            self.repeat[long] = repeat
+            self.long_opts.append(long)
+
+            if long[-1] == '=':  # option takes an argument?
+                if short:
+                    short = short + ':'
+                long = long[0:-1]
+                self.takes_arg[long] = True
+            else:
+                # Is option is a "negative alias" for some other option (eg.
+                # "quiet" == "!verbose")?
+                alias_to = self.negative_alias.get(long)
+                if alias_to is not None:
+                    if self.takes_arg[alias_to]:
+                        raise DistutilsGetoptError(
+                            f"invalid negative alias '{long}': "
+                            f"aliased option '{alias_to}' takes a value"
+                        )
+
+                    self.long_opts[-1] = long  # XXX redundant?!
+                self.takes_arg[long] = False
+
+            # If this is an alias option, make sure its "takes arg" flag is
+            # the same as the option it's aliased to.
+            alias_to = self.alias.get(long)
+            if alias_to is not None:
+                if self.takes_arg[long] != self.takes_arg[alias_to]:
+                    raise DistutilsGetoptError(
+                        f"invalid alias '{long}': inconsistent with "
+                        f"aliased option '{alias_to}' (one of them takes a value, "
+                        "the other doesn't"
+                    )
+
+            # Now enforce some bondage on the long option name, so we can
+            # later translate it to an attribute name on some object.  Have
+            # to do this a bit late to make sure we've removed any trailing
+            # '='.
+            if not longopt_re.match(long):
+                raise DistutilsGetoptError(
+                    f"invalid long option name '{long}' "
+                    "(must be letters, numbers, hyphens only"
+                )
+
+            self.attr_name[long] = self.get_attr_name(long)
+            if short:
+                self.short_opts.append(short)
+                self.short2long[short[0]] = long
+
+    def getopt(self, args: Sequence[str] | None = None, object=None):  # noqa: C901
+        """Parse command-line options in args. Store as attributes on object.
+
+        If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
+        'object' is None or not supplied, creates a new OptionDummy
+        object, stores option values there, and returns a tuple (args,
+        object).  If 'object' is supplied, it is modified in place and
+        'getopt()' just returns 'args'; in both cases, the returned
+        'args' is a modified copy of the passed-in 'args' list, which
+        is left untouched.
+        """
+        if args is None:
+            args = sys.argv[1:]
+        if object is None:
+            object = OptionDummy()
+            created_object = True
+        else:
+            created_object = False
+
+        self._grok_option_table()
+
+        short_opts = ' '.join(self.short_opts)
+        try:
+            opts, args = getopt.getopt(args, short_opts, self.long_opts)
+        except getopt.error as msg:
+            raise DistutilsArgError(msg)
+
+        for opt, val in opts:
+            if len(opt) == 2 and opt[0] == '-':  # it's a short option
+                opt = self.short2long[opt[1]]
+            else:
+                assert len(opt) > 2 and opt[:2] == '--'
+                opt = opt[2:]
+
+            alias = self.alias.get(opt)
+            if alias:
+                opt = alias
+
+            if not self.takes_arg[opt]:  # boolean option?
+                assert val == '', "boolean option can't have value"
+                alias = self.negative_alias.get(opt)
+                if alias:
+                    opt = alias
+                    val = 0
+                else:
+                    val = 1
+
+            attr = self.attr_name[opt]
+            # The only repeating option at the moment is 'verbose'.
+            # It has a negative option -q quiet, which should set verbose = False.
+            if val and self.repeat.get(attr) is not None:
+                val = getattr(object, attr, 0) + 1
+            setattr(object, attr, val)
+            self.option_order.append((opt, val))
+
+        # for opts
+        if created_object:
+            return args, object
+        else:
+            return args
+
+    def get_option_order(self):
+        """Returns the list of (option, value) tuples processed by the
+        previous run of 'getopt()'.  Raises RuntimeError if
+        'getopt()' hasn't been called yet.
+        """
+        if self.option_order is None:
+            raise RuntimeError("'getopt()' hasn't been called yet")
+        else:
+            return self.option_order
+
+    def generate_help(self, header=None):  # noqa: C901
+        """Generate help text (a list of strings, one per suggested line of
+        output) from the option table for this FancyGetopt object.
+        """
+        # Blithely assume the option table is good: probably wouldn't call
+        # 'generate_help()' unless you've already called 'getopt()'.
+
+        # First pass: determine maximum length of long option names
+        max_opt = 0
+        for option in self.option_table:
+            long = option[0]
+            short = option[1]
+            ell = len(long)
+            if long[-1] == '=':
+                ell = ell - 1
+            if short is not None:
+                ell = ell + 5  # " (-x)" where short == 'x'
+            if ell > max_opt:
+                max_opt = ell
+
+        opt_width = max_opt + 2 + 2 + 2  # room for indent + dashes + gutter
+
+        # Typical help block looks like this:
+        #   --foo       controls foonabulation
+        # Help block for longest option looks like this:
+        #   --flimflam  set the flim-flam level
+        # and with wrapped text:
+        #   --flimflam  set the flim-flam level (must be between
+        #               0 and 100, except on Tuesdays)
+        # Options with short names will have the short name shown (but
+        # it doesn't contribute to max_opt):
+        #   --foo (-f)  controls foonabulation
+        # If adding the short option would make the left column too wide,
+        # we push the explanation off to the next line
+        #   --flimflam (-l)
+        #               set the flim-flam level
+        # Important parameters:
+        #   - 2 spaces before option block start lines
+        #   - 2 dashes for each long option name
+        #   - min. 2 spaces between option and explanation (gutter)
+        #   - 5 characters (incl. space) for short option name
+
+        # Now generate lines of help text.  (If 80 columns were good enough
+        # for Jesus, then 78 columns are good enough for me!)
+        line_width = 78
+        text_width = line_width - opt_width
+        big_indent = ' ' * opt_width
+        if header:
+            lines = [header]
+        else:
+            lines = ['Option summary:']
+
+        for option in self.option_table:
+            long, short, help = option[:3]
+            text = wrap_text(help, text_width)
+            if long[-1] == '=':
+                long = long[0:-1]
+
+            # Case 1: no short option at all (makes life easy)
+            if short is None:
+                if text:
+                    lines.append(f"  --{long:<{max_opt}}  {text[0]}")
+                else:
+                    lines.append(f"  --{long:<{max_opt}}")
+
+            # Case 2: we have a short option, so we have to include it
+            # just after the long option
+            else:
+                opt_names = f"{long} (-{short})"
+                if text:
+                    lines.append(f"  --{opt_names:<{max_opt}}  {text[0]}")
+                else:
+                    lines.append(f"  --{opt_names:<{max_opt}}")
+
+            for ell in text[1:]:
+                lines.append(big_indent + ell)
+        return lines
+
+    def print_help(self, header=None, file=None):
+        if file is None:
+            file = sys.stdout
+        for line in self.generate_help(header):
+            file.write(line + "\n")
+
+
+def fancy_getopt(options, negative_opt, object, args: Sequence[str] | None):
+    parser = FancyGetopt(options)
+    parser.set_negative_aliases(negative_opt)
+    return parser.getopt(args, object)
+
+
+WS_TRANS = {ord(_wschar): ' ' for _wschar in string.whitespace}
+
+
+def wrap_text(text, width):
+    """wrap_text(text : string, width : int) -> [string]
+
+    Split 'text' into multiple lines of no more than 'width' characters
+    each, and return the list of strings that results.
+    """
+    if text is None:
+        return []
+    if len(text) <= width:
+        return [text]
+
+    text = text.expandtabs()
+    text = text.translate(WS_TRANS)
+    chunks = re.split(r'( +|-+)', text)
+    chunks = [ch for ch in chunks if ch]  # ' - ' results in empty strings
+    lines = []
+
+    while chunks:
+        cur_line = []  # list of chunks (to-be-joined)
+        cur_len = 0  # length of current line
+
+        while chunks:
+            ell = len(chunks[0])
+            if cur_len + ell <= width:  # can squeeze (at least) this chunk in
+                cur_line.append(chunks[0])
+                del chunks[0]
+                cur_len = cur_len + ell
+            else:  # this line is full
+                # drop last chunk if all space
+                if cur_line and cur_line[-1][0] == ' ':
+                    del cur_line[-1]
+                break
+
+        if chunks:  # any chunks left to process?
+            # if the current line is still empty, then we had a single
+            # chunk that's too big too fit on a line -- so we break
+            # down and break it up at the line width
+            if cur_len == 0:
+                cur_line.append(chunks[0][0:width])
+                chunks[0] = chunks[0][width:]
+
+            # all-whitespace chunks at the end of a line can be discarded
+            # (and we know from the re.split above that if a chunk has
+            # *any* whitespace, it is *all* whitespace)
+            if chunks[0][0] == ' ':
+                del chunks[0]
+
+        # and store this line in the list-of-all-lines -- as a single
+        # string, of course!
+        lines.append(''.join(cur_line))
+
+    return lines
+
+
+def translate_longopt(opt):
+    """Convert a long option name to a valid Python identifier by
+    changing "-" to "_".
+    """
+    return opt.translate(longopt_xlate)
+
+
+class OptionDummy:
+    """Dummy class just used as a place to hold command-line option
+    values as instance attributes."""
+
+    def __init__(self, options: Sequence[Any] = []):
+        """Create a new OptionDummy instance.  The attributes listed in
+        'options' will be initialized to None."""
+        for opt in options:
+            setattr(self, opt, None)
+
+
+if __name__ == "__main__":
+    text = """\
+Tra-la-la, supercalifragilisticexpialidocious.
+How *do* you spell that odd word, anyways?
+(Someone ask Mary -- she'll know [or she'll
+say, "How should I know?"].)"""
+
+    for w in (10, 20, 30, 40):
+        print(f"width: {w}")
+        print("\n".join(wrap_text(text, w)))
+        print()

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

@@ -0,0 +1,9 @@
+import importlib
+
+from .compilers.C import unix
+
+UnixCCompiler = unix.Compiler
+
+# ensure import of unixccompiler implies ccompiler imported
+# (pypa/setuptools#4871)
+importlib.import_module('distutils.ccompiler')

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/legacy/ms2/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/maniskill3_environment/figures/environment_demos/AnymalC-Reach-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:696f4c0ae90a56d0edecfba6bcecdf4ff0e06ef5888920a221cd5d8446e46301
+size 56992

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/AnymalC-Spin-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1583ad114c6956c901acaddcc2a59a85e99e6089005942fbfa9a6e52802c55b7
+size 440488

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/AssemblingKits-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c85dc660adcc569e80c35dee229991984ac4b97b1f41ca106f082140ec1c28f5
+size 207136

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/FMBAssembly1Easy.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b2cbca524b9acd618a554273c1335612ef795939a57b977e9ca422104dc1272
+size 1175013

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/LiftPegUpright-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31b1f1fd90966c26b23e7b21228bd4e0c341d4b51e4e3d62786217c86123fcec
+size 269267

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/MS-CartpoleBalance-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:298d70c05e3f5fff86ec804e101ab6e237ec194c299a62b9ca3898a50635d8b0
+size 27453

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/ManiSkill-HAB_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd51f313f1e6e8d3ffdf07a5c76b6c702424b18ed880825c546842185de1035a
+size 2121211

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/OpenCabinetDrawer-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca5ff1da6430b9eec2b0d7c749a73392d60df7ad2cdfa99190d0730e265bd564
+size 43081

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/PegInsertionSide-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eeeda0cf62b7888c34b49707c3980408ad8f9bbb038930419337925b0251dd37
+size 125420

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/PickClutterYCB-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:447e1bb757c05969406446094fd87f1e7129c4fa8ed5dcaf3471d6f4f9db5371
+size 131551

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/PickCube-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f3e4ffbcd759ca274e632a1cce600d63a650a57f5985fde9272a1d5c1a40acc
+size 77049

project/ManiSkill3/src/maniskill3_environment/figures/environment_demos/PickSingleYCB-v1_rt.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2adf6c3e2d137bb60559f549d58cc94e0210010b9bdc4c1afcd37a7e8e84f60e
+size 165740