Add files using upload-large-folder tool

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: hang-yin
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. Ubuntu 22.04]
+ - Isaac Sim Version [e.g. 4.1.0]
+ - OmniGibson Version [e.g. 1.1.0]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: cgokmen
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,10 @@
+---
+name: Question
+about: PLEASE POST QUESTIONS IN THE DISCUSSIONS TAB
+title: ''
+labels: question
+assignees: ''
+
+---
+
+**PLEASE POST QUESTIONS IN THE DISCUSSIONS TAB**

.github/workflows/build-push-containers.yml

@@ -0,0 +1,166 @@
+name: build-push-containers
+
+on:
+  release:
+    types: [published]
+  push:
+    branches:
+      - 'main'
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+      - 
+        name: Check disk space
+        run: df . -h
+      - 
+        name: Free disk space
+        run: |
+          sudo docker rmi $(docker image ls -aq) >/dev/null 2>&1 || true
+          sudo rm -rf \
+            /usr/share/dotnet /usr/local/lib/android /opt/ghc \
+            /usr/local/share/powershell /usr/share/swift /usr/local/.ghcup \
+            /usr/lib/jvm /opt/hostedtoolcache/CodeQL || true
+          echo "some directories deleted"
+          sudo apt install aptitude -y >/dev/null 2>&1
+          sudo aptitude purge aria2 ansible azure-cli shellcheck rpm xorriso zsync \
+            esl-erlang firefox gfortran-8 gfortran-9 google-chrome-stable \
+            google-cloud-sdk imagemagick \
+            libmagickcore-dev libmagickwand-dev libmagic-dev ant ant-optional kubectl \
+            mercurial apt-transport-https mono-complete libmysqlclient \
+            unixodbc-dev yarn chrpath libssl-dev libxft-dev \
+            libfreetype6 libfreetype6-dev libfontconfig1 libfontconfig1-dev \
+            snmp pollinate libpq-dev postgresql-client powershell ruby-full \
+            sphinxsearch subversion mongodb-org azure-cli microsoft-edge-stable \
+            -y -f >/dev/null 2>&1
+          sudo aptitude purge google-cloud-sdk -f -y >/dev/null 2>&1
+          sudo aptitude purge microsoft-edge-stable -f -y >/dev/null 2>&1 || true
+          sudo apt purge microsoft-edge-stable -f -y >/dev/null 2>&1 || true
+          sudo aptitude purge '~n ^mysql' -f -y >/dev/null 2>&1
+          sudo aptitude purge '~n ^php' -f -y >/dev/null 2>&1
+          sudo aptitude purge '~n ^dotnet' -f -y >/dev/null 2>&1
+          sudo apt-get autoremove -y >/dev/null 2>&1
+          sudo apt-get autoclean -y >/dev/null 2>&1
+          echo "some packages purged"
+      - 
+        name: Check disk space
+        run: |
+          df . -h
+      -
+        name: Checkout
+        uses: actions/checkout@v4
+      -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      -
+        name: Login to NVCR
+        uses: docker/login-action@v3
+        with:
+          registry: nvcr.io
+          username: ${{ secrets.NVCR_USERNAME }}
+          password: ${{ secrets.NVCR_PASSWORD }}   
+      -
+        name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_PASSWORD }}
+      -
+        name: Metadata for prod Image
+        id: meta-prod
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            stanfordvl/omnigibson
+          tags: |
+            type=ref,event=branch
+            type=semver,pattern={{version}}
+      -
+        name: Metadata for dev Image
+        id: meta-dev
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            stanfordvl/omnigibson-dev
+          tags: |
+            type=ref,event=branch
+            type=semver,pattern={{version}}
+      -
+        name: Metadata for vscode Image
+        id: meta-vscode
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            stanfordvl/omnigibson-vscode
+          tags: |
+            type=ref,event=branch
+            type=semver,pattern={{version}}
+      -
+        name: Metadata for actions Image
+        id: meta-actions
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            stanfordvl/omnigibson-gha
+          tags: |
+            # We only push to the latest tag for the actions image
+            type=raw,value=latest
+      -
+        name: Build and push prod image
+        id: build-prod
+        uses: docker/build-push-action@v5
+        with:
+          context: OmniGibson/
+          push: true
+          tags: ${{ steps.meta-prod.outputs.tags }}
+          labels: ${{ steps.meta-prod.outputs.labels }}
+          file: OmniGibson/docker/prod.Dockerfile
+          cache-from: type=registry,ref=stanfordvl/omnigibson:build-cache
+          cache-to: type=registry,ref=stanfordvl/omnigibson:build-cache,mode=max
+
+      -
+        name: Build and push dev image
+        id: build-dev
+        uses: docker/build-push-action@v5
+        with:
+          context: OmniGibson/
+          build-args: "DEV_MODE=1"
+          push: true
+          tags: ${{ steps.meta-dev.outputs.tags }}
+          labels: ${{ steps.meta-dev.outputs.labels }}
+          file: OmniGibson/docker/prod.Dockerfile
+          cache-from: type=registry,ref=stanfordvl/omnigibson:build-cache  # OK to share cache here.
+          cache-to: type=registry,ref=stanfordvl/omnigibson:build-cache,mode=max
+
+      - name: Update vscode image Dockerfile with prod image tag
+        run: |
+          sed -i "s/omnigibson:latest/omnigibson@${{ steps.build-prod.outputs.digest }}/g" OmniGibson/docker/vscode.Dockerfile && cat OmniGibson/docker/vscode.Dockerfile
+      -
+        name: Build and push vscode image
+        id: build-vscode
+        uses: docker/build-push-action@v5
+        with:
+          context: OmniGibson/
+          push: true
+          tags: ${{ steps.meta-vscode.outputs.tags }}
+          labels: ${{ steps.meta-vscode.outputs.labels }}
+          file: OmniGibson/docker/vscode.Dockerfile
+          cache-from: type=registry,ref=stanfordvl/omnigibson:build-cache  # OK to share cache here.
+          cache-to: type=registry,ref=stanfordvl/omnigibson:build-cache,mode=max
+
+      - name: Update actions image Dockerfile with dev image tag
+        run: |
+          sed -i "s/omnigibson-dev:latest/omnigibson-dev@${{ steps.build-dev.outputs.digest }}/g" OmniGibson/docker/gh-actions/Dockerfile && cat OmniGibson/docker/gh-actions/Dockerfile
+      -
+        name: Build and push actions image
+        id: build-actions
+        uses: docker/build-push-action@v5
+        with:
+          context: OmniGibson/docker/gh-actions
+          push: true
+          tags: ${{ steps.meta-actions.outputs.tags }}
+          labels: ${{ steps.meta-actions.outputs.labels }}
+          file: OmniGibson/docker/gh-actions/Dockerfile
+          cache-from: type=registry,ref=stanfordvl/omnigibson:build-cache  # OK to share cache here.
+          cache-to: type=registry,ref=stanfordvl/omnigibson:build-cache,mode=max

.github/workflows/build-website.yml

@@ -0,0 +1,93 @@
+name: Build and deploy BEHAVIOR website
+
+on:
+  schedule:
+    - cron: "0 10 * * *"  # Every day at 10am
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+
+
+jobs:
+  build:
+    runs-on: [self-hosted, linux]
+
+    defaults:
+      run:
+        shell: micromamba run -n omnigibson /bin/bash -leo pipefail {0}
+
+    steps:
+      - name: Fix home
+        run: echo "HOME=/root" >> $GITHUB_ENV
+
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Install BDDL
+        working-directory: bddl
+        run: pip install -e .
+
+      - name: Install
+        working-directory: OmniGibson
+        run: pip install -e .[dev]
+
+      - name: Build docs
+        run: mkdocs build   # TODO: Shouldn't we copy over the src directory here?
+
+      # # See if we need to rebuild the whole thing
+      # - name: Get BDDL hash
+      #   id: bddl-hash
+      #   working-directory: bddl
+      #   run: echo hash=$(git rev-parse HEAD) >> "$GITHUB_OUTPUT"
+
+      # - name: Get knowledgebase hash
+      #   id: website-hash
+      #   working-directory: knowledgebase
+      #   run: echo hash=$(git rev-parse HEAD) >> "$GITHUB_OUTPUT"
+
+      # - name: Check cache for overall data
+      #   id: cache-knowledgebase
+      #   uses: actions/cache@v3
+      #   with:
+      #     key: knowledgebase-${{ steps.website-hash.outputs.hash }}-${{ steps.bddl-hash.outputs.hash }}
+      #     path: README.md
+      #     lookup-only: true
+
+      # - if: ${{ steps.cache-knowledgebase.outputs.cache-hit != 'true' }}
+      - name: Install other dependencies
+        working-directory: knowledgebase
+        run: pip install -r requirements.txt
+
+      # - if: ${{ steps.cache-knowledgebase.outputs.cache-hit != 'true' }}
+      - name: Generate static knowledgebase site
+        working-directory: knowledgebase
+        run: python build_static_site.py
+
+      - name: Move knowledgebase to combined site
+        run: cp -R knowledgebase/build/knowledgebase site
+
+      - name: Upload pages artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: site/
+
+  # Deploy on github pages
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/examples-as-test.yml

@@ -0,0 +1,111 @@
+name: Examples as Tests
+
+on:
+  schedule:
+    # * is a special character in YAML so you have to quote this string
+    # Format: minute hour day-of-month month day-of-week(starts on sunday)
+    # Scheduled for 2 am, everyday
+    - cron: '0 10 * * *'
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  generate_example_tests:
+    name: Generate Example Tests
+    runs-on: [self-hosted, linux, gpu, dataset-enabled]
+    defaults:
+      run:
+        shell: micromamba run -n omnigibson /bin/bash -leo pipefail {0}
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+             
+      - name: Install
+        run: pip install -e .[dev,primitives]
+
+      - name: Generate example tests
+        run: python tests/create_tests_of_examples.py
+
+      - name: Get list of generated tests
+        id: get-test-list
+        run: |
+          echo "example_tests=$(cat tests/example_tests.json)" >> $GITHUB_OUTPUT
+
+    outputs:
+      example_tests: ${{ steps.get-test-list.outputs.example_tests }}
+  
+  run_test:
+    name: Run Example Tests
+    needs: [generate_example_tests]
+    runs-on: [self-hosted, linux, gpu, dataset-enabled]
+
+    strategy:
+      matrix:
+        test_file:
+          - ${{ needs.generate_example_tests.outputs.example_tests != '' && fromJson(needs.generate_example_tests.outputs.example_tests) }}
+      fail-fast: true
+
+    defaults:
+      run:
+        shell: micromamba run -n omnigibson /bin/bash -leo pipefail {0}
+
+    steps:
+      - name: Check for generated tests
+        if: ${{ needs.generate_example_tests.outputs.example_tests == '' }}
+        run: |
+          echo "No tests were generated. Failing the job."
+          exit 1
+
+      - name: Fix home
+        run: echo "HOME=/root" >> $GITHUB_ENV
+
+      - name: Checkout source
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Install
+        run: pip install -e .[dev,primitives]
+
+      - name: Run tests
+        run: pytest -s tests/tests_of_examples/${{ matrix.test_file }}.py --junitxml=${{ matrix.test_file }}.xml && cp ${{ matrix.test_file }}.xml ${GITHUB_WORKSPACE}/
+
+      - name: Deploy artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ github.run_id }}-tests-${{ matrix.test_file }}
+          path: ${{ matrix.test_file }}.xml
+
+      - name: Fail on failure or error
+        run: grep -Eq "<failure|error" ${{ matrix.test_file }}.xml; if [ $? -eq 0 ]; then exit 1; else exit 0; fi
+
+  upload_report:
+    name: Compile Example Test Report
+    runs-on: [self-hosted, linux]
+    defaults:
+      run:
+        shell: micromamba run -n omnigibson /bin/bash -leo pipefail {0}
+    needs: [run_test]
+    steps:
+      - name: Pull reports
+        uses: actions/download-artifact@v4
+        with:
+          merge-multiple: True
+      - name: Example Test Report0
+        uses: dorny/test-reporter@v1
+        with:
+          name: Example Test Results
+          path: "*_test.xml"
+          reporter: java-junit
+          fail-on-error: 'true'
+          fail-on-empty: 'true'
+
+      # - name: Upload coverage to Codecov
+      #   uses: codecov/codecov-action@v2.1.0
+      #   with:
+      #     token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/profiling.yml

@@ -0,0 +1,51 @@
+name: Profiling
+
+on: 
+  workflow_dispatch:
+  push:
+    branches:
+      - og-develop
+
+permissions:
+  # deployments permission to deploy GitHub pages website
+  deployments: write
+  # contents permission to update profiling contents in gh-pages branch
+  contents: write
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  profiling:
+    name: Speed Profiling
+    runs-on: [self-hosted, linux, gpu, dataset-enabled]
+
+    defaults:
+      run:
+        shell: micromamba run -n omnigibson /bin/bash -leo pipefail {0}
+
+    steps:
+      - name: Fix home
+        run: echo "HOME=/root" >> $GITHUB_ENV
+
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Install
+        run: pip install -e .[dev,primitives]
+      
+      - name: Run performance benchmark
+        run: bash scripts/profiling.sh
+          
+      - name: Store benchmark result
+        uses: benchmark-action/github-action-benchmark@v1
+        with:
+          tool: 'customSmallerIsBetter'
+          output-file-path: output.json
+          benchmark-data-dir-path: profiling
+          fail-on-alert: false
+          alert-threshold: '200%'
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          comment-on-alert: false
+          auto-push: true

.github/workflows/publish-pypi.yml

@@ -0,0 +1,38 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  pypi-publish:
+    name: Upload release to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/omnigibson
+    permissions:
+      id-token: write  # IMPORTANT: this permission is mandatory for trusted publishing
+      contents: read
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine
+    - name: Build package
+      run: python setup.py sdist
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@v1.10.2

.github/workflows/pull-sheets-bddl.yml

@@ -0,0 +1,99 @@
+name: Sync bddl Google Sheets data
+
+on:
+  schedule:
+    - cron: "0 9 * * *"  # Every day at 9am
+  workflow_dispatch:
+  # push:
+  #   branches:
+  #     - main
+
+jobs:
+  pull-sheets:
+    name: Sync Google Sheets data
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+    
+    - name: Setup python
+      uses: actions/setup-python@v2
+      with:
+        python-version: "3.10"
+        architecture: x64
+
+    - name: Authenticate on Google Cloud
+      uses: 'google-github-actions/auth@v1'
+      with:
+        credentials_json: '${{ secrets.GCP_CREDENTIALS }}'
+
+    - uses: webfactory/ssh-agent@v0.9.0
+      with:
+          ssh-private-key: ${{ secrets.SHEETS_DEPLOY_KEY }}
+
+    # See if we need to re-pull any asset_pipeline data from DVC.
+    - name: Check cache for pipeline data
+      id: cache-pipeline
+      uses: actions/cache@v3
+      with:
+        key: asset_pipeline-${{ hashFiles('asset_pipeline/dvc.lock') }}
+        path: |
+          asset_pipeline/artifacts/pipeline/combined_room_object_list.json
+          asset_pipeline/artifacts/pipeline/object_inventory.json
+
+    - if: ${{ steps.cache-pipeline.outputs.cache-hit != 'true' }}
+      name: Install dvc
+      run: pip install dvc[gs]
+
+    - if: ${{ steps.cache-pipeline.outputs.cache-hit != 'true' }}
+      name: Pull dvc data
+      working-directory: asset_pipeline
+      run: dvc pull combined_room_object_list object_inventory
+
+    - if: ${{ steps.cache-pipeline.outputs.cache-hit != 'true' }}
+      name: Unprotect data
+      working-directory: asset_pipeline
+      run: dvc unprotect artifacts/pipeline/combined_room_object_list.json artifacts/pipeline/object_inventory.json
+
+    - name: Copy over pipeline files
+      run: cp asset_pipeline/artifacts/pipeline/{combined_room_object_list,object_inventory}.json bddl/bddl/generated_data
+
+    - name: Combine complaint files from asset_pipeline
+      run: |
+        python3 -c "
+        import glob, json
+        files = glob.glob('asset_pipeline/cad/*/*/complaints.json')
+        combined = []
+        for file in files:
+            with open(file) as f:
+                combined.extend(json.load(f))
+        combined.sort(key=lambda x: (x['object'], x['type'], x['additional_info'], x['complaint'], x['processed']))
+        with open('bddl/bddl/generated_data/complaints.json', 'w') as f:
+            json.dump(combined, f, indent=2)
+        "
+
+    - name: Install BDDL
+      working-directory: bddl
+      run: pip install -e .
+
+    - name: Install dev requirements
+      working-directory: bddl
+      run: pip install -r requirements-dev.txt
+
+    - name: Refresh sheets data
+      working-directory: bddl
+      run: python -m bddl.data_generation.pull_sheets
+
+    - name: Refresh derivative data
+      working-directory: bddl
+      run: python -m bddl.data_generation.generate_datafiles
+
+    # We want to check if the knowledgebase imports correctly, and if not, we want to NOT do the pull
+    # because it will result in a permamently broken knowledgebase that blocks sampling and website.
+    - name: Test if knowledgebase loads OK
+      run: python -c "from bddl.knowledge_base import *"
+
+    - uses: stefanzweifel/git-auto-commit-action@v4
+      with:
+        commit_message: "Sync bddl Google Sheets data"

.github/workflows/pull-sheets.yml

@@ -0,0 +1,44 @@
+name: Sync asset pipeline Google Sheets data
+
+on:
+  schedule:
+    - cron: "0 10 * * *"  # Every day at 10am
+  workflow_dispatch:
+  # push:
+  #   branches:
+  #     - main
+
+jobs:
+  pull-sheets:
+    name: Sync Google Sheets data
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+    
+    - name: Setup python
+      uses: actions/setup-python@v2
+      with:
+        python-version: "3.8"
+        architecture: x64
+
+    - name: Install requirements
+      run: pip install gspread pandas
+
+    - name: Authenticate on Google Cloud
+      uses: 'google-github-actions/auth@v1'
+      with:
+        credentials_json: '${{ secrets.GCP_CREDENTIALS }}'
+
+    - uses: webfactory/ssh-agent@v0.9.0
+      with:
+          ssh-private-key: ${{ secrets.SHEETS_DEPLOY_KEY }}
+
+    - name: Refresh sheets data
+      run: python -m b1k_pipeline.sync_sheets
+      working-directory: asset_pipeline
+
+    - uses: stefanzweifel/git-auto-commit-action@v4
+      with:
+        commit_message: "Sync Google Sheets data"

.github/workflows/tests.yml

@@ -0,0 +1,117 @@
+name: Tests
+
+on: 
+  pull_request: 
+  push: 
+    branches: 
+      - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.head_ref || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  run_test:
+    name: Run Tests
+    runs-on: [self-hosted, linux, gpu, dataset-enabled]
+
+    strategy:
+      fail-fast: false
+      matrix:
+        test_file:
+          - test_controllers
+          - test_curobo
+          - test_data_collection
+          - test_dump_load_states
+          - test_envs
+          - test_multiple_envs
+          - test_object_removal
+          - test_object_states
+          - test_primitives
+          - test_robot_states_flatcache
+          - test_robot_states_no_flatcache
+          - test_robot_teleoperation
+          - test_scene_graph
+          - test_sensors
+          - test_symbolic_primitives
+          - test_systems
+          - test_transform_utils
+          - test_transition_rules
+
+    defaults:
+      run:
+        shell: micromamba run -n omnigibson /bin/bash -leo pipefail {0}
+        working-directory: ${{ github.workspace }}/OmniGibson
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Install BDDL
+        run: pip install -e .
+        working-directory: ${{ github.workspace }}/bddl
+
+      - name: Install OmniGibson
+        run: pip install -e .[dev,primitives,eval] --no-build-isolation
+
+      - name: Print env
+        run: printenv
+
+      - name: Run tests
+        run: pytest -s tests/${{ matrix.test_file }}.py --junitxml=${{ matrix.test_file }}.xml
+        continue-on-error: true
+
+      - name: Deploy artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ github.run_id }}-tests-${{ matrix.test_file }}
+          path: OmniGibson/${{ matrix.test_file }}.xml
+
+      - name: Check for failures, errors, or missing XML
+        run: |
+          if [ ! -f ${{ matrix.test_file }}.xml ]; then
+            echo "Error: XML file not found, probably due to segfault"
+            exit 1
+          elif grep -Eq 'failures="[1-9][0-9]*"|errors="[1-9][0-9]*"' ${{ matrix.test_file }}.xml; then
+            echo "Error: Test failures or errors found"
+            exit 1
+          else
+            echo "All tests passed successfully"
+            exit 0
+          fi
+
+  upload_report:
+    name: Compile Report
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: micromamba run -n omnigibson /bin/bash -leo pipefail {0}
+    needs: [run_test]
+    if: always()
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v2
+        with:
+          submodules: true
+          path: behavior1k-src
+      - name: Pull reports
+        uses: actions/download-artifact@v4
+        with:
+          path: behavior1k-src/OmniGibson
+          merge-multiple: true
+      - name: Test Report0
+        uses: dorny/test-reporter@v1
+        with:
+          name: Test Results
+          working-directory: behavior1k-src/OmniGibson
+          path: test_*.xml
+          reporter: java-junit
+          fail-on-error: 'false'
+          fail-on-empty: 'false'
+
+      # - name: Upload coverage to Codecov
+      #   uses: codecov/codecov-action@v2.1.0
+      #   with:
+      #     token: ${{ secrets.CODECOV_TOKEN }}

OmniGibson/docker/README.md

@@ -0,0 +1,22 @@
+# Requirements
+
+- Modern Linux distribution (Ubuntu 20.04, Fedora 36, etc.)
+- RTX capable Nvidia graphics card (20 series or newer,)
+- Up-to-date NVIDIA drivers
+
+# Usage
+
+**The below instructions concern the usage of OmniGibson containers with self-built images. Please see the BEHAVIOR-1K docs for instructions on how to pull and run a cloud image.**
+
+1. Set up the NVIDIA Docker Runtime and login to the NVIDIA Container Registry
+See [here](https://www.pugetsystems.com/labs/hpc/how-to-setup-nvidia-docker-and-ngc-registry-on-your-workstation-part-4-accessing-the-ngc-registry-1115/) for details.
+
+2. Build the container. **From the OmniGibson root**, run: `./docker/build_docker.sh`
+
+3. Run the container
+* To get a shell inside a container with GUI: `sudo ./docker/run_docker_gui.sh`
+* To get a jupyter notebook: `sudo ./docker/run_docker_notebook.sh`
+* To get access to a shell inside a headless container `sudo ./docker/run_docker.sh`
+
+# Development
+To push a Docker container, run: `sudo ./docker/push_docker.sh`

OmniGibson/docker/build_docker.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -e -o pipefail
+
+docker build \
+    -t stanfordvl/omnigibson:latest \
+    -t stanfordvl/omnigibson:$(sed -ne "s/.*version= *['\"]\([^'\"]*\)['\"] *.*/\1/p" setup.py) \
+    -f docker/prod.Dockerfile \
+    .
+
+# Pass the DEV_MODE=1 arg to the docker build command to build the development image
+docker build \
+    -t stanfordvl/omnigibson-dev:latest \
+    -t stanfordvl/omnigibson-dev:$(sed -ne "s/.*version= *['\"]\([^'\"]*\)['\"] *.*/\1/p" setup.py) \
+    -f docker/prod.Dockerfile \
+    --build-arg DEV_MODE=1 \
+    .
+
+docker build \
+    -t stanfordvl/omnigibson-vscode:latest \
+    -f docker/vscode.Dockerfile \
+    .
+
+docker build \
+    -t stanfordvl/omnigibson-colab:latest \
+    -f docker/colab.Dockerfile \
+    .

OmniGibson/docker/colab.Dockerfile

@@ -0,0 +1,21 @@
+FROM stanfordvl/omnigibson:colab-docker
+
+# environment settings
+ARG DEBIAN_FRONTEND="noninteractive"
+ENV OMNIGIBSON_HEADLESS="1"
+ENV OMNIGIBSON_REMOTE_STREAMING="webrtc"
+
+# Fix the JS file to allow for remote streaming on the same port (80)
+RUN sed -i "s/49100/80/g" /isaac-sim/extscache/omni.services.streamclient.webrtc-1.3.8/web/js/kit-player.js && \
+    sed -i -E 's/IsValidIPv4=.*test\(e\)/IsValidIPv4=function(e){return true/g' /isaac-sim/extscache/omni.services.streamclient.webrtc-1.3.8/web/js/kit-player.js
+
+# Install nginx
+RUN apt-get update && apt-get install -y nginx && apt-get clean
+
+# Download the demo dataset and the assets
+RUN python -m omnigibson.utils.asset_utils --download_omnigibson_robot_assets --download_behavior_1k_assets --accept_license
+
+# Add the nginx configuration file
+ADD docker/nginx.conf /etc/nginx/sites-available/default
+
+CMD nginx && python -m omnigibson.examples.robots.robot_control_example --quickstart

OmniGibson/docker/gh-actions/Dockerfile

@@ -0,0 +1,120 @@
+FROM stanfordvl/omnigibson-dev:og-develop
+
+ARG DUMB_INIT_VERSION="1.2.2"
+ARG GIT_CORE_PPA_KEY="A1715D88E1DF1F24"
+
+ENV GIT_LFS_VERSION="3.2.0"
+ENV LANG=en_US.UTF-8
+ENV LANGUAGE=en_US.UTF-8
+ENV LC_ALL=en_US.UTF-8
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+ENV DEBIAN_FRONTEND=noninteractive
+# hadolint ignore=SC2086,DL3015,DL3008,DL3013,SC2015
+RUN echo en_US.UTF-8 UTF-8 >> /etc/locale.gen \
+  && apt-get update \
+  && apt-get install -y --no-install-recommends gnupg \
+  && ( \
+    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys ${GIT_CORE_PPA_KEY} \
+      || apt-key adv --keyserver pgp.mit.edu --recv-keys ${GIT_CORE_PPA_KEY} \
+      || apt-key adv --keyserver keyserver.pgp.com --recv-keys ${GIT_CORE_PPA_KEY} \
+  ) \
+  && apt-get update \
+  && apt-get install -y --no-install-recommends \
+    gnupg \
+    lsb-release \
+    curl \
+    tar \
+    unzip \
+    zip \
+    apt-transport-https \
+    ca-certificates \
+    sudo \
+    gpg-agent \
+    software-properties-common \
+    build-essential \
+    zlib1g-dev \
+    zstd \
+    gettext \
+    libcurl4-openssl-dev \
+    inetutils-ping \
+    jq \
+    wget \
+    dirmngr \
+    openssh-client \
+    locales \
+    python3-pip \
+    python3-setuptools \
+    python3-venv \
+    python3 \
+    dumb-init \
+    nodejs \
+    rsync \
+    libpq-dev \
+    gosu \
+    pkg-config \
+    graphviz \
+  && DPKG_ARCH="$(dpkg --print-architecture)" \
+  && LSB_RELEASE_CODENAME="$(lsb_release --codename | cut -f2)" \
+  && sed -e 's/Defaults.*env_reset/Defaults env_keep = "HTTP_PROXY HTTPS_PROXY NO_PROXY FTP_PROXY http_proxy https_proxy no_proxy ftp_proxy"/' -i /etc/sudoers \
+  && echo deb http://ppa.launchpad.net/git-core/ppa/ubuntu $([[ $(grep -E '^ID=' /etc/os-release | sed 's/.*=//g') == "ubuntu" ]] && (grep VERSION_CODENAME /etc/os-release | sed 's/.*=//g') || echo bionic) main>/etc/apt/sources.list.d/git-core.list \
+  && apt-get update \
+  && ( apt-get install -y --no-install-recommends git || apt-get install -t stable -y --no-install-recommends git || apt-get install -y --no-install-recommends git=1:2.33.1-0ppa1~ubuntu18.04.1 git-man=1:2.33.1-0ppa1~ubuntu18.04.1 ) \
+  && ( [[ $(apt-cache search -n liblttng-ust0 | awk '{print $1}') == "liblttng-ust0" ]] && apt-get install -y --no-install-recommends liblttng-ust0 || : ) \
+  && ( [[ $(apt-cache search -n liblttng-ust1 | awk '{print $1}') == "liblttng-ust1" ]] && apt-get install -y --no-install-recommends liblttng-ust1 || : ) \
+  && ( ( curl "https://awscli.amazonaws.com/awscli-exe-linux-$(uname -m).zip" -o "awscliv2.zip" && unzip awscliv2.zip -d /tmp/ && /tmp/aws/install && rm awscliv2.zip) || pip3 install --no-cache-dir awscli ) \
+  && ( curl -s "https://github.com/git-lfs/git-lfs/releases/download/v${GIT_LFS_VERSION}/git-lfs-linux-${DPKG_ARCH}-v${GIT_LFS_VERSION}.tar.gz" -L -o /tmp/lfs.tar.gz && tar -xzf /tmp/lfs.tar.gz -C /tmp && /tmp/git-lfs-${GIT_LFS_VERSION}/install.sh && rm -rf /tmp/lfs.tar.gz  /tmp/git-lfs-${GIT_LFS_VERSION}) \
+  && distro=$(lsb_release -is | awk '{print tolower($0)}') \
+  && VERSION_ID=$(lsb_release -r | cut -f2) \
+  && echo "deb http://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/xUbuntu_${VERSION_ID}/ /" | sudo tee /etc/apt/sources.list.d/devel-kubic-libcontainers-stable.list \
+  && curl -Ls https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable/xUbuntu_$VERSION_ID/Release.key | apt-key add - \
+  && apt-get update \
+  && apt-get install buildah podman fuse-overlayfs -y \
+  && sed -i 's/^\[machine\]$/#\[machine\]/' /usr/share/containers/containers.conf \
+  # && sed -i 's/#mount_program/mount_program/g' /etc/containers/storage.conf \
+  && mkdir -p /etc/apt/keyrings \
+  && ( curl -fsSL https://download.docker.com/linux/${distro}/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg ) \
+  && version=$(lsb_release -cs | sed 's/trixie\|n\/a/bookworm/g') \
+  && ( echo "deb [arch=${DPKG_ARCH} signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/${distro} ${version} stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null ) \
+  && apt-get update \
+  && apt-get install -y docker-ce docker-ce-cli docker-buildx-plugin containerd.io docker-compose-plugin --no-install-recommends --allow-unauthenticated \
+  && echo -e '#!/bin/sh\ndocker compose --compatibility "$@"' > /usr/local/bin/docker-compose && chmod +x /usr/local/bin/docker-compose \
+  && ( [[ "${LSB_RELEASE_CODENAME}" == "focal" ]] && ( echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/xUbuntu_20.04/ /" | tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list && curl -L "https://build.opensuse.org/projects/devel:kubic/public_key" | apt-key add -; echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/xUbuntu_20.04/ /" | tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list && curl -L "https://build.opensuse.org/projects/devel:kubic/public_key" | apt-key add - && apt-get update) || : ) \
+  && ( [[ "${LSB_RELEASE_CODENAME}" == "focal" || "${LSB_RELEASE_CODENAME}" == "jammy" || "${LSB_RELEASE_CODENAME}" == "sid" || "${LSB_RELEASE_CODENAME}" == "bullseye" ]] && apt-get install -y --no-install-recommends podman buildah skopeo || : ) \
+  && ( [[ "${LSB_RELEASE_CODENAME}" == "jammy" ]] && echo "Ubuntu Jammy is marked as beta. Please see https://github.com/actions/virtual-environments/issues/5490" || : ) \
+  && GH_CLI_VERSION=$(curl -sL -H "Accept: application/vnd.github+json"   https://api.github.com/repos/cli/cli/releases/latest | jq -r '.tag_name' | sed 's/^v//g') \
+  && GH_CLI_DOWNLOAD_URL=$(curl -sL -H "Accept: application/vnd.github+json"   https://api.github.com/repos/cli/cli/releases/latest | jq ".assets[] | select(.name == \"gh_${GH_CLI_VERSION}_linux_${DPKG_ARCH}.deb\")" | jq -r '.browser_download_url') \
+  && curl -sSLo /tmp/ghcli.deb ${GH_CLI_DOWNLOAD_URL} && apt-get -y install /tmp/ghcli.deb && rm /tmp/ghcli.deb \
+  && YQ_VERSION=$(curl -sL -H "Accept: application/vnd.github+json" https://api.github.com/repos/mikefarah/yq/releases/latest | jq -r '.tag_name' | sed 's/^v//g') \
+  && YQ_DOWNLOAD_URL=$(curl -sL -H "Accept: application/vnd.github+json" https://api.github.com/repos/mikefarah/yq/releases/latest | jq ".assets[] | select(.name == \"yq_linux_${DPKG_ARCH}.tar.gz\")" | jq -r '.browser_download_url') \
+  && ( curl -s ${YQ_DOWNLOAD_URL} -L -o /tmp/yq.tar.gz && tar -xzf /tmp/yq.tar.gz -C /tmp && mv /tmp/yq_linux_${DPKG_ARCH} /usr/local/bin/yq) \
+  && rm -rf /var/lib/apt/lists/* \
+  && rm -rf /tmp/* \
+  && groupadd -g 121 runner \
+  && useradd -mr -d /home/runner -u 1001 -g 121 runner \
+  && usermod -aG sudo runner \
+  && usermod -aG docker runner \
+  && echo '%sudo ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers \
+  && ( [[ -f /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list ]] && rm /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list || : )
+
+ENV AGENT_TOOLSDIRECTORY=/opt/hostedtoolcache
+RUN mkdir -p /opt/hostedtoolcache
+
+ARG GH_RUNNER_VERSION="2.320.0"
+
+ARG TARGETPLATFORM
+
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+
+WORKDIR /actions-runner
+COPY install_actions.sh /actions-runner
+
+RUN chmod +x /actions-runner/install_actions.sh \
+  && /actions-runner/install_actions.sh ${GH_RUNNER_VERSION} ${TARGETPLATFORM} \
+  && rm /actions-runner/install_actions.sh \
+  && chown runner /_work /actions-runner /opt/hostedtoolcache
+
+COPY token.sh entrypoint.sh app_token.sh /
+RUN chmod +x /token.sh /entrypoint.sh /app_token.sh
+
+ENTRYPOINT ["/entrypoint.sh"]
+CMD ["./bin/Runner.Listener", "run", "--startuptype", "service"]

OmniGibson/docker/gh-actions/app_token.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+#
+# Request an ACCESS_TOKEN to be used by a GitHub APP
+# Environment variable that need to be set up:
+# * APP_ID, the GitHub's app ID
+# * APP_PRIVATE_KEY, the content of GitHub app's private key in PEM format.
+# * APP_LOGIN, the login name used to install GitHub's app
+#
+# https://github.com/orgs/community/discussions/24743#discussioncomment-3245300
+#
+
+set -o pipefail
+
+_GITHUB_HOST=${GITHUB_HOST:="github.com"}
+
+# If URL is not github.com then use the enterprise api endpoint
+if [[ ${GITHUB_HOST} = "github.com" ]]; then
+  URI="https://api.${_GITHUB_HOST}"
+else
+  URI="https://${_GITHUB_HOST}/api/v3"
+fi
+
+API_VERSION=v3
+API_HEADER="Accept: application/vnd.github.${API_VERSION}+json"
+CONTENT_LENGTH_HEADER="Content-Length: 0"
+APP_INSTALLATIONS_URI="${URI}/app/installations"
+
+
+# JWT parameters based off
+# https://docs.github.com/en/developers/apps/building-github-apps/authenticating-with-github-apps#authenticating-as-a-github-app
+#
+# JWT token issuance and expiration parameters
+JWT_IAT_DRIFT=60
+JWT_EXP_DELTA=600
+
+JWT_JOSE_HEADER='{
+    "alg": "RS256",
+    "typ": "JWT"
+}'
+
+
+build_jwt_payload() {
+    now=$(date +%s)
+    iat=$((now - JWT_IAT_DRIFT))
+    jq -c \
+        --arg iat_str "${iat}" \
+        --arg exp_delta_str "${JWT_EXP_DELTA}" \
+        --arg app_id_str "${APP_ID}" \
+    '
+        ($iat_str | tonumber) as $iat
+        | ($exp_delta_str | tonumber) as $exp_delta
+        | ($app_id_str | tonumber) as $app_id
+        | .iat = $iat
+        | .exp = ($iat + $exp_delta)
+        | .iss = $app_id
+    ' <<< "{}" | tr -d '\n'
+}
+
+base64url() {
+    base64 | tr '+/' '-_' | tr -d '=\n'
+}
+
+rs256_sign() {
+    openssl dgst -binary -sha256 -sign <(echo "$1")
+}
+
+request_access_token() {
+    jwt_payload=$(build_jwt_payload)
+    encoded_jwt_parts=$(base64url <<<"${JWT_JOSE_HEADER}").$(base64url <<<"${jwt_payload}")
+    encoded_mac=$(echo -n "${encoded_jwt_parts}" | rs256_sign "${APP_PRIVATE_KEY}" | base64url)
+    generated_jwt="${encoded_jwt_parts}.${encoded_mac}"
+
+    auth_header="Authorization: Bearer ${generated_jwt}"
+
+    app_installations_response=$(curl -sX GET \
+        -H "${auth_header}" \
+        -H "${API_HEADER}" \
+        "${APP_INSTALLATIONS_URI}" \
+    )
+    access_token_url=$(echo "${app_installations_response}" | jq --raw-output '.[] | select (.account.login == "'"${APP_LOGIN}"'" and .app_id  == '"${APP_ID}"') .access_tokens_url')
+    curl -sX POST \
+        -H "${CONTENT_LENGTH_HEADER}" \
+        -H "${auth_header}" \
+        -H "${API_HEADER}" \
+        "${access_token_url}" | \
+        jq --raw-output .token
+}
+
+request_access_token

OmniGibson/docker/gh-actions/entrypoint.sh

@@ -0,0 +1,203 @@
+#!/usr/bin/dumb-init /bin/bash
+# shellcheck shell=bash
+
+export RUNNER_ALLOW_RUNASROOT=1
+export PATH=${PATH}:/actions-runner
+
+# Un-export these, so that they must be passed explicitly to the environment of
+# any command that needs them.  This may help prevent leaks.
+export -n ACCESS_TOKEN
+export -n RUNNER_TOKEN
+export -n APP_ID
+export -n APP_PRIVATE_KEY
+
+deregister_runner() {
+  echo "Caught SIGTERM. Deregistering runner"
+  if [[ -n "${ACCESS_TOKEN}" ]]; then
+    _TOKEN=$(ACCESS_TOKEN="${ACCESS_TOKEN}" bash /token.sh)
+    RUNNER_TOKEN=$(echo "${_TOKEN}" | jq -r .token)
+  fi
+  ./config.sh remove --token "${RUNNER_TOKEN}"
+  exit
+}
+
+_DISABLE_AUTOMATIC_DEREGISTRATION=${DISABLE_AUTOMATIC_DEREGISTRATION:-false}
+
+_RANDOM_RUNNER_SUFFIX=${RANDOM_RUNNER_SUFFIX:="true"}
+
+_RUNNER_NAME=${RUNNER_NAME:-${RUNNER_NAME_PREFIX:-github-runner}-$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 13 ; echo '')}
+if [[ ${RANDOM_RUNNER_SUFFIX} != "true" ]]; then
+  # In some cases this file does not exist
+  if [[ -f "/etc/hostname" ]]; then
+    # in some cases it can also be empty
+    if [[ $(stat --printf="%s" /etc/hostname) -ne 0 ]]; then
+      _RUNNER_NAME=${RUNNER_NAME:-${RUNNER_NAME_PREFIX:-github-runner}-$(cat /etc/hostname)}
+      echo "RANDOM_RUNNER_SUFFIX is ${RANDOM_RUNNER_SUFFIX}. /etc/hostname exists and has content. Setting runner name to ${_RUNNER_NAME}"
+    else
+      echo "RANDOM_RUNNER_SUFFIX is ${RANDOM_RUNNER_SUFFIX} ./etc/hostname exists but is empty. Not using /etc/hostname."
+    fi
+  else
+    echo "RANDOM_RUNNER_SUFFIX is ${RANDOM_RUNNER_SUFFIX} but /etc/hostname does not exist. Not using /etc/hostname."
+  fi
+fi
+
+_RUNNER_WORKDIR=${RUNNER_WORKDIR:-/_work/${_RUNNER_NAME}}
+_LABELS=${LABELS:-default}
+_RUNNER_GROUP=${RUNNER_GROUP:-Default}
+_GITHUB_HOST=${GITHUB_HOST:="github.com"}
+_RUN_AS_ROOT=${RUN_AS_ROOT:="true"}
+_START_DOCKER_SERVICE=${START_DOCKER_SERVICE:="false"}
+
+# ensure backwards compatibility
+if [[ -z ${RUNNER_SCOPE} ]]; then
+  if [[ ${ORG_RUNNER} == "true" ]]; then
+    echo 'ORG_RUNNER is now deprecated. Please use RUNNER_SCOPE="org" instead.'
+    export RUNNER_SCOPE="org"
+  else
+    export RUNNER_SCOPE="repo"
+  fi
+fi
+
+RUNNER_SCOPE="${RUNNER_SCOPE,,}" # to lowercase
+
+case ${RUNNER_SCOPE} in
+  org*)
+    [[ -z ${ORG_NAME} ]] && ( echo "ORG_NAME required for org runners"; exit 1 )
+    _SHORT_URL="https://${_GITHUB_HOST}/${ORG_NAME}"
+    RUNNER_SCOPE="org"
+    if [[ -n "${APP_ID}" ]] && [[ -z "${APP_LOGIN}" ]]; then
+      APP_LOGIN=${ORG_NAME}
+    fi
+    ;;
+
+  ent*)
+    [[ -z ${ENTERPRISE_NAME} ]] && ( echo "ENTERPRISE_NAME required for enterprise runners"; exit 1 )
+    _SHORT_URL="https://${_GITHUB_HOST}/enterprises/${ENTERPRISE_NAME}"
+    RUNNER_SCOPE="enterprise"
+    ;;
+
+  *)
+    [[ -z ${REPO_URL} ]] && ( echo "REPO_URL required for repo runners"; exit 1 )
+    _SHORT_URL=${REPO_URL}
+    RUNNER_SCOPE="repo"
+    if [[ -n "${APP_ID}" ]] && [[ -z "${APP_LOGIN}" ]]; then
+      APP_LOGIN=${REPO_URL%/*}
+      APP_LOGIN=${APP_LOGIN##*/}
+    fi
+    ;;
+esac
+
+configure_runner() {
+  ARGS=()
+  if [[ -n "${APP_ID}" ]] && [[ -n "${APP_PRIVATE_KEY}" ]] && [[ -n "${APP_LOGIN}" ]]; then
+    if [[ -n "${ACCESS_TOKEN}" ]] || [[ -n "${RUNNER_TOKEN}" ]]; then
+      echo "ERROR: ACCESS_TOKEN or RUNNER_TOKEN provided but are mutually exclusive with APP_ID, APP_PRIVATE_KEY and APP_LOGIN." >&2
+      exit 1
+    fi
+    echo "Obtaining access token for app_id ${APP_ID} and login ${APP_LOGIN}"
+    nl="
+"
+    ACCESS_TOKEN=$(APP_ID="${APP_ID}" APP_PRIVATE_KEY="${APP_PRIVATE_KEY//\\n/${nl}}" APP_LOGIN="${APP_LOGIN}" bash /app_token.sh)
+  elif [[ -n "${APP_ID}" ]] || [[ -n "${APP_PRIVATE_KEY}" ]] || [[ -n "${APP_LOGIN}" ]]; then
+    echo "ERROR: All of APP_ID, APP_PRIVATE_KEY and APP_LOGIN must be specified." >&2
+    exit 1
+  fi
+
+  if [[ -n "${ACCESS_TOKEN}" ]]; then
+    echo "Obtaining the token of the runner"
+    _TOKEN=$(ACCESS_TOKEN="${ACCESS_TOKEN}" bash /token.sh)
+    RUNNER_TOKEN=$(echo "${_TOKEN}" | jq -r .token)
+  fi
+
+  # shellcheck disable=SC2153
+  if [ -n "${EPHEMERAL}" ]; then
+    echo "Ephemeral option is enabled"
+    ARGS+=("--ephemeral")
+  fi
+
+  if [ -n "${DISABLE_AUTO_UPDATE}" ]; then
+    echo "Disable auto update option is enabled"
+    ARGS+=("--disableupdate")
+  fi
+
+  if [ -n "${NO_DEFAULT_LABELS}" ]; then
+    echo "Disable adding the default self-hosted, platform, and architecture labels"
+    ARGS+=("--no-default-labels")
+  fi
+
+  echo "Configuring"
+  ./config.sh \
+      --url "${_SHORT_URL}" \
+      --token "${RUNNER_TOKEN}" \
+      --name "${_RUNNER_NAME}" \
+      --work "${_RUNNER_WORKDIR}" \
+      --labels "${_LABELS}" \
+      --runnergroup "${_RUNNER_GROUP}" \
+      --unattended \
+      --replace \
+      "${ARGS[@]}"
+
+  [[ ! -d "${_RUNNER_WORKDIR}" ]] && mkdir "${_RUNNER_WORKDIR}"
+
+}
+
+
+# Opt into runner reusage because a value was given
+if [[ -n "${CONFIGURED_ACTIONS_RUNNER_FILES_DIR}" ]]; then
+  echo "Runner reusage is enabled"
+
+  # directory exists, copy the data
+  if [[ -d "${CONFIGURED_ACTIONS_RUNNER_FILES_DIR}" ]]; then
+    echo "Copying previous data"
+    cp -p -r "${CONFIGURED_ACTIONS_RUNNER_FILES_DIR}/." "/actions-runner"
+  fi
+
+  if [ -f "/actions-runner/.runner" ]; then
+    echo "The runner has already been configured"
+  else
+    configure_runner
+  fi
+else
+  echo "Runner reusage is disabled"
+  configure_runner
+fi
+
+if [[ -n "${CONFIGURED_ACTIONS_RUNNER_FILES_DIR}" ]]; then
+  echo "Reusage is enabled. Storing data to ${CONFIGURED_ACTIONS_RUNNER_FILES_DIR}"
+  # Quoting (even with double-quotes) the regexp brokes the copying
+  cp -p -r "/actions-runner/_diag" "/actions-runner/svc.sh" /actions-runner/.[^.]* "${CONFIGURED_ACTIONS_RUNNER_FILES_DIR}"
+fi
+
+if [[ ${_DISABLE_AUTOMATIC_DEREGISTRATION} == "false" ]]; then
+  trap deregister_runner SIGINT SIGQUIT SIGTERM INT TERM QUIT
+fi
+
+# Start docker service if needed (e.g. for docker-in-docker)
+if [[ ${_START_DOCKER_SERVICE} == "true" ]]; then
+  echo "Starting docker service"
+  _PREFIX=""
+  [[ ${_RUN_AS_ROOT} != "true" ]] && _PREFIX="sudo"
+  ${_PREFIX} service docker start
+fi
+
+# Container's command (CMD) execution as runner user
+
+
+if [[ ${_RUN_AS_ROOT} == "true" ]]; then
+  if [[ $(id -u) -eq 0 ]]; then
+    "$@"
+  else
+    echo "ERROR: RUN_AS_ROOT env var is set to true but the user has been overridden and is not running as root, but UID '$(id -u)'"
+    exit 1
+  fi
+else
+  if [[ $(id -u) -eq 0 ]]; then
+    [[ -n "${CONFIGURED_ACTIONS_RUNNER_FILES_DIR}" ]] && chown -R runner "${CONFIGURED_ACTIONS_RUNNER_FILES_DIR}"
+    chown -R runner "${_RUNNER_WORKDIR}" /actions-runner
+    # The toolcache is not recursively chowned to avoid recursing over prepulated tooling in derived docker images
+    chown runner /opt/hostedtoolcache/
+    /usr/sbin/gosu runner "$@"
+  else
+    "$@"
+  fi
+fi

OmniGibson/docker/gh-actions/install_actions.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -ex
+GH_RUNNER_VERSION=$1
+TARGETPLATFORM=$2
+
+export TARGET_ARCH="x64"
+if [[ $TARGETPLATFORM == "linux/arm64" ]]; then
+  export TARGET_ARCH="arm64"
+fi
+curl -L "https://github.com/actions/runner/releases/download/v${GH_RUNNER_VERSION}/actions-runner-linux-${TARGET_ARCH}-${GH_RUNNER_VERSION}.tar.gz" > actions.tar.gz
+tar -zxf actions.tar.gz
+rm -f actions.tar.gz
+./bin/installdependencies.sh
+mkdir /_work

OmniGibson/docker/gh-actions/token.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+_GITHUB_HOST=${GITHUB_HOST:="github.com"}
+
+# If URL is not github.com then use the enterprise api endpoint
+if [[ ${GITHUB_HOST} = "github.com" ]]; then
+  URI="https://api.${_GITHUB_HOST}"
+else
+  URI="https://${_GITHUB_HOST}/api/v3"
+fi
+
+API_VERSION=v3
+API_HEADER="Accept: application/vnd.github.${API_VERSION}+json"
+AUTH_HEADER="Authorization: token ${ACCESS_TOKEN}"
+CONTENT_LENGTH_HEADER="Content-Length: 0"
+
+case ${RUNNER_SCOPE} in
+  org*)
+    _FULL_URL="${URI}/orgs/${ORG_NAME}/actions/runners/registration-token"
+    ;;
+
+  ent*)
+    _FULL_URL="${URI}/enterprises/${ENTERPRISE_NAME}/actions/runners/registration-token"
+    ;;
+
+  *)
+    _PROTO="https://"
+    # shellcheck disable=SC2116
+    _URL="$(echo "${REPO_URL/${_PROTO}/}")"
+    _PATH="$(echo "${_URL}" | grep / | cut -d/ -f2-)"
+    _ACCOUNT="$(echo "${_PATH}" | cut -d/ -f1)"
+    _REPO="$(echo "${_PATH}" | cut -d/ -f2)"
+    _FULL_URL="${URI}/repos/${_ACCOUNT}/${_REPO}/actions/runners/registration-token"
+    ;;
+esac
+
+RUNNER_TOKEN="$(curl -XPOST -fsSL \
+  -H "${CONTENT_LENGTH_HEADER}" \
+  -H "${AUTH_HEADER}" \
+  -H "${API_HEADER}" \
+  "${_FULL_URL}" \
+| jq -r '.token')"
+
+echo "{\"token\": \"${RUNNER_TOKEN}\", \"full_url\": \"${_FULL_URL}\"}"

OmniGibson/docker/launch_vscode.sh

@@ -0,0 +1,143 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=omnigibson-vscode
+#SBATCH --account=cvgl
+#SBATCH --partition=svl --qos=normal
+#SBATCH --nodes=1
+#SBATCH --cpus-per-task=8
+#SBATCH --mem=30G
+#SBATCH --gres=gpu:2080ti:1
+
+set -e -o pipefail
+
+# Get the username
+USERNAME=$(whoami)
+
+# Define the base directory
+BASE_DIR="/cvgl2/u/$USERNAME"
+
+# Step 1: Check if the user's directory exists
+if [ ! -d "$BASE_DIR" ]; then
+    echo "Error: Directory $BASE_DIR does not exist. Please ask for a directory to be created."
+    exit 1
+fi
+
+# cd into the base directory
+cd $BASE_DIR
+
+# Define the vscode-config directory
+VSCODE_CONFIG_DIR="$BASE_DIR/vscode-config"
+
+# Step 2: Check if the vscode-config directory exists, if not create it
+if [ ! -d "$VSCODE_CONFIG_DIR" ]; then
+    mkdir "$VSCODE_CONFIG_DIR" || { echo "Error creating $VSCODE_CONFIG_DIR"; exit 1; }
+fi
+
+# Define the extensions and data directories
+EXTENSIONS_DIR="$VSCODE_CONFIG_DIR/extensions"
+DATA_DIR="$VSCODE_CONFIG_DIR/data"
+
+# Step 3: Check and create the extensions and data directories
+if [ ! -d "$EXTENSIONS_DIR" ]; then
+    mkdir "$EXTENSIONS_DIR" || { echo "Error creating $EXTENSIONS_DIR"; exit 1; }
+fi
+
+if [ ! -d "$DATA_DIR" ]; then
+    mkdir "$DATA_DIR" || { echo "Error creating $DATA_DIR"; exit 1; }
+fi
+
+# Step 4: Clone OmniGibson if necessary
+if [ ! -d "$BASE_DIR/OmniGibson" ]; then
+    git clone https://github.com/StanfordVL/OmniGibson.git $BASE_DIR/OmniGibson
+    cd $BASE_DIR/OmniGibson
+    git pull
+    git checkout vscode-docker  # TODO: Change this to og-develop before vscode-docker is merged
+    cd $BASE_DIR
+fi
+
+# Step 5: Find three free ports
+WEBRTC_PORT=$(python -c 'import socket; s=socket.socket(); s.bind(("", 0)); print(s.getsockname()[1])')
+HTTP_PORT=$(python -c 'import socket; s=socket.socket(); s.bind(("", 0)); print(s.getsockname()[1])')
+VSCODE_PORT=$(python -c 'import socket; s=socket.socket(); s.bind(("", 0)); print(s.getsockname()[1])')
+
+# Ensure that the two ports are different
+while [ "$HTTP_PORT" -eq "$WEBRTC_PORT" ]; do
+    HTTP_PORT=$(python -c 'import socket; s=socket.socket(); s.bind(("", 0)); print(s.getsockname()[1])')
+done
+
+# Ensure that the three ports are different
+while [ "$VSCODE_PORT" -eq "$WEBRTC_PORT" ] || [ "$VSCODE_PORT" -eq "$HTTP_PORT" ]; do
+    VSCODE_PORT=$(python -c 'import socket; s=socket.socket(); s.bind(("", 0)); print(s.getsockname()[1])')
+done
+
+# Print HTTP link to access webrtc and vscode
+FQDN_HOSTNAME=$(hostname -i)  # $(curl "https://checkip.amazonaws.com")
+echo "[OMNIGIBSON-VSCODE] Launching remote OmniGibson environment..."
+echo "[OMNIGIBSON-VSCODE] To access vscode, go to http://${FQDN_HOSTNAME}:${VSCODE_PORT}"
+echo "[OMNIGIBSON-VSCODE] To access webrtc, go to http://${FQDN_HOSTNAME}:${HTTP_PORT}/streaming/webrtc-client"
+echo ""
+
+# Step 6: Create the container
+IMAGE_PATH="/cvgl/group/Gibson/og-docker/omnigibson-vscode.sqsh"
+GPU_ID=$(nvidia-smi -L | grep -oP '(?<=GPU-)[a-fA-F0-9\-]+' | head -n 1)
+ISAAC_CACHE_PATH="/scr-ssd/${SLURM_JOB_USER}/isaac_cache_${GPU_ID}"
+
+# Define env kwargs to pass
+declare -A ENVS=(
+    [NVIDIA_DRIVER_CAPABILITIES]=all
+    [NVIDIA_VISIBLE_DEVICES]=0
+    [DISPLAY]=""
+    [OMNIGIBSON_REMOTE_STREAMING]="webrtc"
+    [OMNIGIBSON_HTTP_PORT]=${HTTP_PORT}
+    [OMNIGIBSON_WEBRTC_PORT]=${WEBRTC_PORT}
+    [OMNIGIBSON_VSCODE_PORT]=${VSCODE_PORT}
+    [PASSWORD]=${USERNAME}
+)
+for env_var in "${!ENVS[@]}"; do
+    # Add to env kwargs we'll pass to enroot command later
+    ENV_KWARGS="${ENV_KWARGS} --env ${env_var}=${ENVS[${env_var}]}"
+done
+
+# Define mounts to create (maps local directory to container directory)
+declare -A MOUNTS=(
+    [/scr-ssd/og-data-0-2-1]=/data
+    [${ISAAC_CACHE_PATH}/isaac-sim/kit/cache/Kit]=/isaac-sim/kit/cache/Kit
+    [${ISAAC_CACHE_PATH}/isaac-sim/cache/ov]=/root/.cache/ov
+    [${ISAAC_CACHE_PATH}/isaac-sim/cache/pip]=/root/.cache/pip
+    [${ISAAC_CACHE_PATH}/isaac-sim/cache/glcache]=/root/.cache/nvidia/GLCache
+    [${ISAAC_CACHE_PATH}/isaac-sim/cache/computecache]=/root/.nv/ComputeCache
+    [${ISAAC_CACHE_PATH}/isaac-sim/logs]=/root/.nvidia-omniverse/logs
+    [${ISAAC_CACHE_PATH}/isaac-sim/config]=/root/.nvidia-omniverse/config
+    [${ISAAC_CACHE_PATH}/isaac-sim/data]=/root/.local/share/ov/data
+    [${ISAAC_CACHE_PATH}/isaac-sim/documents]=/root/Documents
+    [${BASE_DIR}/OmniGibson]=/omnigibson-src
+    [${VSCODE_CONFIG_DIR}]=/vscode-config
+)
+
+MOUNT_KWARGS=""
+for mount in "${!MOUNTS[@]}"; do
+    # Verify mount path in local directory exists, otherwise, create it
+    if [ ! -e "$mount" ]; then
+        mkdir -p ${mount}
+    fi
+    # Add to mount kwargs we'll pass to enroot command later
+    MOUNT_KWARGS="${MOUNT_KWARGS} --mount ${mount}:${MOUNTS[${mount}]}"
+done
+
+# Create the image, even if it exists.
+CONTAINER_NAME=omnigibson_${GPU_ID}
+enroot create --force --name ${CONTAINER_NAME} ${IMAGE_PATH}
+
+# Remove leading space in string
+ENV_KWARGS="${ENV_KWARGS:1}"
+MOUNT_KWARGS="${MOUNT_KWARGS:1}"
+
+# Step 7: Launch the container
+ENROOT_MOUNT_HOME=no enroot start \
+    --root \
+    --rw \
+    ${ENV_KWARGS} \
+    ${MOUNT_KWARGS} \
+    ${CONTAINER_NAME}
+
+# Clean up the image if possible.
+enroot remove -f ${CONTAINER_NAME}

OmniGibson/docker/nginx.conf

@@ -0,0 +1,24 @@
+map $http_upgrade $connection_upgrade {
+    default upgrade;
+    '' close;
+}
+
+server {
+    listen 8123;
+
+    location /streaming/ {
+        proxy_pass http://127.0.0.1:8211/streaming/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection $connection_upgrade;
+        proxy_set_header Host $host;
+    }
+
+    location / {
+        proxy_pass http://127.0.0.1:49100/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection $connection_upgrade;
+        proxy_set_header Host $host;
+    }
+}

OmniGibson/docker/prod.Dockerfile

@@ -0,0 +1,82 @@
+FROM nvcr.io/nvidia/isaac-sim:4.5.0
+
+# Set up all the prerequisites.
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
+  curl git wget \
+  g++ cmake pkg-config libeigen3-dev wget libyaml-cpp-dev castxml pypy3 \
+  && rm -rf /var/lib/apt/lists/*
+
+RUN rm -rf /isaac-sim/exts/omni.isaac.ml_archive/pip_prebundle/gym*
+RUN rm -rf /isaac-sim/exts/omni.isaac.ml_archive/pip_prebundle/torch*
+RUN rm -rf /isaac-sim/exts/omni.isaac.ml_archive/pip_prebundle/functorch*
+RUN rm -rf /isaac-sim/kit/extscore/omni.kit.pip_archive/pip_prebundle/numpy*
+RUN /isaac-sim/python.sh -m pip install click~=8.1.3
+
+# Mount the data directory
+VOLUME ["/data"]
+ENV OMNIGIBSON_DATA_PATH /data
+
+# Install Mamba (light conda alternative)
+RUN curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xvj -C / bin/micromamba
+ENV MAMBA_ROOT_PREFIX /micromamba
+RUN micromamba create -n omnigibson -c conda-forge python=3.10
+RUN micromamba shell init --shell=bash
+
+# Install torch
+RUN micromamba run -n omnigibson micromamba install \
+  pytorch torchvision pytorch-cuda=11.8 \
+  -c pytorch -c nvidia -c conda-forge
+
+# Install curobo. This can normally be installed when OmniGibson is pip
+# installed, but we need to install it beforehand here so that it doesn't
+# have to happen on every time a CI action is run (otherwise it's just
+# very slow).
+# This also allows us to uninstall the cuda toolkit after curobo is built
+# to save space (meaning curobo will not be able to be rebuilt at runtime).
+# Here we also compile this such that it is compatible with GPU architectures
+# Turing, Ampere, and Ada; which correspond to 20, 30, and 40 series GPUs.
+# We also suppress the output of the installation to avoid the log limit.
+RUN wget --no-verbose -O /cuda-keyring.deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb && \ 
+  dpkg -i /cuda-keyring.deb && rm /cuda-keyring.deb && apt-get update && \
+  DEBIAN_FRONTEND=noninteractive apt-get install -y cuda-toolkit-11-8 && \
+  TORCH_CUDA_ARCH_LIST='7.5;8.0;8.6+PTX' PATH=/usr/local/cuda-11.8/bin:$PATH LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64:$LD_LIBRARY_PATH \
+    micromamba run -n omnigibson pip install \
+    git+https://github.com/StanfordVL/curobo@cbaf7d32436160956dad190a9465360fad6aba73#egg=nvidia_curobo \
+    --no-build-isolation > /dev/null && \
+  apt-get remove -y cuda-toolkit-11-8 && apt-get autoremove -y && apt-get autoclean -y && rm -rf /var/lib/apt/lists/*
+
+# Make sure isaac gets properly sourced every time omnigibson gets called
+ARG CONDA_ACT_FILE="/micromamba/envs/omnigibson/etc/conda/activate.d/env_vars.sh"
+RUN mkdir -p "/micromamba/envs/omnigibson/etc/conda/activate.d"
+RUN touch $CONDA_ACT_FILE
+
+RUN echo '#!/bin/sh' > $CONDA_ACT_FILE
+RUN echo "source /isaac-sim/setup_conda_env.sh" >> $CONDA_ACT_FILE
+
+RUN echo "micromamba activate omnigibson" >> /root/.bashrc
+
+# Copy over omnigibson source
+ADD . /omnigibson-src
+WORKDIR /omnigibson-src
+
+# Set the shell
+SHELL ["micromamba", "run", "-n", "omnigibson", "/bin/bash", "--login", "-c"]
+
+# Optionally install OmniGibson (e.g. unless the DEV_MODE flag is set) or
+# remove the OmniGibson source code if we are in dev mode and change the workdir
+ARG DEV_MODE
+ENV DEV_MODE=${DEV_MODE}
+ARG WORKDIR_PATH=/omnigibson-src
+RUN if [ "$DEV_MODE" != "1" ]; then \
+      echo "OMNIGIBSON_NO_OMNIVERSE=1 python omnigibson/download_datasets.py" >> /root/.bashrc; \
+      micromamba run -n omnigibson pip install -e .[dev,primitives]; \
+    else \
+      WORKDIR_PATH=/; \
+      cd / && rm -rf /omnigibson-src; \
+    fi
+
+# Reset the WORKDIR based on whether or not we are in dev mode
+WORKDIR ${WORKDIR_PATH}
+
+ENTRYPOINT ["micromamba", "run", "-n", "omnigibson"]
+CMD ["/bin/bash"]

OmniGibson/docker/push_docker.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -e -o pipefail
+
+docker push stanfordvl/omnigibson:latest
+docker push stanfordvl/omnigibson:$(sed -ne "s/.*version= *['\"]\([^'\"]*\)['\"] *.*/\1/p" setup.py)
+docker push stanfordvl/omnigibson-dev:latest

OmniGibson/docker/run_docker.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+set -e -o pipefail
+
+BYellow='\033[1;33m'
+Color_Off='\033[0m'
+
+# Parse the command line arguments.
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+DEFAULT_DATA_DIR="$SCRIPT_DIR/omnigibson_data"
+DATA_PATH=$DEFAULT_DATA_DIR
+GUI=true
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]
+do
+    key="$1"
+
+    case $key in
+        -h|--headless)
+        GUI=false
+        shift
+        ;;
+        *)
+        DATA_PATH="$1"
+        shift
+        ;;
+    esac
+done
+
+echo -e "${BYellow}IMPORTANT: Saving OmniGibson assets at ${DATA_PATH}."
+echo -e "You can change this path by providing your desired path as an argument"
+echo -e "to the run_docker script you are using. Also note that Docker containers"
+echo -e "are incompatible with AFS/NFS drives, so please make sure that this path"
+echo -e "points to a local filesystem. ${Color_Off}"
+echo ""
+
+echo "The NVIDIA Omniverse License Agreement (EULA) must be accepted before"
+echo "Omniverse Kit can start. The license terms for this product can be viewed at"
+echo "https://docs.omniverse.nvidia.com/app_isaacsim/common/NVIDIA_Omniverse_License_Agreement.html"
+
+while true; do
+    read -p "Do you accept the Omniverse EULA? [y/n] " yn
+    case $yn in
+        [Yy]* ) break;;
+        [Nn]* ) exit;;
+        * ) echo "Please answer yes or no.";;
+    esac
+done
+
+docker pull stanfordvl/omnigibson:latest
+DOCKER_DISPLAY=""
+OMNIGIBSON_HEADLESS=1
+if [ "$GUI" = true ] ; then
+    xhost +local:root
+    DOCKER_DISPLAY=$DISPLAY
+    OMNIGIBSON_HEADLESS=0
+fi
+docker run \
+    --gpus all \
+    --privileged \
+    -e DISPLAY=${DOCKER_DISPLAY} \
+    -e OMNIGIBSON_HEADLESS=${OMNIGIBSON_HEADLESS} \
+    -v $DATA_PATH/datasets:/data \
+    -v $DATA_PATH/isaac-sim/cache/kit:/isaac-sim/kit/cache/Kit:rw \
+    -v $DATA_PATH/isaac-sim/cache/ov:/root/.cache/ov:rw \
+    -v $DATA_PATH/isaac-sim/cache/pip:/root/.cache/pip:rw \
+    -v $DATA_PATH/isaac-sim/cache/glcache:/root/.cache/nvidia/GLCache:rw \
+    -v $DATA_PATH/isaac-sim/cache/computecache:/root/.nv/ComputeCache:rw \
+    -v $DATA_PATH/isaac-sim/logs:/root/.nvidia-omniverse/logs:rw \
+    -v $DATA_PATH/isaac-sim/config:/root/.nvidia-omniverse/config:rw \
+    -v $DATA_PATH/isaac-sim/data:/root/.local/share/ov/data:rw \
+    -v $DATA_PATH/isaac-sim/documents:/root/Documents:rw \
+    --network=host --rm -it stanfordvl/omnigibson:latest
+if [ "$GUI" = true ] ; then
+    xhost -local:root
+fi

OmniGibson/docker/safe_launch_vscode.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -e -o pipefail
+
+# Get the user's currently running vscode job count
+USERNAME=$(whoami)
+CURRENTLY_RUNNING_JOBS=$(squeue -u $USERNAME -o "%j:%i" | grep omnigibson-vscode || true)
+
+if [ -z "$CURRENTLY_RUNNING_JOBS" ]; then
+    # Queue a new job for the user
+    echo "Starting new job"
+    sbatch /cvgl/group/Gibson/og-docker/launch_vscode.sh
+
+    # Wait for the file to show up
+    while ! (squeue -u $USERNAME -o "%j:%i" | grep -q omnigibson-vscode); do
+        echo "Waiting for the job to launch."
+        sleep 3
+    done
+fi
+
+# Get the job id
+LAUNCHED_JOB_ID=$(squeue -u $USERNAME -o "%j:%i" | grep -m 1 omnigibson-vscode | sed "s/.*://g" | tr -d '\n')
+echo "Job ID: $LAUNCHED_JOB_ID"
+
+# Check that the output file exists
+OUTPUT_FILE="slurm-${LAUNCHED_JOB_ID}.out"
+while [ ! -f "$OUTPUT_FILE" ]; do
+    echo "Waiting for the job to start outputting."
+    sleep 3
+done
+
+# Wait for the output file to contain the string OMNIGIBSON-VSCODE exactly 3 times
+while [ "$(grep -c "OMNIGIBSON-VSCODE" "$OUTPUT_FILE" || true)" -lt 3 ]; do
+    echo "Waiting for the job to allocate ports."
+    sleep 3
+done
+# echo "Ports allocated successfully."
+
+# Wait for the output file to contain the string "HTTP server listening"
+# while ! grep -q "HTTP server listening" "$OUTPUT_FILE"; do
+#     echo "Waiting for the job to start the HTTP server."
+#     sleep 3
+# done
+# echo "HTTP server started successfully."
+# echo ""
+
+# Echo the OMNIGIBSON-VSCODE lines
+grep "OMNIGIBSON-VSCODE" "$OUTPUT_FILE"

OmniGibson/docker/sbatch_example.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+#SBATCH --account=cvgl
+#SBATCH --partition=svl --qos=normal
+#SBATCH --nodes=1
+#SBATCH --cpus-per-task=8
+#SBATCH --mem=30G
+#SBATCH --gres=gpu:2080ti:1
+
+set -e -o pipefail
+
+IMAGE_PATH="/cvgl2/u/cgokmen/omnigibson.sqsh"
+GPU_ID=$(nvidia-smi -L | grep -oP '(?<=GPU-)[a-fA-F0-9\-]+' | head -n 1)
+ISAAC_CACHE_PATH="/scr-ssd/${SLURM_JOB_USER}/isaac_cache_${GPU_ID}"
+
+# Define env kwargs to pass
+declare -A ENVS=(
+    [NVIDIA_DRIVER_CAPABILITIES]=all
+    [NVIDIA_VISIBLE_DEVICES]=0
+    [DISPLAY]=""
+    [OMNIGIBSON_HEADLESS]=1
+)
+for env_var in "${!ENVS[@]}"; do
+    # Add to env kwargs we'll pass to enroot command later
+    ENV_KWARGS="${ENV_KWARGS} --env ${env_var}=${ENVS[${env_var}]}"
+done
+
+# Define mounts to create (maps local directory to container directory)
+declare -A MOUNTS=(
+    [/scr-ssd/og-data-0-2-1]=/data
+    [${ISAAC_CACHE_PATH}/isaac-sim/kit/cache/Kit]=/isaac-sim/kit/cache/Kit
+    [${ISAAC_CACHE_PATH}/isaac-sim/cache/ov]=/root/.cache/ov
+    [${ISAAC_CACHE_PATH}/isaac-sim/cache/pip]=/root/.cache/pip
+    [${ISAAC_CACHE_PATH}/isaac-sim/cache/glcache]=/root/.cache/nvidia/GLCache
+    [${ISAAC_CACHE_PATH}/isaac-sim/cache/computecache]=/root/.nv/ComputeCache
+    [${ISAAC_CACHE_PATH}/isaac-sim/logs]=/root/.nvidia-omniverse/logs
+    [${ISAAC_CACHE_PATH}/isaac-sim/config]=/root/.nvidia-omniverse/config
+    [${ISAAC_CACHE_PATH}/isaac-sim/data]=/root/.local/share/ov/data
+    [${ISAAC_CACHE_PATH}/isaac-sim/documents]=/root/Documents
+    # Feel free to include lines like the below to mount a workspace or a custom OG version
+    # [/cvgl2/u/cgokmen/OmniGibson]=/omnigibson-src
+    # [/cvgl2/u/cgokmen/my-project]=/my-project
+)
+
+MOUNT_KWARGS=""
+for mount in "${!MOUNTS[@]}"; do
+    # Verify mount path in local directory exists, otherwise, create it
+    if [ ! -e "$mount" ]; then
+        mkdir -p ${mount}
+    fi
+    # Add to mount kwargs we'll pass to enroot command later
+    MOUNT_KWARGS="${MOUNT_KWARGS} --mount ${mount}:${MOUNTS[${mount}]}"
+done
+
+# Create the image if it doesn't already exist
+CONTAINER_NAME=omnigibson_${GPU_ID}
+enroot create --force --name ${CONTAINER_NAME} ${IMAGE_PATH}
+
+# Remove leading space in string
+ENV_KWARGS="${ENV_KWARGS:1}"
+MOUNT_KWARGS="${MOUNT_KWARGS:1}"
+
+# The last line here is the command you want to run inside the container.
+# Here I'm running some unit tests.
+ENROOT_MOUNT_HOME=no enroot start \
+    --root \
+    --rw \
+    ${ENV_KWARGS} \
+    ${MOUNT_KWARGS} \
+    ${CONTAINER_NAME} \
+    micromamba run -n omnigibson /bin/bash --login -c "source /isaac-sim/setup_conda_env.sh && pytest tests/test_object_states.py"
+
+# Clean up the image if possible.
+enroot remove -f ${CONTAINER_NAME}

OmniGibson/docker/submission.Dockerfile

@@ -0,0 +1,44 @@
+FROM continuumio/miniconda3
+
+# Set working directory
+WORKDIR /workspace
+
+# Install system dependencies including build tools
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    g++ \
+    make \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libgcc-s1 \
+    libudev-dev \
+    libinput-dev \
+    linux-libc-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create and activate a new conda environment
+RUN conda create -n behavior python=3.10 -y -c conda-forge
+SHELL ["conda", "run", "-n", "behavior", "/bin/bash", "-c"]
+
+# Install additional packages
+RUN pip install "numpy<2" "setuptools<=79"
+RUN pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 --index-url https://download.pytorch.org/whl/cu124
+
+# Copy over omnigibson source
+ADD . /b1k-src
+WORKDIR /b1k-src
+
+# Install bddl (editable)
+RUN pip install -e bddl
+# Install omnigibson (editable)
+RUN pip install -e OmniGibson[eval]
+
+ENV PATH=/opt/conda/envs/behavior/bin:$PATH
+ENV CONDA_DEFAULT_ENV=behavior
+
+CMD ["python", "-u", "-c", "from omnigibson.learning.utils.network_utils import WebsocketPolicyServer; from omnigibson.learning.policies import LocalPolicy; server = WebsocketPolicyServer(LocalPolicy(action_dim=23)); server.serve_forever()"]

OmniGibson/docker/vscode.Dockerfile

@@ -0,0 +1,48 @@
+FROM stanfordvl/omnigibson:latest
+
+# environment settings
+ARG DEBIAN_FRONTEND="noninteractive"
+ENV OMNIGIBSON_REMOTE_STREAMING="webrtc"
+
+RUN \
+  echo "**** install runtime dependencies ****" && \
+  apt-get update && \
+  apt-get install -y \
+    git \
+    jq \
+    libatomic1 \
+    nano \
+    net-tools \
+    netcat \
+    sudo && \
+  echo "**** install code-server ****" && \
+  if [ -z ${CODE_RELEASE+x} ]; then \
+    CODE_RELEASE=$(curl -sX GET https://api.github.com/repos/coder/code-server/releases/latest \
+      | awk '/tag_name/{print $4;exit}' FS='[""]' | sed 's|^v||'); \
+  fi && \
+  mkdir -p /app/code-server && \
+  curl -o \
+    /tmp/code-server.tar.gz -L \
+    "https://github.com/coder/code-server/releases/download/v${CODE_RELEASE}/code-server-${CODE_RELEASE}-linux-amd64.tar.gz" && \
+  tar xf /tmp/code-server.tar.gz -C \
+    /app/code-server --strip-components=1 && \
+  echo "**** clean up ****" && \
+  apt-get clean && \
+  rm -rf \
+    /config/* \
+    /tmp/* \
+    /var/lib/apt/lists/* \
+    /var/tmp/*
+
+# Remove the omnigibson source code
+RUN rm -rf /omnigibson-src
+
+# run command
+CMD sed -i "s/49100/${OMNIGIBSON_WEBRTC_PORT}/g" /isaac-sim/extscache/omni.services.streamclient.webrtc-1.3.8/web/js/kit-player.js && \
+  /app/code-server/bin/code-server \
+  --bind-addr 0.0.0.0:${OMNIGIBSON_VSCODE_PORT} \
+  --user-data-dir /vscode-config/data \
+  --extensions-dir /vscode-config/extensions \
+  --disable-telemetry \
+  --auth password \
+  /omnigibson-src

OmniGibson/omnigibson.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: omnigibson
+Version: 3.7.1
+Home-page: https://github.com/StanfordVL/BEHAVIOR-1K
+Author: Stanford University
+Requires-Python: >=3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: huggingface-hub[cli]>=0.34.4
+Requires-Dist: gymnasium>=0.28.1
+Requires-Dist: numpy<2.0.0,>=1.23.5
+Requires-Dist: scipy>=1.10.1
+Requires-Dist: GitPython>=3.1.40
+Requires-Dist: transforms3d>=0.4.1
+Requires-Dist: networkx>=3.2.1
+Requires-Dist: PyYAML>=6.0.1
+Requires-Dist: addict>=2.4.0
+Requires-Dist: ipython>=8.20.0
+Requires-Dist: future>=0.18.3
+Requires-Dist: trimesh>=4.0.8
+Requires-Dist: h5py>=3.10.0
+Requires-Dist: cryptography>=41.0.7
+Requires-Dist: bddl~=3.7.0
+Requires-Dist: opencv-python>=4.8.1
+Requires-Dist: nest_asyncio>=1.5.6
+Requires-Dist: imageio>=2.33.1
+Requires-Dist: imageio-ffmpeg>=0.4.9
+Requires-Dist: termcolor>=2.4.0
+Requires-Dist: progressbar>=2.5
+Requires-Dist: pymeshlab~=2022.2
+Requires-Dist: click>=8.1.3
+Requires-Dist: aenum>=3.1.15
+Requires-Dist: rtree>=1.2.0
+Requires-Dist: graphviz>=0.20
+Requires-Dist: matplotlib>=3.0.0
+Requires-Dist: lxml>=5.2.2
+Requires-Dist: numba>=0.59.1
+Requires-Dist: cffi~=1.17.1
+Requires-Dist: pillow~=11.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.2.3; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: pytest_rerunfailures; extra == "dev"
+Requires-Dist: mkdocs; extra == "dev"
+Requires-Dist: mkdocs-autorefs; extra == "dev"
+Requires-Dist: mkdocs-gen-files; extra == "dev"
+Requires-Dist: mkdocs-material; extra == "dev"
+Requires-Dist: mkdocs-material-extensions; extra == "dev"
+Requires-Dist: mkdocstrings[python]; extra == "dev"
+Requires-Dist: mkdocs-section-index; extra == "dev"
+Requires-Dist: mkdocs-literate-nav; extra == "dev"
+Requires-Dist: mkdocs-redirects; extra == "dev"
+Requires-Dist: mkdocs-include-markdown-plugin; extra == "dev"
+Requires-Dist: telemoma~=0.3.0; extra == "dev"
+Requires-Dist: gspread>=6.2.1; extra == "dev"
+Provides-Extra: primitives
+Requires-Dist: ninja~=1.13.0; extra == "primitives"
+Requires-Dist: nvidia-curobo@ git+https://github.com/StanfordVL/curobo@cbaf7d32436160956dad190a9465360fad6aba73 ; extra == "primitives"
+Requires-Dist: ompl@ https://storage.googleapis.com/gibson_scenes/ompl-1.6.0-cp310-cp310-manylinux_2_28_x86_64.whl ; extra == "primitives"
+Provides-Extra: eval
+Requires-Dist: dm_tree>=0.1.9; extra == "eval"
+Requires-Dist: hydra-core>=1.3.2; extra == "eval"
+Requires-Dist: websockets>=15.0.1; extra == "eval"
+Requires-Dist: msgpack>=1.1.0; extra == "eval"
+Requires-Dist: lerobot@ git+https://github.com/huggingface/lerobot@577cd10974b84bea1f06b6472eb9e5e74e07f77a ; extra == "eval"
+Requires-Dist: gspread>=6.2.1; extra == "eval"
+Requires-Dist: open3d>=0.19.0; extra == "eval"
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+
+
+[![Tests](https://github.com/StanfordVL/OmniGibson/actions/workflows/tests.yml/badge.svg?branch=main&event=push)](https://github.com/StanfordVL/OmniGibson/actions/workflows/tests.yml)
+[![Docker Image Version (latest by date)](https://img.shields.io/docker/v/stanfordvl/omnigibson?label=docker&sort=semver)](https://hub.docker.com/r/stanfordvl/omnigibson)
+[![Realtime Speed](https://behavior.stanford.edu/knowledgebase/profile/badge.svg)](https://stanfordvl.github.io/OmniGibson/profiling/)
+
+-------
+
+### Need support? Join our Discord!
+
+-------
+
+### Latest Updates
+- [10/01/24] **v1.1.0**: Major improvements, stability fixes, pip installation, and much more! [[release notes]](https://github.com/StanfordVL/OmniGibson/releases/tag/v1.1.0)
+
+- [03/17/24] **v1.0.0**: First full release with 1,004 pre-sampled tasks, all 50 scenes, and many new objects! [[release notes]](https://github.com/StanfordVL/OmniGibson/releases/tag/v1.0.0)
+
+- [08/04/23] **v0.2.0**: More assets! 600 pre-sampled tasks, 7 new scenes, and many new objects 📈 [[release notes]](https://github.com/StanfordVL/OmniGibson/releases/tag/v0.2.0)
+
+- [04/10/23] **v0.1.0**: Significantly improved stability, performance, and ease of installation :wrench: [[release notes]](https://github.com/StanfordVL/OmniGibson/releases/tag/v0.1.0)
+
+-------
+
+**`OmniGibson`** is a platform for accelerating Embodied AI research built upon NVIDIA's [Omniverse](https://www.nvidia.com/en-us/omniverse/) platform, featuring:
+
+* 📸 Photorealistic Visuals and 📐 Physical Realism
+* 🌊 Fluid and 👕 Soft Body Support
+* 🏔️ Large-Scale, High-Quality Scenes and 🎾 Objects
+* 🌡️ Dynamic Kinematic and Semantic Object States
+* 🤖 Mobile Manipulator Robots with Modular ⚙️ Controllers
+* 🌎 OpenAI Gym Interface
+
+Check out [**`OmniGibson`**'s documentation](https://behavior.stanford.edu/omnigibson/getting_started/installation.html) to get started!
+
+### Citation
+If you use **`OmniGibson`** or its assets and models, please cite:
+
+```
+@inproceedings{
+li2022behavior,
+title={{BEHAVIOR}-1K: A Benchmark for Embodied {AI} with 1,000 Everyday Activities and Realistic Simulation},
+author={Chengshu Li and Ruohan Zhang and Josiah Wong and Cem Gokmen and Sanjana Srivastava and Roberto Mart{\'\i}n-Mart{\'\i}n and Chen Wang and Gabrael Levine and Michael Lingelbach and Jiankai Sun and Mona Anvari and Minjune Hwang and Manasi Sharma and Arman Aydin and Dhruva Bansal and Samuel Hunter and Kyu-Young Kim and Alan Lou and Caleb R Matthews and Ivan Villa-Renteria and Jerry Huayang Tang and Claire Tang and Fei Xia and Silvio Savarese and Hyowon Gweon and Karen Liu and Jiajun Wu and Li Fei-Fei},
+booktitle={6th Annual Conference on Robot Learning},
+year={2022},
+url={https://openreview.net/forum?id=_8DoIe8G3t}
+}
+```
+
+### Profiling
+Click on the plot to access our profiling page with more examples.
+

OmniGibson/omnigibson.egg-info/SOURCES.txt

@@ -0,0 +1,338 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+omnigibson/.gitignore
+omnigibson/__init__.py
+omnigibson/kit_file_changes.patch
+omnigibson/lazy.py
+omnigibson/macros.py
+omnigibson/omnigibson_4_5_0.kit
+omnigibson/simulator.py
+omnigibson/transition_rules.py
+omnigibson.egg-info/PKG-INFO
+omnigibson.egg-info/SOURCES.txt
+omnigibson.egg-info/dependency_links.txt
+omnigibson.egg-info/not-zip-safe
+omnigibson.egg-info/requires.txt
+omnigibson.egg-info/top_level.txt
+omnigibson/action_primitives/action_primitive_set_base.py
+omnigibson/action_primitives/curobo.py
+omnigibson/action_primitives/starter_semantic_action_primitives.py
+omnigibson/action_primitives/symbolic_semantic_action_primitives.py
+omnigibson/configs/avg_category_specs.json
+omnigibson/configs/default_cfg.yaml
+omnigibson/configs/franka_vector_env.yaml
+omnigibson/configs/r1_primitives.yaml
+omnigibson/configs/r1pro_behavior.yaml
+omnigibson/configs/tiago_primitives.yaml
+omnigibson/configs/turtlebot_nav.yaml
+omnigibson/configs/controllers/dd.yaml
+omnigibson/configs/controllers/ik.yaml
+omnigibson/configs/controllers/joint.yaml
+omnigibson/configs/controllers/multi_finger_gripper.yaml
+omnigibson/configs/controllers/null_gripper.yaml
+omnigibson/configs/robots/fetch.yaml
+omnigibson/configs/robots/freight.yaml
+omnigibson/configs/robots/husky.yaml
+omnigibson/configs/robots/locobot.yaml
+omnigibson/configs/robots/turtlebot.yaml
+omnigibson/configs/sensors/scan.yaml
+omnigibson/configs/sensors/vision.yaml
+omnigibson/controllers/__init__.py
+omnigibson/controllers/controller_base.py
+omnigibson/controllers/dd_controller.py
+omnigibson/controllers/holonomic_base_joint_controller.py
+omnigibson/controllers/ik_controller.py
+omnigibson/controllers/joint_controller.py
+omnigibson/controllers/multi_finger_gripper_controller.py
+omnigibson/controllers/null_joint_controller.py
+omnigibson/controllers/osc_controller.py
+omnigibson/envs/__init__.py
+omnigibson/envs/data_wrapper.py
+omnigibson/envs/env_base.py
+omnigibson/envs/env_wrapper.py
+omnigibson/envs/metrics_wrapper.py
+omnigibson/envs/sb3_vec_env.py
+omnigibson/envs/vec_env_base.py
+omnigibson/examples/__init__.py
+omnigibson/examples/action_primitives/__init__.py
+omnigibson/examples/action_primitives/rs_int_example.py
+omnigibson/examples/action_primitives/solve_simple_task.py
+omnigibson/examples/action_primitives/wip_solve_behavior_task.py
+omnigibson/examples/environments/__init__.py
+omnigibson/examples/environments/behavior_env_demo.py
+omnigibson/examples/environments/navigation_env_demo.py
+omnigibson/examples/environments/vector_env_demo.py
+omnigibson/examples/learning/__init__.py
+omnigibson/examples/learning/navigation_policy_demo.py
+omnigibson/examples/object_states/__init__.py
+omnigibson/examples/object_states/attachment_demo.py
+omnigibson/examples/object_states/dicing_demo.py
+omnigibson/examples/object_states/folded_unfolded_state_demo.py
+omnigibson/examples/object_states/heat_source_or_sink_demo.py
+omnigibson/examples/object_states/heated_state_demo.py
+omnigibson/examples/object_states/object_state_texture_demo.py
+omnigibson/examples/object_states/onfire_demo.py
+omnigibson/examples/object_states/overlaid_demo.py
+omnigibson/examples/object_states/particle_applier_remover_demo.py
+omnigibson/examples/object_states/particle_source_sink_demo.py
+omnigibson/examples/object_states/sample_kinematics_demo.py
+omnigibson/examples/object_states/slicing_demo.py
+omnigibson/examples/object_states/temperature_demo.py
+omnigibson/examples/objects/__init__.py
+omnigibson/examples/objects/draw_bounding_box.py
+omnigibson/examples/objects/highlight_objects.py
+omnigibson/examples/objects/import_custom_object.py
+omnigibson/examples/objects/load_object_selector.py
+omnigibson/examples/objects/view_cloth_configurations.py
+omnigibson/examples/objects/visualize_object.py
+omnigibson/examples/robots/__init__.py
+omnigibson/examples/robots/all_robots_visualizer.py
+omnigibson/examples/robots/curobo_example.py
+omnigibson/examples/robots/grasping_mode_example.py
+omnigibson/examples/robots/import_custom_robot.py
+omnigibson/examples/robots/robot_control_example.py
+omnigibson/examples/scenes/__init__.py
+omnigibson/examples/scenes/scene_selector.py
+omnigibson/examples/scenes/scene_tour_demo.py
+omnigibson/examples/scenes/traversability_map_example.py
+omnigibson/examples/simulator/__init__.py
+omnigibson/examples/simulator/sim_save_load_example.py
+omnigibson/examples/teleoperation/__init__.py
+omnigibson/examples/teleoperation/robot_teleoperate_demo.py
+omnigibson/examples/teleoperation/vr_robot_control_demo.py
+omnigibson/examples/teleoperation/vr_scene_tour_demo.py
+omnigibson/learning/__init__.py
+omnigibson/learning/eval.py
+omnigibson/learning/policies.py
+omnigibson/learning/configs/base_config.yaml
+omnigibson/learning/configs/policy/local.yaml
+omnigibson/learning/configs/policy/websocket.yaml
+omnigibson/learning/configs/robot/a1.yaml
+omnigibson/learning/configs/robot/r1pro.yaml
+omnigibson/learning/configs/task/behavior.yaml
+omnigibson/learning/datas/__init__.py
+omnigibson/learning/datas/iterable_dataset.py
+omnigibson/learning/datas/lerobot_dataset.py
+omnigibson/learning/utils/__init__.py
+omnigibson/learning/utils/array_tensor_utils.py
+omnigibson/learning/utils/config_utils.py
+omnigibson/learning/utils/dataset_utils.py
+omnigibson/learning/utils/eval_utils.py
+omnigibson/learning/utils/lerobot_utils.py
+omnigibson/learning/utils/network_utils.py
+omnigibson/learning/utils/obs_utils.py
+omnigibson/learning/utils/score_utils.py
+omnigibson/learning/wrappers/__init__.py
+omnigibson/learning/wrappers/default_wrapper.py
+omnigibson/learning/wrappers/heavy_robot_wrapper.py
+omnigibson/learning/wrappers/rgb_low_res_wrapper.py
+omnigibson/learning/wrappers/rich_obs_wrapper.py
+omnigibson/maps/__init__.py
+omnigibson/maps/map_base.py
+omnigibson/maps/segmentation_map.py
+omnigibson/maps/traversable_map.py
+omnigibson/materials/omnigibson_vray_mtl.mdl
+omnigibson/materials/vray_maps.mdl
+omnigibson/materials/vray_materials.mdl
+omnigibson/metrics/__init__.py
+omnigibson/metrics/agent_metric.py
+omnigibson/metrics/metric_base.py
+omnigibson/metrics/task_metric.py
+omnigibson/object_states/__init__.py
+omnigibson/object_states/aabb.py
+omnigibson/object_states/adjacency.py
+omnigibson/object_states/attached_to.py
+omnigibson/object_states/burnt.py
+omnigibson/object_states/cloth_mixin.py
+omnigibson/object_states/contact_bodies.py
+omnigibson/object_states/contact_particles.py
+omnigibson/object_states/contact_subscribed_state_mixin.py
+omnigibson/object_states/contains.py
+omnigibson/object_states/cooked.py
+omnigibson/object_states/covered.py
+omnigibson/object_states/draped.py
+omnigibson/object_states/factory.py
+omnigibson/object_states/filled.py
+omnigibson/object_states/folded.py
+omnigibson/object_states/frozen.py
+omnigibson/object_states/heat_source_or_sink.py
+omnigibson/object_states/heated.py
+omnigibson/object_states/inside.py
+omnigibson/object_states/joint_break_subscribed_state_mixin.py
+omnigibson/object_states/joint_state.py
+omnigibson/object_states/kinematics_mixin.py
+omnigibson/object_states/link_based_state_mixin.py
+omnigibson/object_states/max_temperature.py
+omnigibson/object_states/next_to.py
+omnigibson/object_states/object_state_base.py
+omnigibson/object_states/on_fire.py
+omnigibson/object_states/on_top.py
+omnigibson/object_states/open_state.py
+omnigibson/object_states/overlaid.py
+omnigibson/object_states/particle.py
+omnigibson/object_states/particle_modifier.py
+omnigibson/object_states/particle_source_or_sink.py
+omnigibson/object_states/pose.py
+omnigibson/object_states/robot_related_states.py
+omnigibson/object_states/saturated.py
+omnigibson/object_states/sliceable.py
+omnigibson/object_states/slicer_active.py
+omnigibson/object_states/temperature.py
+omnigibson/object_states/tensorized_value_state.py
+omnigibson/object_states/toggle.py
+omnigibson/object_states/touching.py
+omnigibson/object_states/under.py
+omnigibson/object_states/update_state_mixin.py
+omnigibson/objects/__init__.py
+omnigibson/objects/controllable_object.py
+omnigibson/objects/dataset_object.py
+omnigibson/objects/light_object.py
+omnigibson/objects/object_base.py
+omnigibson/objects/primitive_object.py
+omnigibson/objects/stateful_object.py
+omnigibson/objects/usd_object.py
+omnigibson/prims/__init__.py
+omnigibson/prims/cloth_prim.py
+omnigibson/prims/entity_prim.py
+omnigibson/prims/geom_prim.py
+omnigibson/prims/joint_prim.py
+omnigibson/prims/material_prim.py
+omnigibson/prims/prim_base.py
+omnigibson/prims/rigid_dynamic_prim.py
+omnigibson/prims/rigid_kinematic_prim.py
+omnigibson/prims/rigid_prim.py
+omnigibson/prims/xform_prim.py
+omnigibson/reward_functions/__init__.py
+omnigibson/reward_functions/collision_reward.py
+omnigibson/reward_functions/grasp_reward.py
+omnigibson/reward_functions/point_goal_reward.py
+omnigibson/reward_functions/potential_reward.py
+omnigibson/reward_functions/reaching_goal_reward.py
+omnigibson/reward_functions/reward_function_base.py
+omnigibson/robots/__init__.py
+omnigibson/robots/a1.py
+omnigibson/robots/active_camera_robot.py
+omnigibson/robots/articulated_trunk_robot.py
+omnigibson/robots/behavior_robot.py
+omnigibson/robots/fetch.py
+omnigibson/robots/franka.py
+omnigibson/robots/franka_mounted.py
+omnigibson/robots/freight.py
+omnigibson/robots/holonomic_base_robot.py
+omnigibson/robots/husky.py
+omnigibson/robots/locobot.py
+omnigibson/robots/locomotion_robot.py
+omnigibson/robots/manipulation_robot.py
+omnigibson/robots/mobile_manipulation_robot.py
+omnigibson/robots/r1.py
+omnigibson/robots/r1pro.py
+omnigibson/robots/robot_base.py
+omnigibson/robots/stretch.py
+omnigibson/robots/tiago.py
+omnigibson/robots/turtlebot.py
+omnigibson/robots/two_wheel_robot.py
+omnigibson/robots/untucked_arm_pose_robot.py
+omnigibson/robots/vx300s.py
+omnigibson/sampling/autogenerate_task_custom_list_template.py
+omnigibson/sampling/chengshu_task_custom_lists.json
+omnigibson/sampling/create_stable_scene.py
+omnigibson/sampling/cremebrule_1_sample.sh
+omnigibson/sampling/cremebrule_2_postprocess.sh
+omnigibson/sampling/cremebrule_3_multiply.sh
+omnigibson/sampling/cremebrule_task_custom_lists.json
+omnigibson/sampling/hang_task_custom_lists.json
+omnigibson/sampling/multiply_b1k_tasks.py
+omnigibson/sampling/postprocess_sampled_task.py
+omnigibson/sampling/sample_b1k_tasks.py
+omnigibson/sampling/task_custom_lists.json
+omnigibson/sampling/utils.py
+omnigibson/scene_graphs/__init__.py
+omnigibson/scene_graphs/graph_builder.py
+omnigibson/scenes/__init__.py
+omnigibson/scenes/interactive_traversable_scene.py
+omnigibson/scenes/scene_base.py
+omnigibson/scenes/static_traversable_scene.py
+omnigibson/scenes/traversable_scene.py
+omnigibson/sensors/__init__.py
+omnigibson/sensors/dropout_sensor_noise.py
+omnigibson/sensors/scan_sensor.py
+omnigibson/sensors/sensor_base.py
+omnigibson/sensors/sensor_noise_base.py
+omnigibson/sensors/vision_sensor.py
+omnigibson/systems/__init__.py
+omnigibson/systems/macro_particle_system.py
+omnigibson/systems/micro_particle_system.py
+omnigibson/systems/system_base.py
+omnigibson/tasks/__init__.py
+omnigibson/tasks/behavior_task.py
+omnigibson/tasks/dummy_task.py
+omnigibson/tasks/grasp_task.py
+omnigibson/tasks/point_navigation_task.py
+omnigibson/tasks/point_reaching_task.py
+omnigibson/tasks/task_base.py
+omnigibson/termination_conditions/__init__.py
+omnigibson/termination_conditions/falling.py
+omnigibson/termination_conditions/grasp_goal.py
+omnigibson/termination_conditions/max_collision.py
+omnigibson/termination_conditions/point_goal.py
+omnigibson/termination_conditions/predicate_goal.py
+omnigibson/termination_conditions/reaching_goal.py
+omnigibson/termination_conditions/termination_condition_base.py
+omnigibson/termination_conditions/timeout.py
+omnigibson/utils/__init__.py
+omnigibson/utils/asset_conversion_utils.py
+omnigibson/utils/asset_utils.py
+omnigibson/utils/backend_utils.py
+omnigibson/utils/bddl_utils.py
+omnigibson/utils/coacd_runner.py
+omnigibson/utils/config_utils.py
+omnigibson/utils/constants.py
+omnigibson/utils/control_utils.py
+omnigibson/utils/data_utils.py
+omnigibson/utils/deprecated_utils.py
+omnigibson/utils/geometry_utils.py
+omnigibson/utils/git_utils.py
+omnigibson/utils/grasping_planning_utils.py
+omnigibson/utils/gym_utils.py
+omnigibson/utils/lazy_import_utils.py
+omnigibson/utils/motion_planning_utils.py
+omnigibson/utils/numpy_utils.py
+omnigibson/utils/object_state_utils.py
+omnigibson/utils/object_utils.py
+omnigibson/utils/physx_utils.py
+omnigibson/utils/processing_utils.py
+omnigibson/utils/profiling_utils.py
+omnigibson/utils/pynvml_utils.py
+omnigibson/utils/python_utils.py
+omnigibson/utils/registry_utils.py
+omnigibson/utils/render_utils.py
+omnigibson/utils/sampling_utils.py
+omnigibson/utils/sim_utils.py
+omnigibson/utils/teleop_utils.py
+omnigibson/utils/transform_utils.py
+omnigibson/utils/transform_utils_np.py
+omnigibson/utils/ui_utils.py
+omnigibson/utils/urdfpy_utils.py
+omnigibson/utils/usd_utils.py
+omnigibson/utils/vision_utils.py
+tests/test_controllers.py
+tests/test_curobo.py
+tests/test_data_collection.py
+tests/test_dump_load_states.py
+tests/test_envs.py
+tests/test_multiple_envs.py
+tests/test_object_removal.py
+tests/test_object_states.py
+tests/test_primitives.py
+tests/test_robot_states_flatcache.py
+tests/test_robot_states_no_flatcache.py
+tests/test_robot_teleoperation.py
+tests/test_scene_graph.py
+tests/test_sensors.py
+tests/test_symbolic_primitives.py
+tests/test_systems.py
+tests/test_transform_utils.py
+tests/test_transition_rules.py

OmniGibson/omnigibson.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

OmniGibson/omnigibson.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

OmniGibson/omnigibson.egg-info/requires.txt

@@ -0,0 +1,62 @@
+huggingface-hub[cli]>=0.34.4
+gymnasium>=0.28.1
+numpy<2.0.0,>=1.23.5
+scipy>=1.10.1
+GitPython>=3.1.40
+transforms3d>=0.4.1
+networkx>=3.2.1
+PyYAML>=6.0.1
+addict>=2.4.0
+ipython>=8.20.0
+future>=0.18.3
+trimesh>=4.0.8
+h5py>=3.10.0
+cryptography>=41.0.7
+bddl~=3.7.0
+opencv-python>=4.8.1
+nest_asyncio>=1.5.6
+imageio>=2.33.1
+imageio-ffmpeg>=0.4.9
+termcolor>=2.4.0
+progressbar>=2.5
+pymeshlab~=2022.2
+click>=8.1.3
+aenum>=3.1.15
+rtree>=1.2.0
+graphviz>=0.20
+matplotlib>=3.0.0
+lxml>=5.2.2
+numba>=0.59.1
+cffi~=1.17.1
+pillow~=11.0.0
+
+[dev]
+pytest>=6.2.3
+pytest-cov>=3.0.0
+pytest_rerunfailures
+mkdocs
+mkdocs-autorefs
+mkdocs-gen-files
+mkdocs-material
+mkdocs-material-extensions
+mkdocstrings[python]
+mkdocs-section-index
+mkdocs-literate-nav
+mkdocs-redirects
+mkdocs-include-markdown-plugin
+telemoma~=0.3.0
+gspread>=6.2.1
+
+[eval]
+dm_tree>=0.1.9
+hydra-core>=1.3.2
+websockets>=15.0.1
+msgpack>=1.1.0
+lerobot@ git+https://github.com/huggingface/lerobot@577cd10974b84bea1f06b6472eb9e5e74e07f77a
+gspread>=6.2.1
+open3d>=0.19.0
+
+[primitives]
+ninja~=1.13.0
+nvidia-curobo@ git+https://github.com/StanfordVL/curobo@cbaf7d32436160956dad190a9465360fad6aba73
+ompl@ https://storage.googleapis.com/gibson_scenes/ompl-1.6.0-cp310-cp310-manylinux_2_28_x86_64.whl

OmniGibson/omnigibson.egg-info/top_level.txt

@@ -0,0 +1 @@
+omnigibson

OmniGibson/omnigibson/learning/datas/__init__.py

@@ -0,0 +1,8 @@
+from .iterable_dataset import BehaviorIterableDataset
+from .lerobot_dataset import BehaviorLeRobotDataset, BehaviorLerobotDatasetMetadata
+
+__all__ = [
+    "BehaviorIterableDataset",
+    "BehaviorLeRobotDataset",
+    "BehaviorLerobotDatasetMetadata",
+]

OmniGibson/omnigibson/learning/datas/iterable_dataset.py

@@ -0,0 +1,448 @@
+import h5py
+import json
+import numpy as np
+import os
+import pandas as pd
+import torch as th
+import torch.distributed as dist
+from copy import deepcopy
+from omegaconf import OmegaConf, ListConfig
+from omnigibson.learning.utils.array_tensor_utils import (
+    any_concat,
+    any_ones_like,
+    any_slice,
+    any_stack,
+    get_batch_size,
+    sequential_sum_balanced_partitioning,
+)
+from omnigibson.learning.utils.eval_utils import (
+    ACTION_QPOS_INDICES,
+    JOINT_RANGE,
+    PROPRIO_QPOS_INDICES,
+    PROPRIOCEPTION_INDICES,
+    TASK_NAMES_TO_INDICES,
+    EEF_POSITION_RANGE,
+    ROBOT_CAMERA_NAMES,
+)
+from omnigibson.learning.utils.obs_utils import OBS_LOADER_MAP
+from omnigibson.utils.ui_utils import create_module_logger
+from torch.utils.data import IterableDataset, get_worker_info
+from typing import Any, Optional, List, Tuple, Dict, Generator
+
+
+logger = create_module_logger("BehaviorIterableDataset")
+
+
+class BehaviorIterableDataset(IterableDataset):
+    """
+    BehaviorIterableDataset is an IterableDataset designed for loading and streaming demonstration data for behavior tasks.
+    It supports multi-modal observations (including low-dimensional proprioception, visual data, and point clouds), action chunking,
+    temporal context windows, and distributed data loading for scalable training.
+    Key Features:
+        - Loads demonstration data from disk, supporting multiple tasks and robots.
+        - Preloads low-dimensional data (actions, proprioception, task info) into memory for efficient access.
+        - Supports visual observation types: RGB, depth, segmentation, and point clouds, with multi-view camera support.
+        - Handles action chunking for sequence prediction tasks, with optional prediction horizon and masking.
+        - Supports temporal downsampling of data for variable frame rates.
+        - Provides deterministic shuffling and partitioning for distributed and multi-worker training.
+        - Normalizes observations and actions to standardized ranges for learning.
+        - Optionally loads and normalizes privileged task information.
+        - Implements efficient chunked streaming of data for training with context windows.
+    """
+
+    @classmethod
+    def get_all_demo_keys(cls, data_path: str, task_names: List[str]) -> List[Any]:
+        assert os.path.exists(data_path), "Data path does not exist!"
+        task_dir_names = [f"task-{TASK_NAMES_TO_INDICES[name]:04d}" for name in task_names]
+        demo_keys = sorted(
+            [
+                file_name.split(".")[0].split("_")[-1]
+                for task_dir_name in task_dir_names
+                for file_name in os.listdir(f"{data_path}/2025-challenge-demos/data/{task_dir_name}")
+                if file_name.endswith(".parquet")
+            ]
+        )
+        return demo_keys
+
+    def __init__(
+        self,
+        *args,
+        data_path: str,
+        demo_keys: List[Any],
+        robot_type: str = "R1Pro",
+        obs_window_size: int,
+        ctx_len: int,
+        use_action_chunks: bool = False,
+        action_prediction_horizon: Optional[int] = None,
+        downsample_factor: int = 1,
+        visual_obs_types: List[str],
+        multi_view_cameras: Optional[Dict[str, Any]] = None,
+        use_task_info: bool = False,
+        task_info_range: Optional[ListConfig] = None,
+        seed: int = 42,
+        shuffle: bool = True,
+        **kwargs,
+    ) -> None:
+        """
+        Initialize the BehaviorIterableDataset.
+        Args:
+            data_path (str): Path to the data directory.
+            demo_keys (List[Any]): List of demo keys.
+            robot_type (str): Type of the robot. Default is "R1Pro".
+            obs_window_size (int): Size of the observation window.
+            ctx_len (int): Context length.
+            use_action_chunks (bool): Whether to use action chunks.
+                Action will be from (T, A) to (T, L_pred_horizon, A)
+            action_prediction_horizon (Optional[int]): Horizon of the action prediction.
+                Must not be None if use_action_chunks is True.
+            downsample_factor (int): Downsample factor for the data (with uniform temporal subsampling).
+                Note that the original data is at 30Hz, so if factor=3 then data will be at 10Hz.
+                Default is 1 (no downsampling), must be >= 1.
+            visual_obs_types (List[str]): List of visual observation types to load.
+                Valid options are: "rgb", "depth", "seg".
+            multi_view_cameras (Optional[Dict[str, Any]]): Dict of id-camera pairs to load obs from.
+            use_task_info (bool): Whether to load privileged task information.
+            task_info_range (Optional[ListConfig]): Range of the task information (for normalization).
+            seed (int): Random seed.
+            shuffle (bool): Whether to shuffle the dataset.
+        """
+        super().__init__(*args, **kwargs)
+        self._data_path = data_path
+        self._demo_keys = demo_keys
+        self._robot_type = robot_type
+        self._obs_window_size = obs_window_size
+        self._ctx_len = ctx_len
+        self._use_action_chunks = use_action_chunks
+        self._action_prediction_horizon = action_prediction_horizon
+        assert (
+            self._action_prediction_horizon is not None if self._use_action_chunks else True
+        ), "action_prediction_horizon must be provided if use_action_chunks is True!"
+        self._downsample_factor = downsample_factor
+        assert self._downsample_factor >= 1, "downsample_factor must be >= 1!"
+        self._use_task_info = use_task_info
+        self._task_info_range = (
+            th.tensor(OmegaConf.to_container(task_info_range)) if task_info_range is not None else None
+        )
+        self._seed = seed
+        self._shuffle = shuffle
+        self._epoch = 0
+
+        assert set(visual_obs_types).issubset(
+            {"rgb", "depth_linear", "seg_instance_id", "pcd"}
+        ), "visual_obs_types must be a subset of {'rgb', 'depth_linear', 'seg_instance_id', 'pcd'}!"
+        self._visual_obs_types = set(visual_obs_types)
+
+        self._multi_view_cameras = multi_view_cameras
+
+        self._demo_indices = list(range(len(self._demo_keys)))
+        # Preload low dim into memory
+        self._all_demos = [self._preload_demo(demo_key) for demo_key in self._demo_keys]
+        # get demo lengths (N_chunks)
+        self._demo_lengths = []
+        for demo in self._all_demos:
+            L = get_batch_size(demo, strict=True)
+            assert L >= self._obs_window_size >= 1
+            self._demo_lengths.append(L - self._obs_window_size + 1)
+        logger.info(f"Dataset chunk length: {sum(self._demo_lengths)}")
+
+    @property
+    def epoch(self):
+        return self._epoch
+
+    @epoch.setter
+    def epoch(self, epoch: int):
+        self._epoch = epoch
+        if self._shuffle:
+            # deterministically shuffle the demos
+            g = th.Generator()
+            g.manual_seed(epoch + self._seed)
+            self._demo_indices = th.randperm(len(self._demo_keys), generator=g).tolist()
+
+    def __iter__(self) -> Generator[Dict[str, Any], None, None]:
+        global_worker_id, total_global_workers = self._get_global_worker_id()
+        demo_lengths_shuffled = [self._demo_lengths[i] for i in self._demo_indices]
+        start_demo_id, start_demo_idx, end_demo_id, end_demo_idx = sequential_sum_balanced_partitioning(
+            demo_lengths_shuffled, total_global_workers, global_worker_id
+        )
+        for demo_idx, demo_ptr in enumerate(self._demo_indices[start_demo_id : end_demo_id + 1]):
+            start_idx = start_demo_idx if demo_idx == 0 else 0
+            end_idx = end_demo_idx if demo_idx == end_demo_id - start_demo_id else self._demo_lengths[demo_ptr]
+            yield from self.get_streamed_data(demo_ptr, start_idx, end_idx)
+
+    def get_streamed_data(self, demo_ptr: int, start_idx: int, end_idx: int) -> Generator[Dict[str, Any], None, None]:
+        task_id = int(self._demo_keys[demo_ptr]) // 10000
+        chunk_generator = self._chunk_demo(demo_ptr, start_idx, end_idx)
+        # Initialize obs loaders
+        obs_loaders = dict()
+        for obs_type in self._visual_obs_types:
+            if obs_type == "pcd":
+                # pcd_generator
+                f_pcd = h5py.File(
+                    f"{self._data_path}/pcd_vid/task-{task_id:04d}/episode_{self._demo_keys[demo_ptr]}.hdf5",
+                    "r",
+                    swmr=True,
+                    libver="latest",
+                )
+                # Create a generator that yields sliding windows of point clouds
+                pcd_data = f_pcd["data/demo_0/robot_r1::fused_pcd"]
+                pcd_generator = self._h5_window_generator(pcd_data, start_idx, end_idx)
+            else:
+                # calculate the start a
+                for camera_id in self._multi_view_cameras.keys():
+                    camera_name = self._multi_view_cameras[camera_id]["name"]
+                    stride = 1
+                    kwargs = {}
+                    if obs_type == "seg_instance_id":
+                        with open(
+                            f"{self._data_path}/2025-challenge-demos/meta/episodes/task-{task_id:04d}/episode_{self._demo_keys[demo_ptr]}.json",
+                            "r",
+                        ) as f:
+                            kwargs["id_list"] = th.tensor(
+                                json.load(f)[f"{ROBOT_CAMERA_NAMES['R1Pro'][camera_id]}::unique_ins_ids"]
+                            )
+                    obs_loaders[f"{camera_name}::{obs_type}"] = iter(
+                        OBS_LOADER_MAP[obs_type](
+                            data_path=f"{self._data_path}/2025-challenge-demos",
+                            task_id=task_id,
+                            camera_id=camera_id,
+                            demo_id=self._demo_keys[demo_ptr],
+                            batch_size=self._obs_window_size,
+                            stride=stride,
+                            start_idx=start_idx * stride * self._downsample_factor,
+                            end_idx=((end_idx - 1) * stride + self._obs_window_size) * self._downsample_factor,
+                            output_size=tuple(self._multi_view_cameras[camera_id]["resolution"]),
+                            **kwargs,
+                        )
+                    )
+        for _ in range(start_idx, end_idx):
+            data, mask = next(chunk_generator)
+            # load visual obs
+            for obs_type in self._visual_obs_types:
+                if obs_type == "pcd":
+                    # get file from
+                    data["obs"]["pcd"] = next(pcd_generator)
+                else:
+                    for camera in self._multi_view_cameras.values():
+                        data["obs"][f"{camera['name']}::{obs_type}"] = next(
+                            obs_loaders[f"{camera['name']}::{obs_type}"]
+                        )
+            data["masks"] = mask
+            yield data
+        for obs_type in self._visual_obs_types:
+            if obs_type == "pcd":
+                f_pcd.close()
+            else:
+                for camera in self._multi_view_cameras.values():
+                    obs_loaders[f"{camera['name']}::{obs_type}"].close()
+
+    def _preload_demo(self, demo_key: Any) -> Dict[str, Any]:
+        """
+        Preload a single demo into memory. Currently it loads action, proprio, and optionally task info.
+        Args:
+            demo_key (Any): Key of the demo to preload.
+        Returns:
+            demo (dict): Preloaded demo.
+        """
+        demo = dict()
+        demo["obs"] = {"qpos": dict(), "eef": dict()}
+        # load low_dim data
+        action_dict = dict()
+        low_dim_data = self._extract_low_dim_data(demo_key)
+        for key, data in low_dim_data.items():
+            if key == "proprio":
+                # normalize proprioception
+                if "base_qvel" in PROPRIOCEPTION_INDICES[self._robot_type]:
+                    demo["obs"]["odom"] = {
+                        "base_velocity": 2
+                        * (
+                            data[..., PROPRIOCEPTION_INDICES[self._robot_type]["base_qvel"]]
+                            - JOINT_RANGE[self._robot_type]["base"][0]
+                        )
+                        / (JOINT_RANGE[self._robot_type]["base"][1] - JOINT_RANGE[self._robot_type]["base"][0])
+                        - 1.0
+                    }
+                for key in PROPRIO_QPOS_INDICES[self._robot_type]:
+                    if "gripper" in key:
+                        # rectify gripper actions to {-1, 1}
+                        demo["obs"]["qpos"][key] = th.mean(
+                            data[..., PROPRIO_QPOS_INDICES[self._robot_type][key]], dim=-1, keepdim=True
+                        )
+                        demo["obs"]["qpos"][key] = th.where(
+                            demo["obs"]["qpos"][key]
+                            > (JOINT_RANGE[self._robot_type][key][0] + JOINT_RANGE[self._robot_type][key][1]) / 2,
+                            1.0,
+                            -1.0,
+                        )
+                    else:
+                        # normalize the qpos to [-1, 1]
+                        demo["obs"]["qpos"][key] = (
+                            2
+                            * (
+                                data[..., PROPRIO_QPOS_INDICES[self._robot_type][key]]
+                                - JOINT_RANGE[self._robot_type][key][0]
+                            )
+                            / (JOINT_RANGE[self._robot_type][key][1] - JOINT_RANGE[self._robot_type][key][0])
+                            - 1.0
+                        )
+                for key in EEF_POSITION_RANGE[self._robot_type]:
+                    demo["obs"]["eef"][f"{key}_pos"] = (
+                        2
+                        * (
+                            data[..., PROPRIOCEPTION_INDICES[self._robot_type][f"eef_{key}_pos"]]
+                            - EEF_POSITION_RANGE[self._robot_type][key][0]
+                        )
+                        / (EEF_POSITION_RANGE[self._robot_type][key][1] - EEF_POSITION_RANGE[self._robot_type][key][0])
+                        - 1.0
+                    )
+                    # don't normalize the eef orientation
+                    demo["obs"]["eef"][f"{key}_quat"] = data[
+                        ..., PROPRIOCEPTION_INDICES[self._robot_type][f"eef_{key}_quat"]
+                    ]
+            elif key == "action":
+                # Note that we need to take the action at the timestamp before the next observation
+                # First pad the action array so that it is divisible by the downsample factor
+                if data.shape[0] % self._downsample_factor != 0:
+                    pad_size = self._downsample_factor - (data.shape[0] % self._downsample_factor)
+                    # pad with the last action
+                    data = th.cat([data, data[-1:].repeat(pad_size, 1)], dim=0)
+                # Now downsample the action array
+                data = data[self._downsample_factor - 1 :: self._downsample_factor]
+                for key, indices in ACTION_QPOS_INDICES[self._robot_type].items():
+                    action_dict[key] = data[:, indices]
+                    # action normalization
+                    if "gripper" not in key:  # Gripper actions are already normalized to [-1, 1]
+                        action_dict[key] = (
+                            2
+                            * (action_dict[key] - JOINT_RANGE[self._robot_type][key][0])
+                            / (JOINT_RANGE[self._robot_type][key][1] - JOINT_RANGE[self._robot_type][key][0])
+                            - 1.0
+                        )
+                if self._use_action_chunks:
+                    # make actions from (T, A) to (T, L_pred_horizon, A)
+                    # need to construct a mask
+                    action_chunks = []
+                    action_chunk_masks = []
+                    action_structure = deepcopy(any_slice(action_dict, np.s_[0:1]))  # (1, A)
+                    for t in range(get_batch_size(action_dict, strict=True)):
+                        action_chunk = any_slice(action_dict, np.s_[t : t + self._action_prediction_horizon])
+                        action_chunk_size = get_batch_size(action_chunk, strict=True)
+                        pad_size = self._action_prediction_horizon - action_chunk_size
+                        mask = any_concat(
+                            [
+                                th.ones((action_chunk_size,), dtype=th.bool),
+                                th.zeros((pad_size,), dtype=th.bool),
+                            ],
+                            dim=0,
+                        )  # (L_pred_horizon,)
+                        action_chunk = any_concat(
+                            [
+                                action_chunk,
+                            ]
+                            + [any_ones_like(action_structure)] * pad_size,
+                            dim=0,
+                        )  # (L_pred_horizon, A)
+                        action_chunks.append(action_chunk)
+                        action_chunk_masks.append(mask)
+                    action_chunks = any_stack(action_chunks, dim=0)  # (T, L_pred_horizon, A)
+                    action_chunk_masks = th.stack(action_chunk_masks, dim=0)  # (T, L_pred_horizon)
+                    demo["actions"] = action_chunks
+                    demo["action_masks"] = action_chunk_masks
+                else:
+                    demo["actions"] = action_dict
+            elif key == "task":
+                if self._task_info_range is not None:
+                    # Normalize task info to [-1, 1]
+                    demo["obs"]["task"] = (
+                        2 * (data - self._task_info_range[0]) / (self._task_info_range[1] - self._task_info_range[0])
+                        - 1.0
+                    )
+                else:
+                    # If no range is provided, just use the raw data
+                    demo["obs"]["task"] = data
+            else:
+                # For other keys, just store the data as is
+                demo["obs"][key] = data
+        return demo
+
+    def _extract_low_dim_data(self, demo_key: Any) -> Dict[str, th.Tensor]:
+        task_id = int(demo_key) // 10000
+        df = pd.read_parquet(
+            os.path.join(
+                self._data_path, "2025-challenge-demos", "data", f"task-{task_id:04d}", f"episode_{demo_key}.parquet"
+            )
+        )
+        ret = {
+            "proprio": th.from_numpy(
+                np.array(df["observation.state"][:: self._downsample_factor].tolist(), dtype=np.float32)
+            ),
+            "action": th.from_numpy(np.array(df["action"].tolist(), dtype=np.float32)),
+            "cam_rel_poses": th.from_numpy(
+                np.array(df["observation.cam_rel_poses"][:: self._downsample_factor].tolist(), dtype=np.float32)
+            ),
+        }
+        if self._use_task_info:
+            ret["task"] = th.from_numpy(
+                np.array(df["observation.task_info"][:: self._downsample_factor].tolist(), dtype=np.float32)
+            )
+        return ret
+
+    def _chunk_demo(self, demo_ptr: int, start_idx: int, end_idx: int) -> Generator[Tuple[dict, th.Tensor], None, None]:
+        demo = self._all_demos[demo_ptr]
+        # split obs into chunks
+        for chunk_idx in range(start_idx, end_idx):
+            data, mask = [], []
+            s = np.s_[chunk_idx : chunk_idx + self._obs_window_size]
+            data = dict()
+            for k in demo:
+                if k == "actions":
+                    data[k] = any_slice(demo[k], np.s_[chunk_idx : chunk_idx + self._ctx_len])
+                    action_chunk_size = get_batch_size(data[k], strict=True)
+                    pad_size = self._ctx_len - action_chunk_size
+                    if self._use_action_chunks:
+                        assert pad_size == 0, "pad_size should be 0 if use_action_chunks is True!"
+                        mask = demo["action_masks"][chunk_idx : chunk_idx + self._ctx_len]
+                    else:
+                        # pad action chunks to equal length of ctx_len
+                        data[k] = any_concat(
+                            [
+                                data[k],
+                            ]
+                            + [any_ones_like(any_slice(data[k], np.s_[0:1]))] * pad_size,
+                            dim=0,
+                        )
+                        mask = th.cat(
+                            [
+                                th.ones((action_chunk_size,), dtype=th.bool),
+                                th.zeros((pad_size,), dtype=th.bool),
+                            ],
+                            dim=0,
+                        )
+                elif k != "action_masks":
+                    data[k] = any_slice(demo[k], s)
+                else:
+                    # action_masks has already been processed
+                    pass
+            yield data, mask
+
+    def _get_global_worker_id(self):
+        worker_info = get_worker_info()
+        worker_id = worker_info.id if worker_info is not None else 0
+        if dist.is_initialized():
+            rank = dist.get_rank()
+            world_size = dist.get_world_size()
+            num_workers = worker_info.num_workers if worker_info else 1
+            global_worker_id = rank * num_workers + worker_id
+            total_global_workers = world_size * num_workers
+        else:
+            global_worker_id = worker_id
+            total_global_workers = worker_info.num_workers if worker_info else 1
+        return global_worker_id, total_global_workers
+
+    def _h5_window_generator(self, df: h5py.Dataset, start_idx: int, end_idx: int) -> Generator[th.Tensor, None, None]:
+        for i in range(start_idx, end_idx):
+            yield th.from_numpy(
+                df[
+                    i * self._downsample_factor : (i + self._obs_window_size)
+                    * self._downsample_factor : self._downsample_factor
+                ]
+            )

OmniGibson/omnigibson/learning/datas/lerobot_dataset.py

@@ -0,0 +1,557 @@
+import datasets
+import json
+import os
+import numpy as np
+import packaging.version
+import torch as th
+from collections import defaultdict
+from collections.abc import Callable
+from datasets import load_dataset
+from huggingface_hub import snapshot_download
+from lerobot.constants import HF_LEROBOT_HOME
+from lerobot.datasets.lerobot_dataset import LeRobotDataset, LeRobotDatasetMetadata, CODEBASE_VERSION
+from lerobot.datasets.utils import (
+    EPISODES_PATH,
+    EPISODES_STATS_PATH,
+    STATS_PATH,
+    TASKS_PATH,
+    cast_stats_to_numpy,
+    check_delta_timestamps,
+    check_timestamps_sync,
+    check_version_compatibility,
+    get_delta_indices,
+    get_episode_data_index,
+    get_safe_version,
+    backward_compatible_episodes_stats,
+    load_json,
+    load_jsonlines,
+    load_info,
+    is_valid_version,
+)
+from lerobot.datasets.video_utils import get_safe_default_codec
+from omnigibson.learning.utils.eval_utils import TASK_NAMES_TO_INDICES, ROBOT_CAMERA_NAMES
+from omnigibson.learning.utils.lerobot_utils import hf_transform_to_torch, decode_video_frames, aggregate_stats
+from omnigibson.learning.utils.obs_utils import OBS_LOADER_MAP
+from omnigibson.utils.ui_utils import create_module_logger
+from pathlib import Path
+from torch.utils.data import Dataset, get_worker_info
+from typing import Iterable, List, Tuple
+
+
+logger = create_module_logger("BehaviorLeRobotDataset")
+
+
+class BehaviorLeRobotDataset(LeRobotDataset):
+    """
+    BehaviorLeRobotDataset is a customized dataset class for loading and managing LeRobot datasets,
+    with additional filtering and loading options tailored for the BEHAVIOR-1K benchmark.
+    This class extends LeRobotDataset and introduces the following customizations:
+        - Task-based filtering: Load only episodes corresponding to specific tasks.
+        - Modality and camera selection: Load only specified modalities (e.g., "rgb", "depth", "seg_instance_id")
+          and cameras (e.g., "left_wrist", "right_wrist", "head").
+        - Ability to download and use additional annotation and metainfo files.
+        - Local-only mode: Optionally restrict dataset usage to local files, disabling downloads.
+        - Optional batch streaming using keyframe for faster access.
+    These customizations allow for more efficient and targeted dataset usage in the context of B1K tasks
+    """
+
+    def __init__(
+        self,
+        repo_id: str,
+        root: str | Path | None = None,
+        episodes: list[int] | None = None,
+        image_transforms: Callable | None = None,
+        delta_timestamps: dict[list[float]] | None = None,
+        tolerance_s: float = 1e-4,
+        revision: str | None = None,
+        force_cache_sync: bool = False,
+        download_videos: bool = True,
+        video_backend: str | None = "pyav",
+        batch_encoding_size: int = 1,
+        # === Customized arguments for BehaviorLeRobotDataset ===
+        tasks: Iterable[str] = None,
+        modalities: Iterable[str] = None,
+        cameras: Iterable[str] = None,
+        local_only: bool = False,
+        check_timestamp_sync: bool = True,
+        chunk_streaming_using_keyframe: bool = True,
+        shuffle: bool = True,
+        seed: int = 42,
+    ):
+        """
+        Custom args:
+            episodes (List[int]): list of episodes to use PER TASK.
+                NOTE: This is different from the actual episode indices in the dataset.
+                Rather, this is meant to be used for train/val split, or loading a specific amount of partial data.
+                If set to None, all episodes will be loaded for a given task.
+            tasks (List[str]): list of task names to load. If None, all tasks will be loaded.
+            modalities (List[str]): list of modality names to load. If None, all modalities will be loaded.
+                must be a subset of ["rgb", "depth", "seg_instance_id"]
+            cameras (List[str]): list of camera names to load. If None, all cameras will be loaded.
+                must be a subset of ["left_wrist", "right_wrist", "head"]
+            local_only (bool): whether to only use local data (not download from HuggingFace).
+                NOTE: set this to False and force_cache_sync to True if you want to force re-syncing the local cache with the remote dataset.
+                For more details, please refer to the `force_cache_sync` argument in the base class.
+            check_timestamp_sync (bool): whether to check timestamp synchronization between different modalities and the state/action data.
+                While it is set to True in the original LeRobotDataset and is set to True here by default, it can be set to False to skip the check for faster loading.
+                This will especially save time if you are loading the complete challenge demo dataset.
+            chunk_streaming_using_keyframe (bool): whether to use chunk streaming mode for loading the dataset using keyframes.
+                When this is enabled, the dataset will pseudo-randomly load data in chunks based on keyframes, allowing for faster access to the data.
+                NOTE: As B1K challenge demos has GOP size of 250 frames for efficient storage, it is STRONGLY recommended to set this to True if you don't need true frame-level random access.
+                When this is enabled, it is recommended to set shuffle to True for better randomness in chunk selection.
+                We also enforce that segmentation instance ID videos can only be loaded in chunk_streaming_using_keyframe mode for faster access.
+            shuffle (bool): whether to shuffle the chunks after loading. This ONLY applies in chunk streaming mode. Recommended to be set to True for better randomness in chunk selection.
+            seed (int): random seed for shuffling chunks.
+        """
+        Dataset.__init__(self)
+        self.repo_id = repo_id
+        self.root = Path(os.path.expanduser(str(root))) if root else HF_LEROBOT_HOME / repo_id
+        self.image_transforms = image_transforms
+        self.delta_timestamps = delta_timestamps
+        self.tolerance_s = tolerance_s
+        self.revision = revision if revision else CODEBASE_VERSION
+        self.video_backend = video_backend if video_backend else get_safe_default_codec()
+        self.delta_indices = None
+        self.batch_encoding_size = batch_encoding_size
+        self.episodes_since_last_encoding = 0
+
+        # Unused attributes
+        self.image_writer = None
+        self.episode_buffer = None
+
+        self.root.mkdir(exist_ok=True, parents=True)
+
+        # ========== Customizations ==========
+        self.seed = seed
+        if modalities is None:
+            modalities = ["rgb", "depth", "seg_instance_id"]
+        if "seg_instance_id" in modalities:
+            assert chunk_streaming_using_keyframe, "For the sake of data loading speed, please use chunk_streaming_using_keyframe=True when loading segmentation instance ID videos."
+        if "depth" in modalities:
+            assert self.video_backend == "pyav", (
+                "Depth videos can only be decoded with the 'pyav' backend. "
+                "Please set video_backend='pyav' when initializing the dataset."
+            )
+        if cameras is None:
+            cameras = ["head", "left_wrist", "right_wrist"]
+        self.task_names = set(tasks) if tasks is not None else set(TASK_NAMES_TO_INDICES.keys())
+        self.task_indices = [TASK_NAMES_TO_INDICES[task] for task in self.task_names]
+        # Load metadata
+        self.meta = BehaviorLerobotDatasetMetadata(
+            repo_id=self.repo_id,
+            root=self.root,
+            revision=self.revision,
+            force_cache_sync=force_cache_sync,
+            tasks=self.task_names,
+            modalities=modalities,
+            cameras=cameras,
+        )
+        # overwrite episode based on task
+        all_episodes = load_jsonlines(self.root / EPISODES_PATH)
+        # get the episodes grouped by task
+        epi_by_task = defaultdict(list)
+        for item in all_episodes:
+            if item["episode_index"] // 1e4 in self.meta.tasks:
+                epi_by_task[item["episode_index"] // 1e4].append(item["episode_index"])
+        # sort and cherrypick episodes within each task
+        for task_id, ep_indices in epi_by_task.items():
+            epi_by_task[task_id] = sorted(ep_indices)
+            if episodes is not None:
+                epi_by_task[task_id] = [epi_by_task[task_id][i] for i in episodes if i < len(epi_by_task[task_id])]
+        # now put episodes back together
+        self.episodes = sorted([ep for eps in epi_by_task.values() for ep in eps])
+        # handle streaming mode and shuffling of episodes
+        self._chunk_streaming_using_keyframe = chunk_streaming_using_keyframe
+        if self._chunk_streaming_using_keyframe:
+            if not shuffle:
+                logger.warning(
+                    "chunk_streaming_using_keyframe mode is enabled but shuffle is set to False. This may lead to less randomness in chunk selection."
+                )
+            self.chunks = self._get_keyframe_chunk_indices()
+            # Now, we randomly permute the episodes if shuffle is True
+            if shuffle:
+                self.current_streaming_chunk_idx = None
+                self.current_streaming_frame_idx = None
+            else:
+                self.current_streaming_chunk_idx = 0
+                self.current_streaming_frame_idx = self.chunks[self.current_streaming_chunk_idx][0]
+            self.obs_loaders = dict()
+            self._should_obs_loaders_reload = True
+        # record the positional index of each episode index within self.episodes
+        self.episode_data_index_pos = {ep_idx: i for i, ep_idx in enumerate(self.episodes)}
+        logger.info(f"Total episodes: {len(self.episodes)}")
+        # ====================================
+
+        if self.episodes is not None and self.meta._version >= packaging.version.parse("v2.1"):
+            episodes_stats = [self.meta.episodes_stats[ep_idx] for ep_idx in self.episodes]
+            self.stats = aggregate_stats(episodes_stats)
+
+        # Load actual data
+        try:
+            if force_cache_sync:
+                raise FileNotFoundError
+            for fpath in self.get_episodes_file_paths():
+                assert (self.root / fpath).is_file(), f"Missing file: {self.root / fpath}"
+            self.hf_dataset = self.load_hf_dataset()
+        except (AssertionError, FileNotFoundError, NotADirectoryError) as e:
+            if local_only:
+                raise e
+            self.revision = get_safe_version(self.repo_id, self.revision)
+            self.download_episodes(download_videos)
+            self.hf_dataset = self.load_hf_dataset()
+
+        self.episode_data_index = get_episode_data_index(self.meta.episodes, self.episodes)
+
+        # Check timestamps
+        if check_timestamp_sync:
+            timestamps = th.stack(self.hf_dataset["timestamp"]).numpy()
+            episode_indices = th.stack(self.hf_dataset["episode_index"]).numpy()
+            ep_data_index_np = {k: t.numpy() for k, t in self.episode_data_index.items()}
+            check_timestamps_sync(timestamps, episode_indices, ep_data_index_np, self.fps, self.tolerance_s)
+
+        # Setup delta_indices
+        if self.delta_timestamps is not None:
+            check_delta_timestamps(self.delta_timestamps, self.fps, self.tolerance_s)
+            self.delta_indices = get_delta_indices(self.delta_timestamps, self.fps)
+
+    def get_episodes_file_paths(self) -> list[str]:
+        """
+        Overwrite the original method to use the episodes indices instead of range(self.meta.total_episodes)
+        """
+        episodes = self.episodes if self.episodes is not None else list(self.meta.episodes.keys())
+        fpaths = [str(self.meta.get_data_file_path(ep_idx)) for ep_idx in episodes]
+        # append metainfo and language annotations
+        fpaths += [str(self.meta.get_metainfo_path(ep_idx)) for ep_idx in episodes]
+        # TODO: add this back once we have all the language annotations
+        # fpaths += [str(self.meta.get_annotation_path(ep_idx)) for ep_idx in episodes]
+        if len(self.meta.video_keys) > 0:
+            video_files = [
+                str(self.meta.get_video_file_path(ep_idx, vid_key))
+                for vid_key in self.meta.video_keys
+                for ep_idx in episodes
+            ]
+            fpaths += video_files
+
+        return fpaths
+
+    def download_episodes(self, download_videos: bool = True) -> None:
+        """
+        Overwrite base method to allow more flexible pattern matching.
+        Here, we do coarse filtering based on tasks, cameras, and modalities.
+        We do this instead of filename patterns to speed up pattern checking and download speed.
+        """
+        allow_patterns = []
+        if set(self.task_indices) != set(TASK_NAMES_TO_INDICES.values()):
+            for task in self.task_indices:
+                allow_patterns.append(f"**/task-{task:04d}/**")
+        if len(self.meta.modalities) != 3:
+            for modality in self.meta.modalities:
+                if len(self.meta.camera_names) != 3:
+                    for camera in self.meta.camera_names:
+                        allow_patterns.append(f"**/observation.images.{modality}.{camera}/**")
+                else:
+                    allow_patterns.append(f"**/observation.images.{modality}.*/**")
+        elif len(self.meta.camera_names) != 3:
+            for camera in self.meta.camera_names:
+                allow_patterns.append(f"**/observation.images.*.{camera}/**")
+        ignore_patterns = []
+        if not download_videos:
+            ignore_patterns.append("videos/")
+        if set(self.task_indices) != set(TASK_NAMES_TO_INDICES.values()):
+            for task in set(TASK_NAMES_TO_INDICES.values()).difference(self.task_indices):
+                ignore_patterns.append(f"**/task-{task:04d}/**")
+
+        allow_patterns = None if allow_patterns == [] else allow_patterns
+        ignore_patterns = None if ignore_patterns == [] else ignore_patterns
+        self.pull_from_repo(allow_patterns=allow_patterns, ignore_patterns=ignore_patterns)
+
+    def pull_from_repo(
+        self,
+        allow_patterns: list[str] | str | None = None,
+        ignore_patterns: list[str] | str | None = None,
+    ) -> None:
+        """
+        Overwrite base class to increase max workers to num of CPUs - 2
+        """
+        logger.info(f"Pulling dataset {self.repo_id} from HuggingFace hub...")
+        snapshot_download(
+            self.repo_id,
+            repo_type="dataset",
+            revision=self.revision,
+            local_dir=self.root,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+            max_workers=os.cpu_count() - 2,
+        )
+
+    def load_hf_dataset(self) -> datasets.Dataset:
+        """hf_dataset contains all the observations, states, actions, rewards, etc."""
+        if self.episodes is None:
+            path = str(self.root / "data")
+            hf_dataset = load_dataset("parquet", data_dir=path, split="train")
+        else:
+            files = [str(self.root / self.meta.get_data_file_path(ep_idx)) for ep_idx in self.episodes]
+            hf_dataset = load_dataset("parquet", data_files=files, split="train")
+
+        hf_dataset.set_transform(hf_transform_to_torch)
+        return hf_dataset
+
+    def __getitem__(self, idx) -> dict:
+        if not self._chunk_streaming_using_keyframe:
+            return super().__getitem__(idx)
+        # Streaming mode: we will load the episode at the current streaming index, and then increment the index for next call
+        # Randomize chunk index on first call
+        if self.current_streaming_chunk_idx is None:
+            worker_info = get_worker_info()
+            worker_id = 0 if worker_info is None else worker_info.id
+            rng = np.random.default_rng(self.seed + worker_id)
+            rng.shuffle(self.chunks)
+            self.current_streaming_chunk_idx = rng.integers(0, len(self.chunks)).item()
+            self.current_streaming_frame_idx = self.chunks[self.current_streaming_chunk_idx][0]
+        # Current chunk iterated, move to next chunk
+        if self.current_streaming_frame_idx >= self.chunks[self.current_streaming_chunk_idx][1]:
+            self.current_streaming_chunk_idx += 1
+            # All data iterated, restart from beginning
+            if self.current_streaming_chunk_idx >= len(self.chunks):
+                self.current_streaming_chunk_idx = 0
+            self.current_streaming_frame_idx = self.chunks[self.current_streaming_chunk_idx][0]
+            self._should_obs_loaders_reload = True
+        item = self.hf_dataset[self.current_streaming_frame_idx]
+        ep_idx = item["episode_index"].item()
+
+        if self._should_obs_loaders_reload:
+            for loader in self.obs_loaders.values():
+                loader.close()
+            self.obs_loaders = dict()
+            # reload video loaders for new episode
+            self.current_streaming_episode_idx = ep_idx
+            for vid_key in self.meta.video_keys:
+                kwargs = {}
+                task_id = item["task_index"].item()
+                if "seg_instance_id" in vid_key:
+                    # load id list
+                    with open(
+                        self.root / "meta/episodes" / f"task-{task_id:04d}" / f"episode_{ep_idx:08d}.json",
+                        "r",
+                    ) as f:
+                        kwargs["id_list"] = th.tensor(
+                            json.load(f)[f"{ROBOT_CAMERA_NAMES['R1Pro'][vid_key.split('.')[-1]]}::unique_ins_ids"]
+                        )
+                self.obs_loaders[vid_key] = iter(
+                    OBS_LOADER_MAP[vid_key.split(".")[2]](
+                        data_path=self.root,
+                        task_id=task_id,
+                        camera_id=vid_key.split(".")[-1],
+                        demo_id=f"{ep_idx:08d}",
+                        start_idx=self.chunks[self.current_streaming_chunk_idx][2],
+                        start_idx_is_keyframe=True,
+                        batch_size=1,
+                        stride=1,
+                        **kwargs,
+                    )
+                )
+            self._should_obs_loaders_reload = False
+
+        query_indices = None
+        if self.delta_indices is not None:
+            query_indices, padding = self._get_query_indices(self.current_streaming_frame_idx, ep_idx)
+            query_result = self._query_hf_dataset(query_indices)
+            item = {**item, **padding}
+            for key, val in query_result.items():
+                item[key] = val
+
+        # load visual observations
+        for key in self.meta.video_keys:
+            item[key] = next(self.obs_loaders[key])[0]
+
+        if self.image_transforms is not None:
+            image_keys = self.meta.camera_keys
+            for cam in image_keys:
+                item[cam] = self.image_transforms(item[cam])
+
+        # Add task as a string
+        task_idx = item["task_index"].item()
+        item["task"] = self.meta.tasks[task_idx]
+        self.current_streaming_frame_idx += 1
+
+        return item
+
+    def _get_query_indices(self, idx: int, ep_idx: int) -> tuple[dict[str, list[int | bool]]]:
+        ep_idx = self.episode_data_index_pos[ep_idx]
+        ep_start = self.episode_data_index["from"][ep_idx]
+        ep_end = self.episode_data_index["to"][ep_idx]
+        query_indices = {
+            key: [max(ep_start.item(), min(ep_end.item() - 1, idx + delta)) for delta in delta_idx]
+            for key, delta_idx in self.delta_indices.items()
+        }
+        padding = {  # Pad values outside of current episode range
+            f"{key}_is_pad": th.BoolTensor(
+                [(idx + delta < ep_start.item()) | (idx + delta >= ep_end.item()) for delta in delta_idx]
+            )
+            for key, delta_idx in self.delta_indices.items()
+        }
+        return query_indices, padding
+
+    def _query_videos(self, query_timestamps: dict[str, list[float]], ep_idx: int) -> dict[str, th.Tensor]:
+        """Note: When using data workers (e.g. DataLoader with num_workers>0), do not call this function
+        in the main process (e.g. by using a second Dataloader with num_workers=0). It will result in a
+        Segmentation Fault. This probably happens because a memory reference to the video loader is created in
+        the main process and a subprocess fails to access it.
+        """
+        item = {}
+        for vid_key, query_ts in query_timestamps.items():
+            video_path = self.root / self.meta.get_video_file_path(ep_idx, vid_key)
+            frames = decode_video_frames(video_path, query_ts, self.tolerance_s, self.video_backend)
+            item[vid_key] = frames.squeeze(0)
+
+        return item
+
+    def _get_keyframe_chunk_indices(self, chunk_size=250) -> List[Tuple[int, int, int]]:
+        """
+        Divide each episode into chunks of data based on GOP of the data (here for B1K, GOP size is 250 frames).
+        Args:
+            chunk_size (int): size of each chunk in number of frames. Default is 250 for B1K. Should be the GOP size of the video data.
+        Returns:
+            List of tuples, where each tuple contains (start_index, end_index, local_start_index) for each chunk.
+        """
+        episode_lengths = {ep_idx: ep_dict["length"] for ep_idx, ep_dict in self.meta.episodes.items()}
+        episode_lengths = [episode_lengths[ep_idx] for ep_idx in self.episodes]
+        chunks = []
+        offset = 0
+        for L in episode_lengths:
+            local_starts = list(range(0, L, chunk_size))
+            local_ends = local_starts[1:] + [L]
+            for ls, le in zip(local_starts, local_ends):
+                chunks.append((offset + ls, offset + le, ls))
+            offset += L
+        return chunks
+
+
+class BehaviorLerobotDatasetMetadata(LeRobotDatasetMetadata):
+    """
+    BehaviorLerobotDatasetMetadata extends LeRobotDatasetMetadata with the following customizations:
+        1. Restricts the set of allowed modalities to {"rgb", "depth", "seg_instance_id"}.
+        2. Restricts the set of allowed camera names to those defined in ROBOT_CAMERA_NAMES["R1Pro"].
+        3. Provides a filtered view of dataset features, including only those corresponding to the selected modalities and camera names.
+    """
+
+    def __init__(
+        self,
+        repo_id: str,
+        root: str | Path | None = None,
+        revision: str | None = None,
+        force_cache_sync: bool = False,
+        # === Customized arguments for BehaviorLeRobotDataset ===
+        tasks: Iterable[str] = None,
+        modalities: Iterable[str] = None,
+        cameras: Iterable[str] = None,
+    ):
+        # ========== Customizations ==========
+        self.task_name_candidates = set(tasks) if tasks is not None else set(TASK_NAMES_TO_INDICES.keys())
+        self.modalities = set(modalities)
+        self.camera_names = set(cameras)
+        assert self.modalities.issubset(
+            {"rgb", "depth", "seg_instance_id"}
+        ), f"Modalities must be a subset of ['rgb', 'depth', 'seg_instance_id'], but got {self.modalities}"
+        assert self.camera_names.issubset(
+            ROBOT_CAMERA_NAMES["R1Pro"]
+        ), f"Camera names must be a subset of {ROBOT_CAMERA_NAMES['R1Pro']}, but got {self.camera_names}"
+        # ===================================
+
+        self.repo_id = repo_id
+        self.revision = revision if revision else CODEBASE_VERSION
+        self.root = Path(root) if root is not None else HF_LEROBOT_HOME / repo_id
+
+        try:
+            if force_cache_sync:
+                raise FileNotFoundError
+            self.load_metadata()
+        except (FileNotFoundError, NotADirectoryError):
+            if is_valid_version(self.revision):
+                self.revision = get_safe_version(self.repo_id, self.revision)
+
+            (self.root / "meta").mkdir(exist_ok=True, parents=True)
+            self.pull_from_repo(allow_patterns="meta/**", ignore_patterns="meta/episodes/**")
+            self.load_metadata()
+
+    def load_metadata(self):
+        self.info = load_info(self.root)
+        check_version_compatibility(self.repo_id, self._version, CODEBASE_VERSION)
+        self.tasks, self.task_to_task_index, self.task_names = self.load_tasks(self.root)
+        # filter based on self.task_name_candidates
+        valid_task_indices = [idx for idx, name in self.task_names.items() if name in self.task_name_candidates]
+        self.task_names = set([self.task_names[idx] for idx in valid_task_indices])
+        self.tasks = {idx: self.tasks[idx] for idx in valid_task_indices}
+        self.task_to_task_index = {v: k for k, v in self.tasks.items()}
+
+        self.episodes = self.load_episodes(self.root)
+        if self._version < packaging.version.parse("v2.1"):
+            self.stats = self.load_stats(self.root)
+            self.episodes_stats = backward_compatible_episodes_stats(self.stats, self.episodes)
+        else:
+            self.episodes_stats = self.load_episodes_stats(self.root)
+            self.stats = aggregate_stats(list(self.episodes_stats.values()))
+        logger.info(f"Loaded metadata for {len(self.episodes)} episodes.")
+
+    def load_tasks(self, local_dir: Path) -> tuple[dict, dict]:
+        tasks = load_jsonlines(local_dir / TASKS_PATH)
+        task_names = {item["task_index"]: item["task_name"] for item in sorted(tasks, key=lambda x: x["task_index"])}
+        tasks = {item["task_index"]: item["task"] for item in sorted(tasks, key=lambda x: x["task_index"])}
+        task_to_task_index = {task: task_index for task_index, task in tasks.items()}
+        return tasks, task_to_task_index, task_names
+
+    def load_episodes(self, local_dir: Path) -> dict:
+        episodes = load_jsonlines(local_dir / EPISODES_PATH)
+        return {
+            item["episode_index"]: item
+            for item in sorted(episodes, key=lambda x: x["episode_index"])
+            if item["episode_index"] // 1e4 in self.tasks
+        }
+
+    def load_stats(self, local_dir: Path) -> dict[str, dict[str, np.ndarray]]:
+        if not (local_dir / STATS_PATH).exists():
+            return None
+        stats = load_json(local_dir / STATS_PATH)
+        return cast_stats_to_numpy(stats)
+
+    def load_episodes_stats(self, local_dir: Path) -> dict:
+        episodes_stats = load_jsonlines(local_dir / EPISODES_STATS_PATH)
+        return {
+            item["episode_index"]: cast_stats_to_numpy(item["stats"])
+            for item in sorted(episodes_stats, key=lambda x: x["episode_index"])
+            if item["episode_index"] in self.episodes
+        }
+
+    def get_annotation_path(self, ep_index: int) -> Path:
+        ep_chunk = self.get_episode_chunk(ep_index)
+        fpath = self.annotation_path.format(episode_chunk=ep_chunk, episode_index=ep_index)
+        return Path(fpath)
+
+    def get_metainfo_path(self, ep_index: int) -> Path:
+        ep_chunk = self.get_episode_chunk(ep_index)
+        fpath = self.metainfo_path.format(episode_chunk=ep_chunk, episode_index=ep_index)
+        return Path(fpath)
+
+    @property
+    def annotation_path(self) -> str | None:
+        """Formattable string for the annotation files."""
+        return self.info["annotation_path"]
+
+    @property
+    def metainfo_path(self) -> str | None:
+        """Formattable string for the metainfo files."""
+        return self.info["metainfo_path"]
+
+    @property
+    def features(self) -> dict[str, dict]:
+        """All features contained in the dataset."""
+        features = dict()
+        # pop not required features
+        for name in self.info["features"].keys():
+            if (
+                name.startswith("observation.images.")
+                and name.split(".")[-1] in self.camera_names
+                and name.split(".")[-2] in self.modalities
+            ):
+                features[name] = self.info["features"][name]
+        return features

OmniGibson/omnigibson/learning/eval.py

@@ -0,0 +1,490 @@
+import csv
+import cv2
+import hydra
+import json
+import logging
+import numpy as np
+import omnigibson as og
+import omnigibson.utils.transform_utils as T
+import os
+import sys
+import torch as th
+import traceback
+from av.container import Container
+from av.stream import Stream
+from gello.robots.sim_robot.og_teleop_utils import (
+    augment_rooms,
+    load_available_tasks,
+    generate_robot_config,
+    get_task_relevant_room_types,
+)
+from gello.robots.sim_robot.og_teleop_cfg import DISABLED_TRANSITION_RULES
+from hydra.utils import instantiate
+from inspect import getsourcefile
+from omegaconf import DictConfig, OmegaConf
+from omnigibson.envs.env_wrapper import EnvironmentWrapper
+from omnigibson.learning.utils.config_utils import register_omegaconf_resolvers
+from omnigibson.learning.utils.eval_utils import (
+    ROBOT_CAMERA_NAMES,
+    PROPRIOCEPTION_INDICES,
+    generate_basic_environment_config,
+    flatten_obs_dict,
+    TASK_NAMES_TO_INDICES,
+)
+from omnigibson.learning.utils.obs_utils import (
+    create_video_writer,
+    write_video,
+)
+from omnigibson.macros import gm, create_module_macros
+from omnigibson.metrics import MetricBase, AgentMetric, TaskMetric
+from omnigibson.robots import BaseRobot
+from omnigibson.utils.asset_utils import get_task_instance_path
+from omnigibson.utils.python_utils import recursively_convert_to_torch
+from pathlib import Path
+from signal import signal, SIGINT
+from typing import Any, Tuple, List
+
+m = create_module_macros(module_path=__file__)
+m.NUM_EVAL_EPISODES = 1
+m.NUM_TRAIN_INSTANCES = 200
+m.NUM_EVAL_INSTANCES = 10
+
+
+# set global variables to boost performance
+gm.ENABLE_FLATCACHE = True
+gm.USE_GPU_DYNAMICS = False
+gm.ENABLE_TRANSITION_RULES = True
+
+# create module logger
+logger = logging.getLogger("evaluator")
+logger.setLevel(20)  # info
+
+
+class Evaluator:
+    """
+    Evaluator class for running and evaluating policies for behavior task.
+    This class manages the setup, execution, and evaluation of policy rollouts in OmniGibson environment,
+    tracking metrics such as the number of trials, successes, and total time. It supports loading environments,
+    robots, policies, and metrics, and provides methods for stepping through the environment, resetting state,
+    and handling video outputs and loggings.
+    """
+
+    def __init__(self, cfg: DictConfig) -> None:
+        self.cfg = cfg
+
+        # record total number and success number of trials and trial time
+        self.n_trials = 0
+        self.n_success_trials = 0
+        self.total_time = 0
+        self.robot_action = dict()
+
+        self.env = self.load_env(env_wrapper=self.cfg.env_wrapper)
+        self.policy = self.load_policy()
+        self.robot = self.load_robot()
+        self.metrics = self.load_metrics()
+
+        self.reset()
+        # manually reset environment episode number
+        self.env._current_episode = 0
+        self._video_writer = None
+
+    def load_env(self, env_wrapper: DictConfig) -> EnvironmentWrapper:
+        """
+        Read the environment config file and create the environment.
+        The config file is located in the configs/envs directory.
+        """
+        # Disable a subset of transition rules for data collection
+        for rule in DISABLED_TRANSITION_RULES:
+            rule.ENABLED = False
+        # Load config file
+        available_tasks = load_available_tasks()
+        task_name = self.cfg.task.name
+        assert task_name in available_tasks, f"Got invalid task name: {task_name}"
+        # Now, get human stats of the task
+        task_idx = TASK_NAMES_TO_INDICES[task_name]
+        self.human_stats = {
+            "length": [],
+            "distance_traveled": [],
+            "left_eef_displacement": [],
+            "right_eef_displacement": [],
+        }
+        with open(os.path.join(gm.DATA_PATH, "2025-challenge-task-instances", "metadata", "episodes.jsonl"), "r") as f:
+            episodes = [json.loads(line) for line in f]
+        for episode in episodes:
+            if episode["episode_index"] // 1e4 == task_idx:
+                for k in self.human_stats.keys():
+                    self.human_stats[k].append(episode[k])
+        # take a mean
+        for k in self.human_stats.keys():
+            self.human_stats[k] = sum(self.human_stats[k]) / len(self.human_stats[k])
+
+        # Load the seed instance by default
+        task_cfg = available_tasks[task_name][0]
+        robot_type = self.cfg.robot.type
+        assert robot_type == "R1Pro", f"Got invalid robot type: {robot_type}, only R1Pro is supported."
+        cfg = generate_basic_environment_config(task_name=task_name, task_cfg=task_cfg)
+        if self.cfg.partial_scene_load:
+            relevant_rooms = get_task_relevant_room_types(activity_name=task_name)
+            relevant_rooms = augment_rooms(relevant_rooms, task_cfg["scene_model"], task_name)
+            cfg["scene"]["load_room_types"] = relevant_rooms
+
+        cfg["robots"] = [
+            generate_robot_config(
+                task_name=task_name,
+                task_cfg=task_cfg,
+            )
+        ]
+        # Update observation modalities
+        cfg["robots"][0]["obs_modalities"] = ["proprio", "rgb"]
+        cfg["robots"][0]["proprio_obs"] = list(PROPRIOCEPTION_INDICES["R1Pro"].keys())
+        if self.cfg.robot.controllers is not None:
+            cfg["robots"][0]["controller_config"].update(self.cfg.robot.controllers)
+        if self.cfg.max_steps is None:
+            logger.info(
+                f"Setting timeout to be 2x the average length of human demos: {int(self.human_stats['length'] * 2)}"
+            )
+            cfg["task"]["termination_config"]["max_steps"] = int(self.human_stats["length"] * 2)
+        else:
+            logger.info(f"Setting timeout to be {self.cfg.max_steps} steps through config.")
+            cfg["task"]["termination_config"]["max_steps"] = self.cfg.max_steps
+        cfg["task"]["include_obs"] = False
+        env = og.Environment(configs=cfg)
+        # instantiate env wrapper
+        env = instantiate(env_wrapper, env=env)
+        return env
+
+    def load_robot(self) -> BaseRobot:
+        """
+        Loads and returns the robot instance from the environment.
+        Returns:
+            BaseRobot: The robot instance loaded from the environment.
+        """
+        robot = self.env.scene.object_registry("name", "robot_r1")
+        return robot
+
+    def load_policy(self) -> Any:
+        """
+        Loads and returns the policy instance.
+        """
+        policy = instantiate(self.cfg.model)
+        logger.info("")
+        logger.info("=" * 50)
+        logger.info(f"Loaded policy: {self.cfg.policy_name}")
+        logger.info("=" * 50)
+        logger.info("")
+        return policy
+
+    def load_metrics(self) -> List[MetricBase]:
+        """
+        Load agent and task metrics.
+        """
+        return [AgentMetric(self.human_stats), TaskMetric(self.human_stats)]
+
+    def step(self) -> Tuple[bool, bool]:
+        """
+        Performs a single step of the task by executing the policy, interacting with the environment,
+        processing observations, updating metrics, and tracking trial success.
+
+        Returns:
+            Tuple[bool, bool]:
+                - terminated (bool): Whether the episode has terminated (i.e., reached a terminal state).
+                - truncated (bool): Whether the episode was truncated (i.e., stopped due to a time limit or other constraint).
+
+        Workflow:
+            1. Computes the next action using the policy based on the current observation.
+            2. Steps the environment with the computed action and retrieves the next observation,
+               termination and truncation flags, and additional info.
+            3. If the episode has ended (terminated or truncated), increments the trial counter and
+               updates the count of successful trials if the task was completed successfully.
+            4. Preprocesses the new observation.
+            5. Invokes step callbacks for all registered metrics to update their state.
+            6. Returns the termination and truncation status.
+        """
+        self.robot_action = self.policy.forward(obs=self.obs)
+
+        obs, _, terminated, truncated, info = self.env.step(self.robot_action, n_render_iterations=1)
+        # process obs
+        self.obs = self._preprocess_obs(obs)
+
+        if terminated or truncated:
+            self.n_trials += 1
+            if info["done"]["success"]:
+                self.n_success_trials += 1
+
+        for metric in self.metrics:
+            metric.step_callback(self.env)
+        return terminated, truncated
+
+    @property
+    def video_writer(self) -> Tuple[Container, Stream]:
+        """
+        Returns the video writer for the current evaluation step.
+        """
+        return self._video_writer
+
+    @video_writer.setter
+    def video_writer(self, video_writer: Tuple[Container, Stream]) -> None:
+        if self._video_writer is not None:
+            (container, stream) = self._video_writer
+            # Flush any remaining packets
+            for packet in stream.encode():
+                container.mux(packet)
+            # Close the container
+            container.close()
+        self._video_writer = video_writer
+
+    def load_task_instance(self, instance_id: int, test_hidden: bool = False) -> None:
+        """
+        Loads the configuration for a specific task instance.
+
+        Args:
+            instance_id (int): The ID of the task instance to load.
+            test_hidden (bool): [Interal use only] Whether to load the hidden test instance.
+        """
+        scene_model = self.env.task.scene_name
+        tro_filename = self.env.task.get_cached_activity_scene_filename(
+            scene_model=scene_model,
+            activity_name=self.env.task.activity_name,
+            activity_definition_id=self.env.task.activity_definition_id,
+            activity_instance_id=instance_id,
+        )
+        if test_hidden:
+            tro_file_path = os.path.join(
+                gm.DATA_PATH,
+                "2025-challenge-test-instances",
+                self.env.task.activity_name,
+                f"{tro_filename}-tro_state.json",
+            )
+        else:
+            tro_file_path = os.path.join(
+                get_task_instance_path(scene_model),
+                f"json/{scene_model}_task_{self.env.task.activity_name}_instances/{tro_filename}-tro_state.json",
+            )
+        with open(tro_file_path, "r") as f:
+            tro_state = recursively_convert_to_torch(json.load(f))
+        for tro_key, tro_state in tro_state.items():
+            if tro_key == "robot_poses":
+                presampled_robot_poses = tro_state
+                robot_pos = presampled_robot_poses[self.robot.model_name][0]["position"]
+                robot_quat = presampled_robot_poses[self.robot.model_name][0]["orientation"]
+                self.robot.set_position_orientation(robot_pos, robot_quat)
+                # Write robot poses to scene metadata
+                self.env.scene.write_task_metadata(key=tro_key, data=tro_state)
+            else:
+                self.env.task.object_scope[tro_key].load_state(tro_state, serialized=False)
+
+        # Try to ensure that all task-relevant objects are stable
+        # They should already be stable from the sampled instance, but there is some issue where loading the state
+        # causes some jitter (maybe for small mass / thin objects?)
+        for _ in range(25):
+            og.sim.step_physics()
+            for entity in self.env.task.object_scope.values():
+                if not entity.is_system and entity.exists:
+                    entity.keep_still()
+
+        self.env.scene.update_initial_file()
+        self.env.scene.reset()
+
+    def _preprocess_obs(self, obs: dict) -> dict:
+        """
+        Preprocess the observation dictionary before passing it to the policy.
+        Args:
+            obs (dict): The observation dictionary to preprocess.
+
+        Returns:
+            dict: The preprocessed observation dictionary.
+        """
+        obs = flatten_obs_dict(obs)
+        base_pose = self.robot.get_position_orientation()
+        cam_rel_poses = []
+        # The first time we query for camera parameters, it will return all zeros
+        # For this case, we use camera.get_position_orientation() instead.
+        # The reason we are not using camera.get_position_orientation() by defualt is because it will always return the most recent camera poses
+        # However, since og render is somewhat "async", it takes >= 3 render calls per step to actually get the up-to-date camera renderings
+        # Since we are using n_render_iterations=1 for speed concern, we need the correct corresponding camera poses instead of the most update-to-date one.
+        # Thus, we use camera parameters which are guaranteed to be in sync with the visual observations.
+        for camera_name in ROBOT_CAMERA_NAMES["R1Pro"].values():
+            camera = self.robot.sensors[camera_name.split("::")[1]]
+            direct_cam_pose = camera.camera_parameters["cameraViewTransform"]
+            if np.allclose(direct_cam_pose, np.zeros(16)):
+                cam_rel_poses.append(
+                    th.cat(T.relative_pose_transform(*(camera.get_position_orientation()), *base_pose))
+                )
+            else:
+                cam_pose = T.mat2pose(th.tensor(np.linalg.inv(np.reshape(direct_cam_pose, [4, 4]).T), dtype=th.float32))
+                cam_rel_poses.append(th.cat(T.relative_pose_transform(*cam_pose, *base_pose)))
+        obs["robot_r1::cam_rel_poses"] = th.cat(cam_rel_poses, axis=-1)
+        # append task id to obs
+        obs["task_id"] = th.tensor([TASK_NAMES_TO_INDICES[self.cfg.task.name]], dtype=th.int64)
+        return obs
+
+    def _write_video(self) -> None:
+        """
+        Write the current robot observations to video.
+        """
+        # concatenate obs
+        left_wrist_rgb = cv2.resize(
+            self.obs[ROBOT_CAMERA_NAMES["R1Pro"]["left_wrist"] + "::rgb"].numpy(),
+            (224, 224),
+        )
+        right_wrist_rgb = cv2.resize(
+            self.obs[ROBOT_CAMERA_NAMES["R1Pro"]["right_wrist"] + "::rgb"].numpy(),
+            (224, 224),
+        )
+        head_rgb = cv2.resize(
+            self.obs[ROBOT_CAMERA_NAMES["R1Pro"]["head"] + "::rgb"].numpy(),
+            (448, 448),
+        )
+        write_video(
+            np.expand_dims(np.hstack([np.vstack([left_wrist_rgb, right_wrist_rgb]), head_rgb]), 0),
+            video_writer=self.video_writer,
+            batch_size=1,
+            mode="rgb",
+        )
+
+    def reset(self) -> None:
+        """
+        Reset the environment, policy, and compute metrics.
+        """
+        self.obs = self._preprocess_obs(self.env.reset()[0])
+        # run metric start callbacks
+        for metric in self.metrics:
+            metric.start_callback(self.env)
+        self.policy.reset()
+        self.n_success_trials, self.n_trials = 0, 0
+
+    def __enter__(self):
+        signal(SIGINT, self._sigint_handler)
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        # print stats
+        logger.info("")
+        logger.info("=" * 50)
+        logger.info(f"Total success trials: {self.n_success_trials}")
+        logger.info(f"Total trials: {self.n_trials}")
+        if self.n_trials > 0:
+            logger.info(f"Success rate: {self.n_success_trials / self.n_trials}")
+        logger.info("=" * 50)
+        logger.info("")
+        if exc_type is not None:
+            traceback.print_exception(exc_type, exc_value, exc_tb)
+        self.video_writer = None
+        self.env.close()
+        og.shutdown()
+
+    def _sigint_handler(self, signal_received, frame):
+        logger.warning("SIGINT or CTRL-C detected.\n")
+        self.__exit__(None, None, None)
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    register_omegaconf_resolvers()
+    # open yaml from task path
+    with hydra.initialize_config_dir(f"{Path(getsourcefile(lambda:0)).parents[0]}/configs", version_base="1.1"):
+        config = hydra.compose("base_config.yaml", overrides=sys.argv[1:])
+    OmegaConf.resolve(config)
+    # set headless mode
+    gm.HEADLESS = config.headless
+    # set video path
+    if config.write_video:
+        video_path = Path(config.log_path).expanduser() / "videos"
+        video_path.mkdir(parents=True, exist_ok=True)
+    assert not (
+        config.eval_on_train_instances and config.test_hidden
+    ), "Cannot eval on train instances and test hidden instances simultaneously."
+    if config.test_hidden:
+        logger.info("You are evaluating on hidden test instances! This is for internal use only.")
+    # get run instances
+    if config.eval_on_train_instances:
+        logger.info(
+            "You are evaluating on training instances, set eval_on_train_instances to False for test instances."
+        )
+        task_idx = TASK_NAMES_TO_INDICES[config.task.name]
+        with open(os.path.join(gm.DATA_PATH, "2025-challenge-task-instances", "metadata", "episodes.jsonl"), "r") as f:
+            episodes = [json.loads(line) for line in f]
+        instances_to_run = []
+        for episode in episodes:
+            if episode["episode_index"] // 1e4 == task_idx:
+                instances_to_run.append(str(int((episode["episode_index"] // 10) % 1e3)))
+        if config.eval_instance_ids:
+            assert set(config.eval_instance_ids).issubset(
+                set(range(m.NUM_TRAIN_INSTANCES))
+            ), f"eval instance ids must be in range({m.NUM_TRAIN_INSTANCES})"
+            instances_to_run = [instances_to_run[i] for i in config.eval_instance_ids]
+    elif config.test_hidden:
+        instances_to_run = (
+            config.eval_instance_ids if config.eval_instance_ids is not None else set(range(m.NUM_EVAL_INSTANCES))
+        )
+        assert set(instances_to_run).issubset(
+            set(range(m.NUM_EVAL_INSTANCES))
+        ), f"eval instance ids must be in range({m.NUM_EVAL_INSTANCES})"
+    else:
+        instances_to_run = (
+            config.eval_instance_ids if config.eval_instance_ids is not None else set(range(m.NUM_EVAL_INSTANCES))
+        )
+        assert set(instances_to_run).issubset(
+            set(range(m.NUM_EVAL_INSTANCES))
+        ), f"eval instance ids must be in range({m.NUM_EVAL_INSTANCES})"
+        # load csv file
+        task_instance_csv_path = os.path.join(
+            gm.DATA_PATH, "2025-challenge-task-instances", "metadata", "test_instances.csv"
+        )
+        with open(task_instance_csv_path, "r") as f:
+            lines = list(csv.reader(f))[1:]
+        assert (
+            lines[TASK_NAMES_TO_INDICES[config.task.name]][1] == config.task.name
+        ), f"Task name from config {config.task.name} does not match task name from csv {lines[TASK_NAMES_TO_INDICES[config.task.name]][1]}"
+        test_instances = lines[TASK_NAMES_TO_INDICES[config.task.name]][2].strip().split(",")
+        instances_to_run = [int(test_instances[i]) for i in instances_to_run]
+    # establish metrics
+    metrics = {}
+    metrics_path = Path(config.log_path).expanduser() / "metrics"
+    metrics_path.mkdir(parents=True, exist_ok=True)
+
+    with Evaluator(config) as evaluator:
+        logger.info("Starting evaluation...")
+
+        for idx in instances_to_run:
+            evaluator.reset()
+            evaluator.load_task_instance(idx, test_hidden=config.test_hidden)
+            logger.info(f"Starting task instance {idx} for evaluation...")
+            for epi in range(m.NUM_EVAL_EPISODES):
+                evaluator.reset()
+                done = False
+                if config.write_video:
+                    video_name = str(video_path) + f"/{config.task.name}_{idx}_{epi}.mp4"
+                    evaluator.video_writer = create_video_writer(
+                        fpath=video_name,
+                        resolution=(448, 672),
+                    )
+                # run metric start callbacks
+                for metric in evaluator.metrics:
+                    metric.start_callback(evaluator.env)
+                while not done:
+                    terminated, truncated = evaluator.step()
+                    if terminated or truncated:
+                        done = True
+                    if config.write_video:
+                        evaluator._write_video()
+                    if evaluator.env._current_step % 1000 == 0:
+                        logger.info(f"Current step: {evaluator.env._current_step}")
+                # run metric end callbacks
+                for metric in evaluator.metrics:
+                    metric.end_callback(evaluator.env)
+                logger.info(f"Evaluation finished at step {evaluator.env._current_step}.")
+                logger.info(f"Evaluation exit state: {terminated}, {truncated}")
+                logger.info(f"Total trials: {evaluator.n_trials}")
+                logger.info(f"Total success trials: {evaluator.n_success_trials}")
+                # gather metric results and write to file
+                for metric in evaluator.metrics:
+                    metrics.update(metric.gather_results())
+                with open(metrics_path / f"{config.task.name}_{idx}_{epi}.json", "w") as f:
+                    json.dump(metrics, f)
+                # reset video writer
+                if config.write_video:
+                    evaluator.video_writer = None
+                    logger.info(f"Saved video to {video_name}")
+                else:
+                    logger.warning("No observations were recorded.")

OmniGibson/omnigibson/learning/policies.py

@@ -0,0 +1,63 @@
+import logging
+import torch as th
+from omnigibson.learning.utils.array_tensor_utils import torch_to_numpy
+from omnigibson.learning.utils.network_utils import WebsocketClientPolicy
+from typing import Optional
+
+
+__all__ = [
+    "LocalPolicy",
+    "WebsocketPolicy",
+]
+
+
+class LocalPolicy:
+    """
+    Local policy that directly queries action from policy,
+        outputs zero delta action if policy is None.
+    """
+
+    def __init__(self, *args, action_dim: Optional[int] = None, **kwargs) -> None:
+        self.policy = None  # To be set later
+        self.action_dim = action_dim
+
+    def act(self, obs: dict) -> th.Tensor:
+        return self.forward(obs)
+
+    def forward(self, obs: dict, *args, **kwargs) -> th.Tensor:
+        """
+        Directly return a zero action tensor of the specified action dimension.
+        """
+        if self.policy is not None:
+            return self.policy.act(obs).detach().cpu()
+        else:
+            assert self.action_dim is not None
+            return th.zeros(self.action_dim, dtype=th.float32)
+
+    def reset(self) -> None:
+        if self.policy is not None:
+            self.policy.reset()
+
+
+class WebsocketPolicy:
+    """
+    Websocket policy for controlling the robot over a websocket connection.
+    """
+
+    def __init__(
+        self,
+        *args,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        **kwargs,
+    ) -> None:
+        logging.info(f"Creating websocket client policy with host: {host}, port: {port}")
+        self.policy = WebsocketClientPolicy(host=host, port=port)
+
+    def forward(self, obs: dict, *args, **kwargs) -> th.Tensor:
+        # convert observation to numpy
+        obs = torch_to_numpy(obs)
+        return self.policy.act(obs).detach().cpu()
+
+    def reset(self) -> None:
+        self.policy.reset()

OmniGibson/omnigibson/learning/utils/config_utils.py

@@ -0,0 +1,110 @@
+import functools
+import warnings
+from copy import deepcopy
+from omegaconf import OmegaConf
+from typing import Literal
+
+
+_NO_INSTANTIATE = "__no_instantiate__"  # return config as-is
+
+
+def meta_decorator(decor):
+    """
+    a decorator decorator, allowing the wrapped decorator to be used as:
+    @decorator(*args, **kwargs)
+    def callable()
+      -- or --
+    @decorator  # without parenthesis, args and kwargs will use default
+    def callable()
+
+    Args:
+      decor: a decorator whose first argument is a callable (function or class
+        to be decorated), and the rest of the arguments can be omitted as default.
+        decor(f, ... the other arguments must have default values)
+
+    Warning:
+      decor can NOT be a function that receives a single, callable argument.
+      See stackoverflow: http://goo.gl/UEYbDB
+    """
+    single_callable = lambda args, kwargs: len(args) == 1 and len(kwargs) == 0 and callable(args[0])
+
+    @functools.wraps(decor)
+    def new_decor(*args, **kwargs):
+        if single_callable(args, kwargs):
+            # this is the double-decorated f.
+            # It should not run on a single callable.
+            return decor(args[0])
+        else:
+            # decorator arguments
+            return lambda real_f: decor(real_f, *args, **kwargs)
+
+    return new_decor
+
+
+@meta_decorator
+def call_once(func, on_second_call: Literal["noop", "raise", "warn"] = "noop"):
+    """
+    Decorator to ensure that a function is only called once.
+
+    Args:
+      on_second_call (str): what happens when the function is called a second time.
+    """
+    assert on_second_call in [
+        "noop",
+        "raise",
+        "warn",
+    ], "mode must be one of 'noop', 'raise', 'warn'"
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        if wrapper._called:
+            if on_second_call == "raise":
+                raise RuntimeError(f"{func.__name__} has already been called. Can only call once.")
+            elif on_second_call == "warn":
+                warnings.warn(f"{func.__name__} has already been called. Should only call once.")
+        else:
+            wrapper._called = True
+            return func(*args, **kwargs)
+
+    wrapper._called = False
+    return wrapper
+
+
+@call_once(on_second_call="noop")
+def register_omegaconf_resolvers():
+    import numpy as np
+
+    OmegaConf.register_new_resolver("_optional", lambda v: f"_{v}" if v else "")
+    OmegaConf.register_new_resolver("optional_", lambda v: f"{v}_" if v else "")
+    OmegaConf.register_new_resolver("_optional_", lambda v: f"_{v}_" if v else "")
+    OmegaConf.register_new_resolver("__optional", lambda v: f"__{v}" if v else "")
+    OmegaConf.register_new_resolver("optional__", lambda v: f"{v}__" if v else "")
+    OmegaConf.register_new_resolver("__optional__", lambda v: f"__{v}__" if v else "")
+    OmegaConf.register_new_resolver("iftrue", lambda cond, v_default: cond if cond else v_default)
+    OmegaConf.register_new_resolver("ifelse", lambda cond, v1, v2="": v1 if cond else v2)
+    OmegaConf.register_new_resolver("ifequal", lambda query, key, v1, v2: v1 if query == key else v2)
+    OmegaConf.register_new_resolver("intbool", lambda cond: 1 if cond else 0)
+    OmegaConf.register_new_resolver("mult", lambda *x: np.prod(x).tolist())
+    OmegaConf.register_new_resolver("add", lambda *x: sum(x))
+    OmegaConf.register_new_resolver("div", lambda x, y: x / y)
+    OmegaConf.register_new_resolver("intdiv", lambda x, y: x // y)
+
+    # try each key until the key exists. Useful for multiple classes that have different
+    # names for the same key
+    def _try_key(cfg, *keys):
+        for k in keys:
+            if k in cfg:
+                return cfg[k]
+        raise KeyError(f"no key in {keys} is valid")
+
+    OmegaConf.register_new_resolver("trykey", _try_key)
+    # replace `resnet.gn.ws` -> `resnet_gn_ws`, because omegaconf doesn't support
+    # keys with dots. Useful for generating run name with dots
+    OmegaConf.register_new_resolver("underscore_to_dots", lambda s: s.replace("_", "."))
+
+    def _no_instantiate(cfg):
+        cfg = deepcopy(cfg)
+        cfg[_NO_INSTANTIATE] = True
+        return cfg
+
+    OmegaConf.register_new_resolver("no_instantiate", _no_instantiate)

OmniGibson/omnigibson/learning/utils/dataset_utils.py

@@ -0,0 +1,791 @@
+import getpass
+import json
+import numpy as np
+import os
+import omnigibson as og
+import pandas as pd
+import random
+import re
+import requests
+import shutil
+import tarfile
+import time
+import zipfile
+from collections import Counter
+from datetime import datetime
+from typing import Any, Tuple, List, Optional
+from tqdm import tqdm
+from google.oauth2.service_account import Credentials
+from omnigibson.learning.utils.eval_utils import TASK_NAMES_TO_INDICES
+from urllib.parse import urlparse
+
+VALID_USER_NAME = ["wsai", "yinhang", "svl", "wsai-yfj", "wpai", "qinengw", "jdw"]
+
+
+def makedirs_with_mode(path, mode=0o2775) -> None:
+    """
+    Recursively create directories with specified mode applied to all newly created dirs.
+    Args:
+        path (str): The directory path to create.
+        mode (int): The mode to apply to newly created directories.
+    """
+    # Normalize path
+    path = os.path.abspath(path)
+    parts = path.split(os.sep)
+    if parts[0] == "":
+        parts[0] = os.sep  # for absolute paths on Unix
+
+    current_path = parts[0]
+    for part in parts[1:]:
+        current_path = os.path.join(current_path, part)
+        if not os.path.exists(current_path):
+            try:
+                os.makedirs(current_path, exist_ok=True)
+                # Apply mode explicitly because os.mkdir may be affected by umask
+                os.chmod(current_path, mode)
+            except Exception as e:
+                print(f"Failed to create directory {current_path}: {e}")
+        else:
+            pass
+
+
+def get_credentials(credentials_path: str = "~/Documents/credentials") -> Tuple[Any, dict, str]:
+    """
+    [Internal use only] Get Google Sheets and Lightwheel API credentials.
+    Args:
+        credentials_path (str): Path to the credentials directory.
+    Returns:
+        Tuple[gspread.Client, dict, str]: Google Sheets client and Lightwheel API credentials and token.
+    """
+    import gspread
+
+    credentials_path = os.path.expanduser(credentials_path)
+    # authorize with Google Sheets API
+    SCOPES = ["https://www.googleapis.com/auth/spreadsheets", "https://www.googleapis.com/auth/drive"]
+    SERVICE_ACCOUNT_FILE = f"{credentials_path}/google_credentials.json"
+    credentials = Credentials.from_service_account_file(SERVICE_ACCOUNT_FILE, scopes=SCOPES)
+    gc = gspread.authorize(credentials)
+
+    # fetch lightwheel API token
+    LIGHTWHEEL_API_FILE = f"{credentials_path}/lightwheel_credentials.json"
+    LIGHTWHEEL_LOGIN_URL = "http://authserver.lightwheel.net/api/authenticate/v1/user/login"
+    with open(LIGHTWHEEL_API_FILE, "r") as f:
+        lightwheel_api_credentials = json.load(f)
+
+    response = requests.post(
+        LIGHTWHEEL_LOGIN_URL,
+        json={"username": lightwheel_api_credentials["username"], "password": lightwheel_api_credentials["password"]},
+    )
+    response.raise_for_status()
+    lw_token = response.json().get("token")
+    return gc, lightwheel_api_credentials, lw_token
+
+
+def update_google_sheet(credentials_path: str, task_name: str, row_idx: int) -> None:
+    """
+    [Internal use only] update internal data replay tracking sheet.
+    Args:
+        credentials_path (str): Path to the credentials directory.
+        task_name (str): Name of the task to update.
+        row_idx (int): Row index to update.
+    """
+    import gspread
+
+    assert getpass.getuser() in VALID_USER_NAME, f"Invalid user {getpass.getuser()}"
+    # authorize with Google Sheets API
+    SCOPES = ["https://www.googleapis.com/auth/spreadsheets", "https://www.googleapis.com/auth/drive"]
+    SERVICE_ACCOUNT_FILE = f"{credentials_path}/google_credentials.json"
+    credentials = Credentials.from_service_account_file(SERVICE_ACCOUNT_FILE, scopes=SCOPES)
+    gc = gspread.authorize(credentials)
+    spreadsheet = gc.open("B1K Challenge 2025 Data Replay Tracking Sheet")
+    worksheet_name = f"{TASK_NAMES_TO_INDICES[task_name]} - {task_name}"
+    task_worksheet = spreadsheet.worksheet(worksheet_name)
+    # get row data
+    row_data = task_worksheet.row_values(row_idx)
+    assert row_data[4] == "pending"
+    assert row_data[5] == getpass.getuser()
+    # update status and timestamp
+    task_worksheet.update(
+        range_name=f"E{row_idx}:G{row_idx}",
+        values=[["done", getpass.getuser(), time.strftime("%Y-%m-%d %H:%M:%S")]],
+    )
+
+
+def get_all_instance_id_for_task(lw_token: str, lightwheel_api_credentials: dict, task_name: str) -> Tuple[int, str]:
+    """
+    [Internal use only] Given task name, fetch all instance IDs for that task.
+    Args:
+        lw_token (str): Lightwheel API token.
+        lightwheel_api_credentials (dict): Lightwheel API credentials.
+        task_name (str): Name of the task.
+    Returns:
+        Tuple[int, str]: instance_id and resourceUuid
+    """
+    header = {
+        "UserName": lightwheel_api_credentials["username"],
+        "Authorization": lw_token,
+    }
+    body = {
+        "searchRequest": {
+            "whereEqFields": {
+                "projectUuid": lightwheel_api_credentials["projectUuid"],
+                "level1": task_name,
+                "taskType": 2,
+                "isEnd": True,
+                "passed": True,
+                "resourceType": 3,
+            },
+            "selectedFields": [],
+            "sortFields": {"createdAt": 2, "difficulty": 2},
+            "isDeleted": False,
+        },
+        "page": 1,
+        "pageSize": 300,
+    }
+    response = requests.post("https://assetserver.lightwheel.net/api/asset/v1/task/get", headers=header, json=body)
+    response.raise_for_status()
+    return [(item["level2"], item["resourceUuid"]) for item in response.json().get("data", [])]
+
+
+def get_urls_from_lightwheel(uuids: List[str], lightwheel_api_credentials: dict, lw_token: str) -> List[str]:
+    """
+    [Internal use only] Given a list of UUIDs, fetch their download URLs from Lightwheel API.
+    Args:
+        uuids (List[str]): List of version UUIDs.
+        lightwheel_api_credentials (dict): Lightwheel API credentials.
+        lw_token (str): Lightwheel API token.
+    Returns:
+        List[str]: List of download URLs.
+    """
+    header = {
+        "UserName": lightwheel_api_credentials["username"],
+        "Authorization": lw_token,
+    }
+    body = {"versionUuids": uuids, "projectUuid": lightwheel_api_credentials["projectUuid"]}
+    response = requests.post(
+        "https://assetserver.lightwheel.net/api/asset/v1/teleoperation/download", headers=header, json=body
+    )
+    response.raise_for_status()
+    urls = [res["files"][0]["url"] for res in response.json()["downloadInfos"]]
+    return urls
+
+
+def get_timestamp_from_lightwheel(urls: List[str]) -> List[str]:
+    """
+    [Internal use only] Given a list of URLs, fetch their timestamps (on the filename) from Lightwheel API.
+    Args:
+        urls (List[str]): List of download URLs.
+    Returns:
+        List[str]: List of timestamps.
+    """
+    timestamps = []
+    for url in tqdm(urls):
+        resp = requests.head(url, allow_redirects=True)
+        cd = resp.headers.get("content-disposition")
+        if cd and "filename=" in cd:
+            # e.g. 'attachment; filename="episode_00001234.parquet"'
+            fname = cd.split("filename=")[-1].strip('"; ')
+        else:
+            # fallback: use last part of the URL path
+            fname = urlparse(resp.url).path.split("/")[-1]
+        # extract timestamp from filename, which is of the format "`taskname`_`timestamp``.tar"
+        timestamp = fname.rsplit("_", 1)[1].split(".")[0]
+        assert len(timestamp) == 16, f"Invalid timestamp format: {timestamp}"
+        timestamps.append(timestamp)
+    return timestamps
+
+
+def download_and_extract_data(
+    url: str,
+    data_dir: str,
+    task_name: str,
+    instance_id: int,
+    traj_id: int,
+) -> None:
+    """
+    [Internal use only] Download and extract data from a Lightwheel API URL.
+    Args:
+        url (str): The download URL.
+        data_dir (str): The directory to save the data.
+        task_name (str): The name of the task.
+        instance_id (int): The instance ID.
+        traj_id (int): The trajectory ID.
+    """
+    makedirs_with_mode(f"{data_dir}/2025-challenge-rawdata/task-{TASK_NAMES_TO_INDICES[task_name]:04d}")
+    # Download zip file
+    response = requests.get(url)
+    response.raise_for_status()
+    base_name = os.path.basename(url).split("?")[0]  # remove ?Expires... suffix
+    file_name = os.path.join(data_dir, "2025-challenge-rawdata", base_name)
+    base_name = base_name.split(".")[0]  # remove .tar suffix
+    with open(file_name, "wb") as f:
+        f.write(response.content)
+    # unzip file
+    with tarfile.open(file_name, "r:*") as tar_ref:
+        tar_ref.extractall(f"{data_dir}/2025-challenge-rawdata")
+    # rename and move to "raw" folder
+    assert os.path.exists(
+        f"{data_dir}/2025-challenge-rawdata/{base_name}/{task_name}.hdf5"
+    ), f"File not found: {data_dir}/2025-challenge-rawdata/{base_name}/{task_name}.hdf5"
+    # check running_args.json
+    with open(f"{data_dir}/2025-challenge-rawdata/{base_name}/running_args.json", "r") as f:
+        running_args = json.load(f)
+        assert running_args["task_name"] == task_name, f"Task name mismatch: {running_args['task_name']} != {task_name}"
+        assert (
+            running_args["instance_id"] == instance_id
+        ), f"Instance ID mismatch: {running_args['instance_id']} in running_args.json != {instance_id} from LW API"
+    os.rename(
+        f"{data_dir}/2025-challenge-rawdata/{base_name}/{task_name}.hdf5",
+        f"{data_dir}/2025-challenge-rawdata/task-{TASK_NAMES_TO_INDICES[task_name]:04d}/episode_{TASK_NAMES_TO_INDICES[task_name]:04d}{instance_id:03d}{traj_id:01d}.hdf5",
+    )
+    # remove tar file and
+    os.remove(file_name)
+    os.remove(f"{data_dir}/2025-challenge-rawdata/{base_name}/running_args.json")
+    os.rmdir(f"{data_dir}/2025-challenge-rawdata/{base_name}")
+
+
+def reorder_sheet(worksheet) -> None:
+    """
+    Reorder rows in the worksheet based on column B and column A.
+
+    Rules:
+    0. First row is header row -> keep as-is.
+    1. Rows with B == 0 → first group, sorted by A.
+    2. Rows with B != -1 (and not 0) → second group, sorted by A.
+    3. Rows with B == -1 → last group, sorted by A.
+    """
+
+    # Get all values
+    all_values = worksheet.get_all_values()
+    if not all_values:
+        return  # empty sheet
+
+    header, rows = all_values[0], all_values[1:]
+
+    # Parse into (A, B, rest_of_row)
+    def parse_row(row):
+        row[0] = int(row[0])
+        row[1] = int(row[1])
+        return row[0], row[1], row
+
+    parsed = [parse_row(row) for row in rows]
+
+    # Grouping
+    group_b0 = [r for r in parsed if r[1] == 0]
+    group_notm1 = [r for r in parsed if r[1] > 0]
+    group_m1 = [r for r in parsed if r[1] < 0]
+
+    # Sort each group by A
+    group_b0.sort(key=lambda x: x[0])
+    group_notm1.sort(key=lambda x: x[0])
+    group_m1.sort(key=lambda x: x[0])
+
+    # Rebuild ordered rows
+    new_rows = [r[2] for r in group_b0 + group_notm1 + group_m1]
+
+    # Write back in one batch
+    worksheet.update("A1", [header] + new_rows)
+    print("Reordered rows in worksheet:", worksheet.title)
+    time.sleep(1)  # to avoid rate limiting
+
+
+def remove_failed_episodes(worksheet, data_dir: str) -> None:
+    """
+    For the given worksheet and data_dir:
+    0. Ignore the first row (header)
+    1. Extract task_id from ws.title, which is "{task_id} - {task_name}"
+    2. For each row with column B == -1:
+       - take demo_id = int(column A)
+       - construct episode_name = f"episode_{task_id:04d}{demo_id:04d}"
+       - remove corresponding files from data_dir in all subfolders
+    """
+    # --- Step 1: get task_id from sheet title ---
+    title = worksheet.title
+    task_id_str, _ = title.split(" - ", 1)
+    task_id = int(task_id_str)
+
+    # --- Step 2: read all rows (ignore header) ---
+    all_values = worksheet.get_all_values()
+    rows = all_values[1:]
+    total_removed = 0
+    for row in rows:
+        if len(row) < 2:
+            continue
+        try:
+            demo_id = int(row[0])
+            b_val = int(row[1])
+        except ValueError:
+            continue
+
+        if b_val == -1:
+            episode_name = f"episode_{task_id:04d}{demo_id:03d}0"
+
+            # Files to remove
+            files = [
+                os.path.join(data_dir, f"data/task-{task_id:04d}/{episode_name}.parquet"),
+                os.path.join(data_dir, f"meta/episodes/task-{task_id:04d}/{episode_name}.json"),
+                os.path.join(data_dir, f"raw/task-{task_id:04d}/{episode_name}.hdf5"),
+                os.path.join(data_dir, f"videos/task-{task_id:04d}/observation.images.depth.head/{episode_name}.mp4"),
+                os.path.join(
+                    data_dir, f"videos/task-{task_id:04d}/observation.images.depth.left_wrist/{episode_name}.mp4"
+                ),
+                os.path.join(
+                    data_dir, f"videos/task-{task_id:04d}/observation.images.depth.right_wrist/{episode_name}.mp4"
+                ),
+                os.path.join(data_dir, f"videos/task-{task_id:04d}/observation.images.rgb.head/{episode_name}.mp4"),
+                os.path.join(
+                    data_dir, f"videos/task-{task_id:04d}/observation.images.rgb.left_wrist/{episode_name}.mp4"
+                ),
+                os.path.join(
+                    data_dir, f"videos/task-{task_id:04d}/observation.images.rgb.right_wrist/{episode_name}.mp4"
+                ),
+                os.path.join(
+                    data_dir, f"videos/task-{task_id:04d}/observation.images.seg_instance_id.head/{episode_name}.mp4"
+                ),
+                os.path.join(
+                    data_dir,
+                    f"videos/task-{task_id:04d}/observation.images.seg_instance_id.left_wrist/{episode_name}.mp4",
+                ),
+                os.path.join(
+                    data_dir,
+                    f"videos/task-{task_id:04d}/observation.images.seg_instance_id.right_wrist/{episode_name}.mp4",
+                ),
+            ]
+            n_removed = 0
+            for f in files:
+                if os.path.exists(f):
+                    os.remove(f)
+                    n_removed += 1
+            total_removed += n_removed
+    print(f"Total removed files for task {task_id}: {total_removed}")
+    return total_removed
+
+
+def extract_annotations(
+    data_dir: str,
+    annotation_data_dir: str,
+    credentials_path: str = "~/Documents/credentials",
+    remove_memory_prefix: bool = False,
+) -> None:
+    """
+    Extract annotations from the annotation data directory and store in the data directory.
+    If remove_memory_prefix is True, remove "memory_prefix" field in skill annotations.
+    """
+    data_dir = os.path.expanduser(data_dir)
+    makedirs_with_mode(f"{data_dir}/annotations")
+    annotation_data_dir = os.path.expanduser(annotation_data_dir)
+    # get tracking worksheet
+    gc = get_credentials(credentials_path)[0]
+    spreadsheet = gc.open("B1K Challenge 2025 Data Replay Tracking Sheet")
+
+    task_processed = 0
+    # iterate through all files under annotation_data_dir,
+    for file in os.listdir(annotation_data_dir):
+        if file.endswith(".zip"):
+            # extract filename
+            filename = file[:-4]
+            if filename not in TASK_NAMES_TO_INDICES:
+                print(f"Invalid task name: {filename}")
+                continue
+            # unzip the file
+            with zipfile.ZipFile(os.path.join(annotation_data_dir, file), "r") as zip_ref:
+                zip_ref.extractall(f"{data_dir}/annotations")
+            # rename folder based on task indices
+            task_index = TASK_NAMES_TO_INDICES[filename]
+            os.rename(f"{data_dir}/annotations/{filename}", f"{data_dir}/annotations/task-{task_index:04d}")
+            # now, assert there are 200 files in the task folder
+            assert (
+                len(os.listdir(f"{data_dir}/annotations/task-{task_index:04d}")) == 200
+            ), f"Task {task_index} does not have 200 files."
+            # now, fetch all timestamp - task indices correspondance from worksheet
+            worksheet = spreadsheet.worksheet(f"{task_index} - {filename}")
+            rows = worksheet.get_all_values()[1:]  # skip header
+            for row in rows:
+                if row and row[4] == "done":
+                    instance_id, traj_id, timestamp = int(row[0]), int(row[1]), row[3]
+                    assert os.path.isfile(
+                        f"{data_dir}/annotations/task-{task_index:04d}/{filename}_{timestamp}.json"
+                    ), f"Missing annotation for {instance_id}"
+                    # rename episode
+                    os.rename(
+                        f"{data_dir}/annotations/task-{task_index:04d}/{filename}_{timestamp}.json",
+                        f"{data_dir}/annotations/task-{task_index:04d}/episode_{task_index:04d}{instance_id:03d}{traj_id:01d}.json",
+                    )
+                    if remove_memory_prefix:
+                        # remove "memory" in skill_annotations and primitive_annotations
+                        with open(
+                            f"{data_dir}/annotations/task-{task_index:04d}/episode_{task_index:04d}{instance_id:03d}{traj_id:01d}.json",
+                            "r",
+                        ) as f:
+                            annotation_data = json.load(f)
+                        for skill in annotation_data.get("skill_annotation", []):
+                            if "memory_prefix" in skill:
+                                del skill["memory_prefix"]
+                        for primitive in annotation_data.get("primitive_annotation", []):
+                            if "memory_prefix" in primitive:
+                                del primitive["memory_prefix"]
+                        with open(
+                            f"{data_dir}/annotations/task-{task_index:04d}/episode_{task_index:04d}{instance_id:03d}{traj_id:01d}.json",
+                            "w",
+                        ) as f:
+                            json.dump(annotation_data, f, indent=4)
+            print(f"Finished processing task {task_index} - {filename}")
+            task_processed += 1
+            time.sleep(1.5)  # to avoid rate limiting
+
+    # remove __MACOSX folder
+    shutil.rmtree(f"{data_dir}/annotations/__MACOSX")
+    print(f"Finished processing {task_processed} tasks.")
+
+
+def check_leaf_folders_have_n(data_dir: str, n: int = 200) -> Tuple[dict, int]:
+    """
+    Recursively find all leaf folders under data_dir.
+    A leaf folder is one that contains only files (no subdirectories).
+    For each leaf folder, check it has exactly n files.
+    Args:
+        data_dir (str): The root directory to start searching.
+        n (int): The exact number of files each leaf folder should have.
+    Returns:
+        Tuple[dict, int]: A tuple containing:
+            - A dictionary mapping leaf folder paths to their file counts.
+            - The total file count across all leaf folders.
+    """
+    data_dir = os.path.expanduser(data_dir)
+    results = {}
+    total_count = 0
+    for root, dirs, files in os.walk(data_dir):
+        # ignore hidden folders
+        dirs[:] = [d for d in dirs if not d.startswith(".")]
+        # leaf folder: contains files but no subdirs
+        if not dirs:
+            count = len([f for f in files if os.path.isfile(os.path.join(root, f))])
+            results[root] = count
+            total_count += count
+            if count == n:
+                print(f"✅ {root} has exactly {n} files.")
+            else:
+                raise Exception(f"❌ {root} has {count} files (expected {n}).")
+    print(f"Total files across all leaf folders: {total_count}")
+    return results, total_count
+
+
+def update_sheet_counts(worksheet) -> None:
+    """
+    [Internal use only] Updates the worksheet:
+    1. For rows with B != 0:
+       - E = "ignored"
+       - F = ""
+    2. Replace column B with the number of occurrences of column A
+       in previous rows.
+    """
+    all_values = worksheet.get_all_values()
+    if not all_values:
+        return
+
+    _, rows = all_values[0], all_values[1:]
+
+    # Track counts of column A values
+    counts = {}
+
+    updated_rows = []
+    for row in rows:
+        row[0] = int(row[0])
+        row[1] = int(row[1])
+        row[7] = ""
+
+        # --- Step 1: update columns E/F based on original B ---
+        if row[1] != 0:
+            row[4] = "ignored"  # Column E (0-indexed 4)
+            row[5] = ""  # Column F (0-indexed 5)
+
+        # --- Step 2: update column B with previous counts of A ---
+        prev_count = counts.get(row[0], 0)
+        row[1] = int(prev_count)  # Column B
+        counts[row[0]] = prev_count + 1
+
+        updated_rows.append(row)
+
+    # Update the sheet in one batch
+    worksheet.update("A2", updated_rows)
+    print("Changed worksheet:", worksheet.title)
+    time.sleep(1)  # to avoid rate limiting
+
+
+def assign_test_instances(task_ws, ws_misc, misc_values) -> None:
+    """
+    For a given task worksheet and the misc spreadsheet:
+    1. Get task_id and task_name from worksheet title "{id} - {name}".
+    2. Collect unique integers in Column A and compute missing IDs from {1..300}.
+    3. Sample up to 20 missing IDs
+    4. Write groups into columns C in the matching row of Test Instances tab.
+    """
+    # --- Step 1: parse task id/name from worksheet title ---
+    title = task_ws.title
+    task_id_str, task_name = title.split(" - ", 1)
+    task_id = int(task_id_str)
+
+    # --- Step 2: collect unique ints in column A ---
+    all_values = task_ws.get_all_values()
+    rows = all_values[1:]  # ignore header
+    col_a_set = set()
+    for row in rows:
+        if not row or not row[0]:
+            continue
+        try:
+            col_a_set.add(int(row[0]))
+        except ValueError:
+            continue
+
+    ref_set = set(range(1, 301))
+    # assert col_a_set is a subset of ref_set
+    assert col_a_set.issubset(ref_set), f"Column A has values outside 1-300: {col_a_set - ref_set}"
+    missing = list(ref_set - col_a_set)
+    assert len(missing) >= 20, f"Not enough missing IDs to sample 20: only {len(missing)} missing."
+
+    # --- Step 3: sample up to 20 ---
+    sample_missing = random.sample(missing, 20)
+    random.shuffle(sample_missing)
+
+    # --- Step 4: open misc sheet and find correct row ---
+
+    # First row is header
+    target_row = misc_values[task_id + 1]
+    assert (
+        int(target_row[0]) == task_id and target_row[1].strip() == task_name
+    ), f"Row mismatch for task {task_id} - {task_name}: found {target_row[0]} - {target_row[1]}"
+
+    # --- Step 5: update in one batch ---
+    ws_misc.update(range_name=f"C{task_id + 2}:C{task_id + 2}", values=[[", ".join(map(str, sample_missing))]])
+    time.sleep(1)
+
+    print(f"✅ Updated task {task_id} - {task_name} with test instances.")
+
+
+def update_parquet_indices(root_dir: str):
+    """For every parquet file named episode_XXXXXXXX.parquet, update episode_index and task_index."""
+    pat = re.compile(r"episode_(\d{8})\.parquet$")
+
+    for dirpath, _, filenames in os.walk(root_dir):
+        print(dirpath)
+        for fname in filenames:
+            fpath = os.path.join(dirpath, fname)
+
+            m = pat.search(fname)
+            if not m:
+                continue  # not a matching parquet
+
+            episode_num = int(m.group(1))
+            task_num = int(m.group(1)[:4])
+            try:
+                df = pd.read_parquet(fpath)
+
+                assert "episode_index" in df.columns
+                df["episode_index"] = episode_num
+                assert "task_index" in df.columns
+                df["task_index"] = task_num
+
+                # overwrite parquet
+                df.to_parquet(fpath, index=False)
+
+            except Exception as e:
+                print(f"Skipping {fpath}, error: {e}")
+
+
+def remove_grasp_state(root_dir: str):
+    """
+    For every parquet file named episode_XXXXXXXX.parquet,
+    If observation.state has dim 258, remove dim 193 and 233 (grasp_left and grasp_right) and save the parquet back to disk.
+    """
+    pat = re.compile(r"episode_(\d{8})\.parquet$")
+
+    for dirpath, _, filenames in os.walk(root_dir):
+        print(dirpath)
+        for fname in filenames:
+            fpath = os.path.join(dirpath, fname)
+
+            m = pat.search(fname)
+            if not m:
+                continue  # not a matching parquet
+
+            try:
+                df = pd.read_parquet(fpath)
+
+                assert "observation.state" in df.columns
+                obs = np.array(df["observation.state"].tolist())
+                if obs.ndim == 2 and obs.shape[1] == 258:
+                    obs = np.delete(obs, [193, 233], axis=1)
+                    df["observation.state"] = obs.tolist()
+
+                    # overwrite parquet
+                    df.to_parquet(fpath, index=False)
+
+            except Exception as e:
+                print(f"Skipping {fpath}, error: {e}")
+
+
+def fix_permissions(root_dir: str):
+    """Recursively set rw-rw-r-- for all files owned by the current user."""
+    for dirpath, _, filenames in os.walk(root_dir):
+        print(dirpath)
+        for fname in filenames:
+            fpath = os.path.join(dirpath, fname)
+            try:
+                os.chmod(fpath, 0o664)  # rw-rw-r--
+            except (PermissionError, FileNotFoundError):
+                continue
+
+
+def download_raw(credentials_path: str = "~/Documents/credentials", max_traj_per_task: int = 200):
+    task_list = list(TASK_NAMES_TO_INDICES.keys())
+    data_dir = "/vision/group/behavior/2025-challenge-rawdata"
+    gc, lightwheel_api_credentials, lw_token = get_credentials(credentials_path=credentials_path)
+
+    tracking_spreadsheet = gc.open("B1K Challenge 2025 Data Replay Tracking Sheet")
+    worksheets = tracking_spreadsheet.worksheets()
+    for ws in worksheets:
+        file_downloaded = 0
+        traj_downloaded = 0
+        task_name = ws.title.split(" - ")[-1]
+        if task_name in task_list:
+            task_id = TASK_NAMES_TO_INDICES[task_name]
+            all_rows = ws.get_all_values()
+            for row in all_rows[1:]:
+                if row and int(row[1]) == 0:  # We download a maximum of one trajectory for each task instance id
+                    resource_uuid = row[2]
+                    instance_id = int(row[0])
+                    # check whether raw file already exists
+                    if not os.path.exists(
+                        os.path.join(
+                            data_dir, "raw", f"task-{task_id:04d}", f"episode_{task_id:04d}{instance_id:03d}0.hdf5"
+                        )
+                    ):
+                        url = get_urls_from_lightwheel([resource_uuid], lightwheel_api_credentials, lw_token=lw_token)[
+                            0
+                        ]
+                        try:
+                            download_and_extract_data(url, data_dir, task_name, instance_id, 0)
+                            file_downloaded += 1
+                            traj_downloaded += 1
+                        except AssertionError as e:
+                            print(
+                                f"Error downloading or extracting data for {task_name} resource uuid {resource_uuid}: {e}"
+                            )
+                    else:
+                        traj_downloaded += 1
+                if traj_downloaded >= max_traj_per_task:
+                    break
+            time.sleep(1)
+
+        print(f"Finished processing task: {ws.title}, {file_downloaded} files downloaded.")
+
+    print("All tasks processed.")
+
+
+def is_more_than_x_hours_ago(dt_str, x, fmt="%Y-%m-%d %H:%M:%S"):
+    dt = datetime.strptime(dt_str, fmt)
+    diff_hours = (datetime.now() - dt).total_seconds() / 3600
+    return diff_hours > x
+
+
+def update_tracking_sheet(
+    credentials_path: str = "~/Documents/credentials", max_entries_per_task: Optional[int] = None
+) -> None:
+    """
+    [Internal use only] Updates the tracking sheet with the latest information from lightwheel.
+    Args:
+        credentials_path (str): The path to the credentials file.
+        max_entries_per_task (Optional[int]): The maximum number of entries to process per task.
+    """
+    import gspread
+
+    assert getpass.getuser() in VALID_USER_NAME, f"Invalid user {getpass.getuser()}"
+    gc, lightwheel_api_credentials, lw_token = get_credentials(credentials_path)
+    spreadsheet = gc.open("B1K Challenge 2025 Data Replay Tracking Sheet")
+    # Update main sheet
+    main_worksheet = spreadsheet.worksheet("Main")
+    main_worksheet.update(range_name="A5:A5", values=[[f"Last updated: {time.strftime('%Y-%m-%d %H:%M:%S')}"]])
+
+    for task_name, task_index in tqdm(TASK_NAMES_TO_INDICES.items()):
+        worksheet_name = f"{task_index} - {task_name}"
+        # Get or create the worksheet
+        try:
+            task_worksheet = spreadsheet.worksheet(worksheet_name)
+        except gspread.exceptions.WorksheetNotFound:
+            task_worksheet = spreadsheet.add_worksheet(title=worksheet_name, rows="1", cols="8")
+            header = [
+                "Instance ID",
+                "Traj ID",
+                "Resource UUID",
+                "Timestamp",
+                "Status",
+                "Worker ID",
+                "Last Updated",
+                "Misc",
+            ]
+            task_worksheet.update(range_name="A1:H1", values=[header])
+
+        # Get all ids from lightwheel
+        lw_ids = get_all_instance_id_for_task(lw_token, lightwheel_api_credentials, task_name)
+
+        # Get all resource uuids
+        rows = task_worksheet.get_all_values()
+        if len(rows) != len(lw_ids) + 1:
+            print(f"Row count mismatch for task {task_name}: {len(rows)} != {len(lw_ids) + 1}")
+        resource_uuids = set(row[2] for row in rows[1:] if len(row) > 2)
+        counter = Counter(row[0] for row in rows[1:] if len(row) > 0)
+        for lw_id in lw_ids:
+            num_entries = task_worksheet.row_count - 1
+            if max_entries_per_task is not None and num_entries >= max_entries_per_task:
+                break
+            if lw_id[1] not in resource_uuids:
+                url = get_urls_from_lightwheel([lw_id[1]], lightwheel_api_credentials, lw_token)
+                timestamp = str(get_timestamp_from_lightwheel(url)[0])
+                # append new row with unprocessed status
+                new_row = [
+                    lw_id[0],
+                    counter[lw_id[0]],
+                    lw_id[1],
+                    timestamp,
+                    "unprocessed",
+                    "",
+                    time.strftime("%Y-%m-%d %H:%M:%S"),
+                    "",
+                ]
+                task_worksheet.append_row(new_row, value_input_option="USER_ENTERED")
+                counter[lw_id[0]] += 1
+                # rate limit
+                time.sleep(1)
+        # now iterate through entires and find failure ones
+        for row_idx, row in enumerate(rows[1:], start=2):
+            hours_to_check = 24
+            if row and row[4].strip().lower() == "pending" and is_more_than_x_hours_ago(row[6], hours_to_check):
+                print(
+                    f"Row {row_idx} in {worksheet_name} is pending for more than {hours_to_check} hours, marking as failed."
+                )
+                # change row[4] to failed and append 'a' to row[7]
+                task_worksheet.update(
+                    range_name=f"E{row_idx}:H{row_idx}",
+                    values=[["failed", row[5].strip(), time.strftime("%Y-%m-%d %H:%M:%S"), row[7].strip() + "a"]],
+                )
+                time.sleep(1)  # rate limit
+        # rate limit
+        time.sleep(1)
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] All tasks updated successfully.")
+
+
+if __name__ == "__main__":
+    # check_leaf_folders_have_n("~/behavior", 200)
+    # gc = get_credentials("~/Documents/credentials")[0]
+    # tracking_spreadsheet = gc.open("B1K Challenge 2025 Data Replay Tracking Sheet")
+    # misc_sheet = gc.open("B50 Task Misc")
+    # misc_ws = misc_sheet.worksheet("Test Instances")
+    # misc_values = misc_ws.get_all_values()
+    # for task_name, task_index in tqdm(TASK_NAMES_TO_INDICES.items()):
+    #     task_ws = tracking_spreadsheet.worksheet(f"{task_index} - {task_name}")
+    #     assign_test_instances(task_ws, misc_ws, misc_values)
+    #     time.sleep(1)
+    # extract_annotations(
+    #     "/scr/behavior/2025-challenge-demos", "/home/svl/Downloads/annotations", remove_memory_prefix=True
+    # )
+    og.shutdown()