ty

.gitattributes

@@ -1,10 +1,8 @@
-* text=auto eol=lf
+* text=auto
 
 # to move existing files into LFS:
 # git add --renormalize .
 *.onnx filter=lfs diff=lfs merge=lfs -text
-openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl filter=lfs diff=lfs merge=lfs -text
-openpilot/sunnypilot/modeld_v2/models/*.pkl filter=lfs diff=lfs merge=lfs -text
 *.svg filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.gif filter=lfs diff=lfs merge=lfs -text

.github/release-drafter.yml

@@ -0,0 +1,43 @@
+exclude-labels:
+  - 'no-changelog'
+categories:
+  - title: '🚀 Features'
+    labels:
+      - 'feature'
+      - 'enhancement'
+  - title: '🐛 Bug Fixes'
+    collapse-after: 5
+    labels:
+      - 'fix'
+      - 'bugfix'
+      - 'bug'
+  - title: '🧰 Maintenance'
+    collapse-after: 5
+    label: 'chore'
+change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
+change-title-escapes: '\<*_&'
+replacers:
+  - search: '/[Ss][Uu][Nn][Nn][Yy][Pp][Ii][Ll][Oo][Tt]/g'
+    replace: 'sunnypilot'
+  - search: '/\b[Ss][Pp]\b/g'
+    replace: 'SP'
+version-resolver:
+  major:
+    labels:
+      - 'major'
+  minor:
+    labels:
+      - 'minor'
+  patch:
+    labels:
+      - 'patch'
+  default: patch
+name-template: 'v$RESOLVED_VERSION 🚀'
+tag-template: 'v$RESOLVED_VERSION'
+version-template: "0.$MAJOR.$MINOR.$PATCH" # The day OP becomes v1, we need to bump this
+tag-prefix: "v0." # The day OP becomes v1, we need to bump this
+prerelease-identifier: "staging"
+template: |
+  ## Changes
+
+  $CHANGES

.github/workflows/build-all-tinygrad-models.yaml

@@ -20,11 +20,6 @@ on:
         required: false
         type: string
         default: 'sunnypilot/sunnypilot_models_v1'
-      docs_repo:
-        description: 'GitHub repo holding the driving_models JSON on its gh-pages branch'
-        required: false
-        type: string
-        default: 'sunnypilot/sunnypilot-models'
 
 jobs:
   setup:
@@ -39,9 +34,9 @@ jobs:
       - name: Checkout sunnypilot repo
         uses: actions/checkout@v4
         with:
+          repository: sunnypilot/sunnypilot
           path: sunnypilot
           submodules: recursive
-          fetch-depth: 1
 
       - name: Get tinygrad_repo ref
         id: get-tinygrad-ref
@@ -52,14 +47,13 @@ jobs:
           echo "tinygrad_ref=$ref" >> $GITHUB_OUTPUT
           echo "tinygrad_ref is $ref"
 
-      - name: Checkout docs repo (gh-pages)
+      - name: Checkout docs repo (sunnypilot-models, gh-pages)
         uses: actions/checkout@v4
         with:
-          repository: ${{ inputs.docs_repo }}
+          repository: sunnypilot/sunnypilot-models
           ref: gh-pages
           path: docs
           ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}
-          fetch-depth: 1
 
       - name: Get next JSON version to use (from GitHub docs repo)
         id: get-json
@@ -124,7 +118,6 @@ jobs:
       json_version: ${{ needs.setup.outputs.json_version }}
       target_hardware: ${{ github.event.inputs.target_hardware }}
       hf_repo: ${{ github.event.inputs.hf_repo }}
-      docs_repo: ${{ inputs.docs_repo }}
       set_min_version: ${{ github.event.inputs.set_min_version }}
       tinygrad_ref: ${{ needs.setup.outputs.tinygrad_ref }}
     secrets: inherit
@@ -169,7 +162,6 @@ jobs:
       target_hardware: ${{ github.event.inputs.target_hardware }}
       artifact_suffix: -retry
       hf_repo: ${{ github.event.inputs.hf_repo }}
-      docs_repo: ${{ inputs.docs_repo }}
       set_min_version: ${{ github.event.inputs.set_min_version }}
       tinygrad_ref: ${{ needs.setup.outputs.tinygrad_ref }}
     secrets: inherit

.github/workflows/build-default-models.yaml

@@ -46,8 +46,8 @@ jobs:
 
           if [ "${{ inputs.target }}" = "big" ]; then
             NAME=$(python3 -c "from openpilot.sunnypilot.models.model_name import DEFAULT_BIG_MODEL; print(DEFAULT_BIG_MODEL)")
+            ONNX_PATH="openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx"
             HF_DEFAULTS_PATH="models/defaults/big"
-            ONNX_PATH="openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl"
           elif [ "${{ inputs.target }}" = "dm" ]; then
             ONNX_PATH="openpilot/selfdrive/modeld/models/dmonitoring_model.onnx"
             HF_DEFAULTS_PATH="models/defaults/dm"
@@ -57,9 +57,8 @@ jobs:
             ONNX_PATH="openpilot/selfdrive/modeld/models/driving_supercombo.onnx"
             HF_DEFAULTS_PATH="models/defaults/small"
           fi
-          ONNX_REF=""
-          [ -n "$ONNX_PATH" ] && ONNX_REF=$(git log -1 --format='%H' -- "$ONNX_PATH")
 
+          ONNX_REF=$(git log -1 --format='%H' -- "$ONNX_PATH")
           TINYGRAD_REF=$(python3 openpilot/sunnypilot/models/tinygrad_ref.py)
           if [ -z "$TINYGRAD_REF" ]; then
             echo "::error::Failed to resolve tinygrad ref"
@@ -79,8 +78,6 @@ jobs:
     if: ${{ inputs.target == 'small' }}
     runs-on: [self-hosted, tici]
     env:
-      MODELS_DIR: openpilot/selfdrive/modeld/models
-      COMPILER: tinygrad_repo/examples/openpilot
       SMALL_ONNX: openpilot/selfdrive/modeld/models/driving_supercombo.onnx
       SMALL_PKL: openpilot/selfdrive/modeld/models/driving_tinygrad.pkl
     steps:
@@ -88,10 +85,9 @@ jobs:
         with:
           submodules: recursive
 
-      - name: Pull small ONNX via LFS
+      - name: Pull ONNX via LFS
         run: git lfs pull -I "${{ env.SMALL_ONNX }}"
 
-
       - name: Set environment variables
         run: |
           source /etc/profile
@@ -107,15 +103,38 @@ jobs:
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
           PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
 
-      - name: Compile small model from ONNX
+      - name: Compile small model with stock compiler
         run: |
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
           export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
+
+          MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
+          CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")
+          FRAME_SKIP=$(python3 -c "from openpilot.selfdrive.modeld.constants import ModelConstants as MC; print(MC.MODEL_RUN_FREQ // MC.MODEL_CONTEXT_FREQ)")
+
           TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
-          env ${TG_FLAGS} python3 ${{ github.workspace }}/${{ env.COMPILER }}/compile_onnx.py \
-            ${{ github.workspace }}/${{ env.SMALL_ONNX }} \
-            ${{ github.workspace }}/${{ env.SMALL_PKL }} \
-            --device-input "*" --out-of-band --benchmark-runs 1
+
+          env ${TG_FLAGS} python3 \
+            ${{ github.workspace }}/openpilot/selfdrive/modeld/compile_modeld.py \
+            --onnx ${{ github.workspace }}/${{ env.SMALL_ONNX }} \
+            --model-size $MODEL_SIZE \
+            --camera-resolutions $CAMERA_RES \
+            --frame-skip $FRAME_SKIP \
+            --output ${{ github.workspace }}/${{ env.SMALL_PKL }}
+
+      - name: Chunk small pkl
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          python3 -c "
+          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+          import os
+          pkl = '${{ github.workspace }}/${{ env.SMALL_PKL }}'
+          size = os.path.getsize(pkl)
+          targets = get_chunk_targets(pkl, size)
+          chunk_file(pkl, targets)
+          print(f'Chunked into {len(targets)} files')
+          "
 
       - name: Prepare output
         env:
@@ -128,16 +147,14 @@ jobs:
           PKL_BASE="driving_tinygrad.pkl"
           mkdir -p "$OUTPUT_DIR"
 
-          cp "$MODELS_DIR/${PKL_BASE}" "$OUTPUT_DIR/"
-
-          ONNX_SHA256=$(git cat-file blob "$(git ls-files -s "${{ github.workspace }}/${{ env.SMALL_ONNX }}" | awk '{print $2}')" | grep '^oid sha256:' | cut -d: -f2)
+          cp "$MODELS_DIR/${PKL_BASE}".chunk* "$OUTPUT_DIR/"
+          cp "$MODELS_DIR/${PKL_BASE}.chunkmanifest" "$OUTPUT_DIR/"
 
           python3 "${{ github.workspace }}/release/ci/model_generator.py" \
             --model-dir "$MODELS_DIR" \
             --output-dir "$OUTPUT_DIR" \
             --custom-name "$MODEL_NAME" \
-            --upstream-branch "${{ needs.resolve.outputs.onnx_ref }}" \
-            --onnx-sha256 "$ONNX_SHA256"
+            --upstream-branch "${{ needs.resolve.outputs.onnx_ref }}"
 
           echo "model-${MODEL_NAME}-${{ github.run_number }}" > "$OUTPUT_DIR/artifact_name.txt"
 
@@ -164,16 +181,15 @@ jobs:
     if: ${{ inputs.target == 'big' }}
     runs-on: [self-hosted, chestnut]
     env:
-      MODELS_DIR: openpilot/selfdrive/modeld/models
-      COMPILER: tinygrad_repo/examples/openpilot
+      BIG_ONNX: openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx
       BIG_PKL: openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl
     steps:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
 
-      - name: Pull big PKL via LFS
-        run: git lfs pull -I "${{ env.BIG_PKL }}"
+      - name: Pull big ONNX via LFS
+        run: git lfs pull -I "${{ env.BIG_ONNX }}"
 
       - name: Set environment variables
         run: |
@@ -206,33 +222,38 @@ jobs:
               raise RuntimeError('Chestnut PCIe link not ready after 10 attempts')
           "
 
-      - name: Compile big warp
+      - name: Compile big model with stock compiler
         run: |
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
           export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
 
-          CHESTNUT_TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32"
-          COMPILER="${{ github.workspace }}/tinygrad_repo/examples/openpilot"
-          MODELS_DIR="${{ github.workspace }}/openpilot/selfdrive/modeld/models"
           MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
+          CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")
+          FRAME_SKIP=$(python3 -c "from openpilot.selfdrive.modeld.constants import ModelConstants as MC; print(MC.MODEL_RUN_FREQ // MC.MODEL_CONTEXT_FREQ)")
 
-          for res in $(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')"); do
-            CAM_W=$(echo $res | cut -d x -f1)
-            CAM_H=$(echo $res | cut -d x -f2)
-            STRIDE_INFO=$(python3 -c "
-          import sys
-          from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
-          s,y,u,sz = get_nv12_info(int(sys.argv[1]), int(sys.argv[2]))
-          print(f'{s},{y},{u},{sz}')
-          " $CAM_W $CAM_H)
-            WARP_PKL="${MODELS_DIR}/big_driving_warp_${res}_tinygrad.pkl"
-            env ${CHESTNUT_TG_FLAGS} python3 "${COMPILER}/compile_warp.py" \
-              --frame ${CAM_W},${CAM_H},${STRIDE_INFO} \
-              --warp-to ${MODEL_SIZE} \
-              --layout yuv420 \
-              --frames 2 \
-              --output "${WARP_PKL}"
-          done
+          TG_FLAGS="DEBUG=2 DEV=USB+AMD:LLVM WARP_DEV=QCOM FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2"
+
+          env ${TG_FLAGS} python3 \
+            ${{ github.workspace }}/openpilot/selfdrive/modeld/compile_modeld.py \
+            --onnx ${{ github.workspace }}/${{ env.BIG_ONNX }} \
+            --model-size $MODEL_SIZE \
+            --camera-resolutions $CAMERA_RES \
+            --frame-skip $FRAME_SKIP \
+            --output ${{ github.workspace }}/${{ env.BIG_PKL }}
+
+      - name: Chunk big pkl
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          python3 -c "
+          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+          import os
+          pkl = '${{ github.workspace }}/${{ env.BIG_PKL }}'
+          size = os.path.getsize(pkl)
+          targets = get_chunk_targets(pkl, size)
+          chunk_file(pkl, targets)
+          print(f'Chunked into {len(targets)} files')
+          "
 
       - name: Prepare output
         env:
@@ -245,18 +266,14 @@ jobs:
           PKL_BASE="big_driving_tinygrad.pkl"
           mkdir -p "$OUTPUT_DIR"
 
-          cp "$MODELS_DIR/${PKL_BASE}" "$OUTPUT_DIR/"
-
-          PKL_LFS_SHA256=$(git cat-file blob "$(git ls-files -s "${{ github.workspace }}/${{ env.BIG_PKL }}" | awk '{print $2}')" | grep '^oid sha256:' | cut -d: -f2)
+          cp "$MODELS_DIR/${PKL_BASE}".chunk* "$OUTPUT_DIR/"
+          cp "$MODELS_DIR/${PKL_BASE}.chunkmanifest" "$OUTPUT_DIR/"
 
           python3 "${{ github.workspace }}/release/ci/model_generator.py" \
             --model-dir "$MODELS_DIR" \
             --output-dir "$OUTPUT_DIR" \
             --custom-name "$MODEL_NAME" \
-            --upstream-branch "${{ needs.resolve.outputs.onnx_ref }}" \
-            --onnx-sha256 "$PKL_LFS_SHA256"
-
-          cp "$MODELS_DIR"/big_driving_warp_* "$OUTPUT_DIR/" || true
+            --upstream-branch "${{ needs.resolve.outputs.onnx_ref }}"
 
           echo "model-${MODEL_NAME}-${{ github.run_number }}" > "$OUTPUT_DIR/artifact_name.txt"
 
@@ -294,8 +311,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Pull LFS for resolved ONNX files
-        if: ${{ needs.resolve.outputs.onnx_path != '' }}
+      - name: Pull ONNX via LFS
         run: git lfs pull -I "${{ needs.resolve.outputs.onnx_path }}"
 
       - name: Install huggingface_hub
@@ -360,28 +376,38 @@ jobs:
           from datetime import datetime, UTC
 
           dm_dir = Path('dm_output')
-          matches = sorted(dm_dir.glob('dmonitoring_*_tinygrad.pkl'))
-          assert len(matches) == 1, f'expected one DM pkl in {dm_dir}, found {matches}'
-          pkl_name = matches[0].name
+          manifest = list(dm_dir.glob('*.chunkmanifest'))
+          assert manifest, 'No chunkmanifest found'
+          pkl_name = manifest[0].name.removesuffix('.chunkmanifest')
+          num_chunks = int(manifest[0].read_text().strip())
+
+          chunks = []
+          for i in range(num_chunks):
+              chunk = dm_dir / f'{pkl_name}.chunk{i+1:02d}of{num_chunks:02d}'
+              chunks.append({
+                  'file_name': chunk.name,
+                  'sha256': hashlib.sha256(chunk.read_bytes()).hexdigest()
+              })
 
           digest = hashlib.sha256()
-          with open(dm_dir / pkl_name, 'rb') as f:
-              while block := f.read(1024*1024):
-                  digest.update(block)
+          for c in chunks:
+              with open(dm_dir / c['file_name'], 'rb') as f:
+                  while block := f.read(1024*1024):
+                      digest.update(block)
 
           metadata = {
               'bundles': [{
                   'short_name': 'DMMODEL',
                   'display_name': '${{ needs.resolve.outputs.model_name }}',
                   'ref': '${{ needs.resolve.outputs.onnx_ref }}',
-                  'tinygrad_ref': '${{ needs.resolve.outputs.tinygrad_ref }}',
                   'runner': 'tinygrad',
                   'build_time': datetime.now(UTC).strftime('%Y-%m-%dT%H:%M:%SZ'),
                   'models': [{
                       'type': 'chunked',
                       'artifact': {
                           'file_name': pkl_name,
-                          'download_uri': {'url': '', 'sha256': digest.hexdigest()}
+                          'download_uri': {'url': '', 'sha256': digest.hexdigest()},
+                          'chunks': chunks
                       }
                   }]
               }]
@@ -444,39 +470,42 @@ jobs:
             ${{ github.workspace }}/${{ env.DM_ONNX }} \
             ${{ github.workspace }}/${{ env.DM_PKL }}
 
+      - name: Chunk DM pkl
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          python3 -c "
+          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+          import os
+          pkl = '${{ github.workspace }}/${{ env.DM_PKL }}'
+          size = os.path.getsize(pkl)
+          targets = get_chunk_targets(pkl, size)
+          chunk_file(pkl, targets)
+          print(f'Chunked {pkl} into {len(targets)} chunks')
+          "
+
       - name: Compile DM warp
         run: |
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
           export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
 
           TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
-          COMPILER="${{ github.workspace }}/tinygrad_repo/examples/openpilot"
-          MODELS_DIR="${{ github.workspace }}/openpilot/selfdrive/modeld/models"
+          MODEL_DIR="${{ github.workspace }}/openpilot/selfdrive/modeld"
           DM_SIZE=$(python3 -c "from openpilot.common.transformations.model import DM_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
 
           for res in $(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')"); do
-            CAM_W=$(echo $res | cut -d x -f1)
-            CAM_H=$(echo $res | cut -d x -f2)
-            STRIDE_INFO=$(python3 -c "
-          import sys
-          from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
-          s,y,u,sz = get_nv12_info(int(sys.argv[1]), int(sys.argv[2]))
-          print(f'{s},{y},{u},{sz}')
-          " $CAM_W $CAM_H)
-            WARP_PKL="${MODELS_DIR}/dm_warp_${res}_tinygrad.pkl"
-            taskset -c 7 env ${TG_FLAGS} python3 "${COMPILER}/compile_warp.py" \
-              --frame ${CAM_W},${CAM_H},${STRIDE_INFO} \
+            WARP_PKL="${MODEL_DIR}/models/dm_warp_${res}_tinygrad.pkl"
+            taskset -c 7 env ${TG_FLAGS} python3 ${MODEL_DIR}/compile_dm_warp.py \
+              --camera-resolution ${res} \
               --warp-to ${DM_SIZE} \
-              --layout luma \
-              --border-fill 16 \
-              --transform-device NPY \
-              --output "${WARP_PKL}"
+              --output ${WARP_PKL}
           done
 
       - name: Prepare DM output
         run: |
           mkdir -p dm_output
-          cp ${{ github.workspace }}/${{ env.DM_PKL }} dm_output/
+          cp ${{ github.workspace }}/${{ env.DM_PKL }}.chunk* dm_output/
+          cp ${{ github.workspace }}/${{ env.DM_PKL }}.chunkmanifest dm_output/
           cp ${{ github.workspace }}/openpilot/selfdrive/modeld/models/dm_warp_* dm_output/
 
       - name: Upload DM artifact
@@ -490,3 +519,4 @@ jobs:
         run: |
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
           PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
+

.github/workflows/build-single-tinygrad-model.yaml

@@ -39,11 +39,6 @@ on:
         required: false
         type: string
         default: 'sunnypilot/sunnypilot_models_v1'
-      docs_repo:
-        description: 'GitHub repo holding the driving_models JSON on its gh-pages branch'
-        required: false
-        type: string
-        default: 'sunnypilot/sunnypilot-models'
       set_min_version:
         description: 'Minimum selector version'
         required: false
@@ -112,11 +107,6 @@ on:
         required: false
         type: string
         default: 'sunnypilot/sunnypilot_models_v1'
-      docs_repo:
-        description: 'GitHub repo holding the driving_models JSON on its gh-pages branch'
-        required: false
-        type: string
-        default: 'sunnypilot/sunnypilot-models'
 env:
   RECOMPILED_DIR: recompiled${{ inputs.recompiled_dir }}
   JSON_FILE: docs/docs/driving_models_${{ inputs.target_hardware == 'chestnut' && 'chestnut_v' || 'v' }}${{ inputs.json_version }}.json
@@ -134,17 +124,19 @@ jobs:
 
   publish_model:
     if: ${{ !cancelled() && needs.build_model.result == 'success' }}
+    concurrency:
+      group: hf-push-${{ inputs.recompiled_dir }}
+      cancel-in-progress: false
     needs: build_model
     runs-on: ubuntu-latest
     permissions:
-      actions: read
       id-token: write
       contents: write
     steps:
       - name: Checkout docs repo
         uses: actions/checkout@v4
         with:
-          repository: ${{ inputs.docs_repo }}
+          repository: sunnypilot/sunnypilot-models
           ref: gh-pages
           path: docs
           ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}
@@ -180,21 +172,18 @@ jobs:
           echo "artifact_name=$ARTIFACT_NAME" >> $GITHUB_OUTPUT
 
       - name: Download and extract model artifact
-        env:
-          GH_TOKEN: ${{ github.token }}
-          ARTIFACT_NAME: ${{ steps.read-artifact-name.outputs.artifact_name }}
-        run: |
-          id=$(gh api -X GET "repos/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID/artifacts" -f name="$ARTIFACT_NAME" --jq '.artifacts[0].id')
-          url=$(curl -sf -o /dev/null -w '%{redirect_url}' -H "Authorization: Bearer $GH_TOKEN" "https://api.github.com/repos/$GITHUB_REPOSITORY/actions/artifacts/$id/zip")
-          sudo apt-get install -y -qq aria2 > /dev/null
-          aria2c -q -x16 -s16 -k8M --max-tries=5 --file-allocation=none -o model.zip "$url" && unzip -q model.zip -d output && rm model.zip
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ steps.read-artifact-name.outputs.artifact_name }}
+          path: output
 
       - name: Create models folder
         env:
           ARTIFACT_NAME: ${{ steps.read-artifact-name.outputs.artifact_name }}
         run: |
           mkdir -p "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}"
-          cp output/metadata.json "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/"
+          cp -r output/* "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/"
+          rm -f "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/artifact_name.txt"
 
       - name: Upload to Hugging Face
         env:
@@ -206,12 +195,13 @@ jobs:
             "models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/" \
             --repo-type=dataset
 
-      - name: Update and push JSON to docs repo
+      - name: Pull gh-pages
         run: |
           cd docs
-          git config --global user.name "GitHub Action"
-          git config --global user.email "action@github.com"
+          git pull origin gh-pages
 
+      - name: Run json_parser.py to update JSON
+        run: |
           FOLDER="${{ inputs.model_folder }}"
           if [ "$FOLDER" = "Other" ]; then
             FOLDER="${{ inputs.custom_model_folder }}"
@@ -224,27 +214,18 @@ jobs:
           [ -n "${{ inputs.version }}" ] && ARGS="$ARGS --version \"${{ inputs.version }}\""
           [ -n "${{ inputs.set_min_version }}" ] && ARGS="$ARGS --set-min-version \"${{ inputs.set_min_version }}\""
           [ -n "${{ inputs.tinygrad_ref }}" ] && ARGS="$ARGS --tinygrad-ref \"${{ inputs.tinygrad_ref }}\""
+          eval python3 docs/json_parser.py \
+            --json-path "$JSON_FILE" \
+            --recompiled-dir "local_models/$RECOMPILED_DIR" \
+            --sort-by-date \
+            $ARGS
 
-          for attempt in $(seq 1 10); do
-            git fetch origin gh-pages
-            git reset --hard origin/gh-pages
-
-            eval python3 json_parser.py \
-              --json-path "docs/$(basename $JSON_FILE)" \
-              --recompiled-dir "../local_models/$RECOMPILED_DIR" \
-              --sort-by-date \
-              $ARGS
-
-            git add docs/"$(basename $JSON_FILE)"
-            git commit -m "Update $(basename $JSON_FILE) after recompiling model" || { echo "No changes to commit"; exit 0; }
-
-            if git push origin gh-pages; then
-              echo "Push succeeded on attempt $attempt"
-              exit 0
-            fi
-
-            echo "Push failed (attempt $attempt/10), retrying after backoff..."
-            sleep $((RANDOM % 10 + 3))
-          done
-          echo "All 10 push attempts failed"
-          exit 1
+      - name: Push updated JSON to GitHub docs repo
+        run: |
+          cd docs
+          git config --global user.name "GitHub Action"
+          git config --global user.email "action@github.com"
+          git checkout gh-pages
+          git add docs/"$(basename $JSON_FILE)"
+          git commit -m "Update $(basename $JSON_FILE) after recompiling model" || echo "No changes to commit"
+          git push origin gh-pages

.github/workflows/compile-warp-kernels.yaml

@@ -1,71 +0,0 @@
-name: Compile warp for sunnypilot modeld
-
-on:
-  workflow_dispatch:
-
-jobs:
-  compile_warps:
-    runs-on: [self-hosted, chestnut]
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-
-      - name: Set environment variables
-        run: |
-          source /etc/profile
-          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
-          export UV_PYTHON_PREFERENCE=managed
-          export UV_PYTHON_INSTALL_DIR=${HOME}/uv/python
-          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
-          uv sync --frozen
-          printenv >> $GITHUB_ENV
-
-      - name: Disable powersave
-        run: |
-          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
-          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
-
-      - name: Compile Warp Kernels
-        run: |
-          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
-          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
-          mkdir -p openpilot/sunnypilot/modeld_v2/models/
-          MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
-          CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")
-          echo "Model size: $MODEL_SIZE"
-          echo "Camera resolutions: $CAMERA_RES"
-
-          for res in $CAMERA_RES; do
-            FRAME_PARAM=$(python3 -c "from openpilot.system.camerad.cameras.nv12_info import get_nv12_info; w, h = map(int, '${res}'.split('x')); stride, y_h, uv_h, _ = get_nv12_info(w, h); print(f'{w},{h},{stride},{y_h},{uv_h},{stride * (y_h + uv_h)}')")
-
-            WARP_PKL="openpilot/sunnypilot/modeld_v2/models/driving_warp_${res}_tinygrad.pkl"
-            echo "Compiling $WARP_PKL on QCOM"
-            taskset -c 7 env DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1 python3 openpilot/sunnypilot/modeld_v2/compile_warp.py \
-              --frame ${FRAME_PARAM} --warp-to ${MODEL_SIZE} --output "${WARP_PKL}"
-
-            BIG_WARP_PKL="openpilot/sunnypilot/modeld_v2/models/big_driving_warp_${res}_tinygrad.pkl"
-            echo "Compiling $BIG_WARP_PKL on AMD"
-            taskset -c 7 env DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32 python3 openpilot/sunnypilot/modeld_v2/compile_warp.py \
-              --frame ${FRAME_PARAM} --warp-to ${MODEL_SIZE} --output "${BIG_WARP_PKL}"
-          done
-
-      - name: Re-enable powersave
-        if: always()
-        run: |
-          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
-          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
-
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@9153d834b60caba6d51c9b9510b087acf9f33f83
-        with:
-          author: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: "[bot] Update warp pkl for modeld_v2"
-          title: "[bot] Update modeld_v2 Warp"
-          branch: "auto/compile-warp-kernels"
-          base: "master"
-          delete-branch: true
-          labels: bot
-          add-paths: |
-            openpilot/sunnypilot/modeld_v2/models/*.pkl

.github/workflows/docs.yaml

@@ -18,25 +18,24 @@ concurrency:
 env:
   GIT_CONFIG_COUNT: 1
   GIT_CONFIG_KEY_0: lfs.fetchexclude
-  GIT_CONFIG_VALUE_0: openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl
+  GIT_CONFIG_VALUE_0: openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx
 
 jobs:
   docs:
     name: build docs
-    runs-on: ${{
-      (github.repository == 'commaai/openpilot') &&
-      ((github.event_name != 'pull_request') ||
-      (github.event.pull_request.head.repo.full_name == 'commaai/openpilot'))
-      && fromJSON('["namespace-profile-amd64-8x16"]')
-      || fromJSON('["ubuntu-24.04"]') }}
+    runs-on: ubuntu-24.04
     steps:
     - uses: commaai/timeout@v1
+
     - uses: actions/checkout@v7
-    - run: ./tools/op.sh setup
+      with:
+        submodules: true
 
     # Build
     - name: Build docs
-      run: ./tools/op.sh docs --build
+      run: |
+        git lfs pull
+        python docs/serve.py --build
 
     # Push to docs.comma.ai
     - uses: actions/checkout@v7

.github/workflows/download-hf-model-chunks/action.yml

@@ -1,5 +1,5 @@
-name: Download HF model
-description: Resolve and download models from HuggingFace in parallel
+name: Download HF model chunks
+description: Resolve and download model chunks from HuggingFace in parallel
 
 inputs:
   hf_repo:
@@ -11,21 +11,16 @@ inputs:
   dest_dir:
     description: Destination directory for downloaded chunks
     required: true
-  tinygrad_ref:
-    description: 'Tinygrad ref to match bundle against'
-    required: false
-    default: ''
 
 runs:
   using: composite
   steps:
-    - name: Download models
+    - name: Download model chunks
       shell: bash
       env:
         HF_REPO: ${{ inputs.hf_repo }}
         MODELS_JSON: ${{ inputs.models }}
         DEST_DIR: ${{ inputs.dest_dir }}
-        TINYGRAD_REF: ${{ inputs.tinygrad_ref }}
       run: |
         set -eo pipefail
         DOWNLOAD_LIST=$(mktemp)
@@ -33,41 +28,30 @@ runs:
         resolve_chunks() {
           local HF_PATH="$1" ONNX_HASH="$2" CANONICAL="$3" DEST_DIR="$4"
           local JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_PATH}/default_models.json"
-          local DEFAULTS BUNDLE ARTIFACT FILE_URL BASE_URL
+          local DEFAULTS BUNDLE ARTIFACT BASE_URL NUM_CHUNKS
           DEFAULTS=$(curl -fsSL "$JSON_URL")
-          if [ -n "$TINYGRAD_REF" ]; then
-            BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" --arg tg "$TINYGRAD_REF" '
-              . as $root | [.bundles[] | select(.onnx_sha256 == $hash and (.tinygrad_ref == $tg or (.tinygrad_ref == null and $root.tinygrad_ref == $tg)))] | .[0] // empty
-            ')
-          else
-            BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" '
-              [.bundles[] | select(.onnx_sha256 == $hash)] | .[0] // empty
-            ')
-          fi
-
-          if [ -z "$BUNDLE" ] || [ "$BUNDLE" = "null" ]; then
-            echo "::error::No model bundle found matching ONNX hash $ONNX_HASH (tinygrad ref: $TINYGRAD_REF) in $HF_PATH"
-            return 1
-          fi
-
+          BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" '.bundles[] | select(.onnx_sha256 == $hash)')
           ARTIFACT=$(echo "$BUNDLE" | jq -r '.models[0].artifact')
-          FILE_URL=$(echo "$ARTIFACT" | jq -r '.download_uri.url')
-          BASE_URL=$(echo "$FILE_URL" | sed 's|/[^/]*$||')
+          BASE_URL=$(echo "$ARTIFACT" | jq -r '.download_uri.url' | sed 's|/[^/]*$||')
+          NUM_CHUNKS=$(echo "$ARTIFACT" | jq -r '.chunks | length')
 
           mkdir -p "$DEST_DIR"
-          ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${FILE_URL}', safe=':/'))")
-          printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${CANONICAL}" >> "$DOWNLOAD_LIST"
+          while IFS= read -r CHUNK_NAME; do
+            CHUNK_IDX=$(echo "$CHUNK_NAME" | grep -oP 'chunk\K[0-9]+of[0-9]+' || true)
+            if [ -z "$CHUNK_IDX" ]; then
+              echo "::error::Failed to parse chunk index from: $CHUNK_NAME"
+              return 1
+            fi
+            ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${BASE_URL}/${CHUNK_NAME}', safe=':/'))")
+            printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${CANONICAL}.chunk${CHUNK_IDX}" >> "$DOWNLOAD_LIST"
+          done < <(echo "$ARTIFACT" | jq -r '.chunks[].file_name')
+          echo "$NUM_CHUNKS" > "${DEST_DIR}/${CANONICAL}.chunkmanifest"
 
           if [ "$CANONICAL" = "dmonitoring_model_tinygrad.pkl" ]; then
             for warp in dm_warp_1928x1208_tinygrad.pkl dm_warp_1344x760_tinygrad.pkl; do
               ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${BASE_URL}/${warp}', safe=':/'))")
               printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${warp}" >> "$DOWNLOAD_LIST"
             done
-          elif [ "$CANONICAL" = "big_driving_tinygrad.pkl" ]; then
-            for warp in big_driving_warp_1928x1208_tinygrad.pkl big_driving_warp_1344x760_tinygrad.pkl; do
-              ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${BASE_URL}/${warp}', safe=':/'))")
-              printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${warp}" >> "$DOWNLOAD_LIST"
-            done
           fi
         }
 
@@ -79,7 +63,7 @@ runs:
         done
 
         TOTAL=$(wc -l < "$DOWNLOAD_LIST")
-        echo "Downloading $TOTAL files with 8 parallel connections..."
+        echo "Downloading $TOTAL chunks with 8 parallel connections..."
         xargs -P8 -d'\n' -I{} bash -c '
           URL="${1%%	*}"
           DEST="${1#*	}"

.github/workflows/lfs-maintenance.yaml

@@ -1,8 +1,8 @@
 name: Sync comma's LFS
 
 env:
-  LFS_URL: 'https://huggingface.co/sunnypilot/sunnypilot-lfs.git/info/lfs'
-  LFS_PUSH_URL: 'https://huggingface.co/sunnypilot/sunnypilot-lfs.git/info/lfs'
+  LFS_URL: 'https://gitlab.com/sunnypilot/public/sunnypilot-new-lfs.git/info/lfs'
+  LFS_PUSH_URL: 'ssh://git@gitlab.com/sunnypilot/public/sunnypilot-new-lfs.git'
 
 on:
   schedule:
@@ -40,12 +40,14 @@ jobs:
           git config --global user.name 'GitHub Action'
           git config --global user.email 'action@github.com'
 
-      - name: Setup hf
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+      - name: Set up SSH
+        uses: webfactory/ssh-agent@v0.9.0
+        with:
+          ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}
+
+      - name: Add GitLab public keys
         run: |
-          git config --global credential.helper store
-          echo "https://user:${HF_TOKEN}@huggingface.co" > ~/.git-credentials
+          ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
 
       - name: Ensure branch
         run: |

.github/workflows/release-drafter.yml

@@ -0,0 +1,28 @@
+name: Release Drafter
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*'
+  pull_request_target:
+    types: [opened, reopened, synchronize]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  update_release_draft:
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: release-drafter/release-drafter@v6
+        with:
+          config-name: release-drafter.yml
+          prerelease: ${{ !startsWith(github.ref, 'refs/tags/v') }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release.yaml

@@ -7,7 +7,7 @@ on:
 env:
   GIT_CONFIG_COUNT: 1
   GIT_CONFIG_KEY_0: lfs.fetchexclude
-  GIT_CONFIG_VALUE_0: openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl
+  GIT_CONFIG_VALUE_0: openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx
 
 jobs:
   build___nightly:
@@ -34,7 +34,3 @@ jobs:
     - run: ./tools/op.sh setup
     - name: Push __nightly
       run: BRANCH=__nightly tools/release/build_stripped.sh
-    - name: Push chestnut nightly
-      run: |
-        git lfs pull --exclude=''
-        INCLUDE_BIG_MODEL=1 BRANCH=__nightly-chestnut tools/release/build_stripped.sh

.github/workflows/repo-maintenance.yaml

@@ -11,7 +11,7 @@ env:
   PYTHONPATH: ${{ github.workspace }}
   GIT_CONFIG_COUNT: 1
   GIT_CONFIG_KEY_0: lfs.fetchexclude
-  GIT_CONFIG_VALUE_0: openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl
+  GIT_CONFIG_VALUE_0: openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx
 
 jobs:
   package_updates:

.github/workflows/sunnypilot-build-model.yaml

@@ -100,56 +100,24 @@ jobs:
           commit_date=$(git log -1 --format=%cd --date=format:'%B %d, %Y')
           echo "model_date=${commit_date}" >> $GITHUB_OUTPUT
           cat $GITHUB_OUTPUT
-
-      - name: Fetch Models
-        run: |
+      - run: |
           cd ${{ github.workspace }}/openpilot/openpilot
-          fetch_lfs() {
-            sudo apt-get install -y -qq aria2 > /dev/null # Parallel ranges because gh is flaky
-            LFS_URL=$(git config -f "$(git rev-parse --show-toplevel)/.lfsconfig" lfs.url)
-            for f in "$@"; do
-              grep -qs "^version https://git-lfs" "$f" || continue
-              OID=$(awk -F'sha256:' '/^oid/{print $2}' "$f"); SIZE=$(awk '/^size/{print $2}' "$f")
-              HREF=$(curl -fsSL --retry 3 -X POST -H "Accept: application/vnd.git-lfs+json" -H "Content-Type: application/vnd.git-lfs+json" "$LFS_URL/objects/batch" \
-                -d "{\"operation\":\"download\",\"transfer\":[\"basic\"],\"objects\":[{\"oid\":\"$OID\",\"size\":$SIZE}]}" | jq -r '.objects[0].actions.download.href')
-              aria2c -x 16 -s 16 -k 16M --max-tries=5 --retry-wait=5 --file-allocation=none --summary-interval=30 --allow-overwrite=true \
-                -d "$(dirname "$f")" -o "$(basename "$f")" "$HREF"
-              echo "$OID  $f" | sha256sum -c -
-            done
-          }
-          UPSTREAM_PKL=selfdrive/modeld/models/big_driving_tinygrad.pkl
           if [ "${{ inputs.target_hardware }}" != "chestnut" ]; then
-            git lfs pull -X "**/selfdrive/modeld/models/big_*.onnx,**/selfdrive/modeld/models/dmonitoring_*.onnx,**/selfdrive/modeld/models/big_*.pkl,**/selfdrive/modeld/models/dmonitoring_*.pkl"
-            rm -f selfdrive/modeld/models/big_*.onnx selfdrive/modeld/models/dmonitoring_*.onnx selfdrive/modeld/models/big_*.pkl selfdrive/modeld/models/dmonitoring_*.pkl
-          elif compgen -G "selfdrive/modeld/models/big_*.onnx" > /dev/null; then
-            fetch_lfs selfdrive/modeld/models/big_*.onnx selfdrive/modeld/models/big_*.pkl
-            find selfdrive/modeld/models -type f \( -name "*.onnx" -o -name "*.pkl" \) ! -name "big_*.onnx" ! -name "big_*.pkl" -delete
-          elif [ -f "$UPSTREAM_PKL" ]; then
-            echo "No big model ONNX tracked: converting commaai's precompiled $UPSTREAM_PKL, with the tinygrad it was built with"
-            fetch_lfs "$UPSTREAM_PKL"
-            find selfdrive/modeld/models -type f \( -name "*.onnx" -o -name "*.pkl" \) ! -path "$UPSTREAM_PKL" -delete
-            GITMODULES="$(git rev-parse --show-toplevel)/.gitmodules"
-            TG_NAME=$(git config -f "$GITMODULES" --get-regexp '^submodule\..*\.path$' | awk '$2 == "tinygrad_repo" {sub(/^submodule\./, "", $1); sub(/\.path$/, "", $1); print $1}')
-            TG_URL=$(git config -f "$GITMODULES" "submodule.$TG_NAME.url" | sed 's|^\.\./\.\./|https://github.com/|')
-            echo "$TG_URL $(git rev-parse HEAD:tinygrad_repo) $(sha256sum "$UPSTREAM_PKL" | cut -d' ' -f1)" > selfdrive/modeld/models/upstream_pkl.txt
+            git lfs pull -X "**/selfdrive/modeld/models/big_*.onnx,**/selfdrive/modeld/models/dmonitoring_*.onnx"
+            rm -f selfdrive/modeld/models/big_*.onnx selfdrive/modeld/models/dmonitoring_*.onnx
           else
-            echo "::error::no big model ONNX or precompiled big_driving_tinygrad.pkl at this ref"
-            exit 1
+            git lfs pull -I "**/selfdrive/modeld/models/big_*.onnx" -X ""
+            find selfdrive/modeld/models -name "*.onnx" ! -name "big_*.onnx" -delete
           fi
-
-          if grep -lIF "version https://git-lfs.github.com/spec/v1" selfdrive/modeld/models/*.onnx selfdrive/modeld/models/*.pkl 2>/dev/null; then
-            echo "::error::the ONNX or PKL files above are still LFS pointers, not real models"
+          if grep -lIF "version https://git-lfs.github.com/spec/v1" selfdrive/modeld/models/*.onnx; then
+            echo "::error::the ONNX files above are still LFS pointers, not real models"
             exit 1
           fi
       - name: 'Upload Artifact'
         uses: actions/upload-artifact@v4
         with:
           name: models-${{ env.REF }}${{ inputs.artifact_suffix  }}
-          compression-level: 0
-          path: |
-            ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/*.onnx
-            ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/*.pkl
-            ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/upstream_pkl.txt
+          path: ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/*.onnx
           if-no-files-found: error
 
   build_model:
@@ -164,6 +132,7 @@ jobs:
           fetch-depth: 1
           submodules: recursive
 
+
       - name: Set environment variables
         id: set-env
         run: |
@@ -175,6 +144,9 @@ jobs:
           export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
           uv sync --frozen
           printenv >> $GITHUB_ENV
+          if [[ "${{ runner.debug }}" == "1" ]]; then
+            cat $GITHUB_OUTPUT
+          fi
 
       - name: Setup build environment
         run: |
@@ -186,6 +158,10 @@ jobs:
           echo "VERSION: ${{ steps.set-env.outputs.version }}"
           echo "UV_PROJECT_ENVIRONMENT: ${UV_PROJECT_ENVIRONMENT}"
           echo "VIRTUAL_ENV: ${VIRTUAL_ENV}"
+          echo "-------"
+          if [[ "${{ runner.debug }}" == "1" ]]; then
+            printenv
+          fi
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
           PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
           rm -rf ${{ env.MODELS_DIR }}/*.onnx*
@@ -208,11 +184,11 @@ jobs:
           MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
           CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")
 
-          TG_FLAGS_QCOM="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 OPENPILOT_HACKS=1"
+          TG_FLAGS_QCOM="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
           if [ "${{ inputs.target_hardware }}" == "chestnut" ]; then
             echo "CHESTNUT build"
             export CHESTNUT=1
-            TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32"
+            TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2 TC_OCCUPANCY_OPT=1"
             OUTPUT_PKL="${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl"
           else
             echo "QCOM build"
@@ -220,77 +196,64 @@ jobs:
             OUTPUT_PKL="${{ env.MODELS_DIR }}/driving_tinygrad.pkl"
           fi
 
-          NATIVE_PKL=$(find "${{ env.MODELS_DIR }}" -maxdepth 1 -name "*.pkl" -print -quit)
+          # Generate metadata for all ONNX files
+          find "${{ env.MODELS_DIR }}" -maxdepth 1 -name '*.onnx' | while IFS= read -r onnx_file; do
+            echo "Generating metadata: $onnx_file"
+            env ${TG_FLAGS_QCOM} python3 "${{ env.MODELS_DIR }}/../get_model_metadata.py" "$onnx_file" || true
+          done
 
-          if [ -f "${{ env.MODELS_DIR }}/upstream_pkl.txt" ]; then
-            read -r TG_URL TG_SHA _ < "${{ env.MODELS_DIR }}/upstream_pkl.txt"
-            echo "Converting commaai's precompiled model with tinygrad $TG_SHA"
-            UPSTREAM_TG="${{ runner.temp }}/upstream_tinygrad"
-            rm -rf "$UPSTREAM_TG" && git init -q "$UPSTREAM_TG" && git -C "$UPSTREAM_TG" fetch -q --depth 1 "$TG_URL" "$TG_SHA" && git -C "$UPSTREAM_TG" checkout -q FETCH_HEAD
-            CONVERTED="${{ runner.temp }}/big_driving_tinygrad_plain.pkl"
-            env DEV=USB+AMD PYTHONPATH="$UPSTREAM_TG:${{ github.workspace }}" taskset -c 7 python3 openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py \
-              "${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl" "$CONVERTED"
-            mv "$CONVERTED" "$OUTPUT_PKL"
-          elif NEW_ARCH_ONNX=$(find "${{ env.MODELS_DIR }}" -maxdepth 1 -name "${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}*driving*.onnx" -print -quit) &&
-               [ -n "$NEW_ARCH_ONNX" ] && grep -qa new_img "$NEW_ARCH_ONNX"; then # the new architecture: one ONNX taking the warped frames as new_img
-            echo "Compiling new architecture ONNX: $NEW_ARCH_ONNX"
-            env ${TG_FLAGS} taskset -c 7 python3 openpilot/sunnypilot/modeld_v2/compile_modeld_v2.py \
-              "$NEW_ARCH_ONNX" "$OUTPUT_PKL" --device-input "*" --benchmark-runs 1
-          else
-            echo "Detected onnx architecture. Routing to native compile_modeld.py."
-            # Detect model type and build compile args
-            VISION_ONNX=""
-            for f in "${{ env.MODELS_DIR }}/driving_vision.onnx" "${{ env.MODELS_DIR }}/big_driving_vision.onnx"; do
-              [ -f "$f" ] && VISION_ONNX="$f" && break
-            done
+          # Detect model type and build compile args
+          VISION_ONNX=""
+          for f in "${{ env.MODELS_DIR }}/driving_vision.onnx" "${{ env.MODELS_DIR }}/big_driving_vision.onnx"; do
+            [ -f "$f" ] && VISION_ONNX="$f" && break
+          done
 
-            POLICY_ONNX=""
-            for f in "${{ env.MODELS_DIR }}/driving_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_policy.onnx"; do
-              [ -f "$f" ] && POLICY_ONNX="$f" && break
-            done
+          POLICY_ONNX=""
+          for f in "${{ env.MODELS_DIR }}/driving_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_policy.onnx"; do
+            [ -f "$f" ] && POLICY_ONNX="$f" && break
+          done
 
-            OFF_POLICY_ONNX=""
-            for f in "${{ env.MODELS_DIR }}/driving_off_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_off_policy.onnx"; do
-              [ -f "$f" ] && OFF_POLICY_ONNX="$f" && break
-            done
+          OFF_POLICY_ONNX=""
+          for f in "${{ env.MODELS_DIR }}/driving_off_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_off_policy.onnx"; do
+            [ -f "$f" ] && OFF_POLICY_ONNX="$f" && break
+          done
 
-            ON_POLICY_ONNX=""
-            for f in "${{ env.MODELS_DIR }}/driving_on_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_on_policy.onnx"; do
-              [ -f "$f" ] && ON_POLICY_ONNX="$f" && break
-            done
+          ON_POLICY_ONNX=""
+          for f in "${{ env.MODELS_DIR }}/driving_on_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_on_policy.onnx"; do
+            [ -f "$f" ] && ON_POLICY_ONNX="$f" && break
+          done
 
-            SUPERCOMBO_ONNX=""
-            for f in "${{ env.MODELS_DIR }}/supercombo.onnx" "${{ env.MODELS_DIR }}/driving_supercombo.onnx" "${{ env.MODELS_DIR }}/big_supercombo.onnx" "${{ env.MODELS_DIR }}/big_driving_supercombo.onnx"; do
-              [ -f "$f" ] && SUPERCOMBO_ONNX="$f" && break
-            done
+          SUPERCOMBO_ONNX=""
+          for f in "${{ env.MODELS_DIR }}/supercombo.onnx" "${{ env.MODELS_DIR }}/driving_supercombo.onnx" "${{ env.MODELS_DIR }}/big_supercombo.onnx" "${{ env.MODELS_DIR }}/big_driving_supercombo.onnx"; do
+            [ -f "$f" ] && SUPERCOMBO_ONNX="$f" && break
+          done
 
-            MODEL_TYPE="" ONNX_ARGS="" OUTPUT_NAME=""
-            if [ -f "$VISION_ONNX" ]; then
-              ONNX_ARGS="--vision-onnx $VISION_ONNX"
-              if [ -f "$ON_POLICY_ONNX" ] && [ -f "$OFF_POLICY_ONNX" ]; then
-                MODEL_TYPE=vision_multi_policy
-                ONNX_ARGS="$ONNX_ARGS --off-policy-onnx $OFF_POLICY_ONNX --on-policy-onnx $ON_POLICY_ONNX"
-              elif [ -f "$OFF_POLICY_ONNX" ] && [ -f "$POLICY_ONNX" ]; then
-                MODEL_TYPE=vision_multi_policy
-                ONNX_ARGS="$ONNX_ARGS --policy-onnx $POLICY_ONNX --off-policy-onnx $OFF_POLICY_ONNX"
-              elif [ -f "$POLICY_ONNX" ]; then
-                MODEL_TYPE=vision_policy
-                ONNX_ARGS="$ONNX_ARGS --policy-onnx $POLICY_ONNX"
-              fi
-            elif [ -f "$SUPERCOMBO_ONNX" ]; then
-              MODEL_TYPE=supercombo
-              ONNX_ARGS="--supercombo-onnx $SUPERCOMBO_ONNX"
+          MODEL_TYPE="" ONNX_ARGS="" OUTPUT_NAME=""
+          if [ -f "$VISION_ONNX" ]; then
+            ONNX_ARGS="--vision-onnx $VISION_ONNX"
+            if [ -f "$ON_POLICY_ONNX" ] && [ -f "$OFF_POLICY_ONNX" ]; then
+              MODEL_TYPE=vision_multi_policy
+              ONNX_ARGS="$ONNX_ARGS --off-policy-onnx $OFF_POLICY_ONNX --on-policy-onnx $ON_POLICY_ONNX"
+            elif [ -f "$OFF_POLICY_ONNX" ] && [ -f "$POLICY_ONNX" ]; then
+              MODEL_TYPE=vision_multi_policy
+              ONNX_ARGS="$ONNX_ARGS --policy-onnx $POLICY_ONNX --off-policy-onnx $OFF_POLICY_ONNX"
+            elif [ -f "$POLICY_ONNX" ]; then
+              MODEL_TYPE=vision_policy
+              ONNX_ARGS="$ONNX_ARGS --policy-onnx $POLICY_ONNX"
             fi
+          elif [ -f "$SUPERCOMBO_ONNX" ]; then
+            MODEL_TYPE=supercombo
+            ONNX_ARGS="--supercombo-onnx $SUPERCOMBO_ONNX"
+          fi
 
-            if [ -n "$MODEL_TYPE" ]; then
-              echo "Detected: $MODEL_TYPE -> $OUTPUT_PKL"
-              env ${TG_FLAGS} taskset -c 7 python3 "$COMPILE_MODELD" \
-                --model-type $MODEL_TYPE \
-                --model-size $MODEL_SIZE \
-                --camera-resolutions $CAMERA_RES \
-                $ONNX_ARGS \
-                --output "$OUTPUT_PKL"
-            fi
+          if [ -n "$MODEL_TYPE" ]; then
+            echo "Detected: $MODEL_TYPE -> $OUTPUT_PKL"
+            env ${TG_FLAGS} python3 "$COMPILE_MODELD" \
+              --model-type $MODEL_TYPE \
+              --model-size $MODEL_SIZE \
+              --camera-resolutions $CAMERA_RES \
+              $ONNX_ARGS \
+              --output "$OUTPUT_PKL"
           fi
 
       - name: Prepare Output
@@ -301,7 +264,8 @@ jobs:
           # Copy the model files
           rsync -avm \
             --include='*.dlc' \
-            --include='/${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}driving_tinygrad.pkl' \
+            --include='*.chunk*' \
+            --include='*.chunkmanifest' \
             --exclude='*' \
             --delete-excluded \
             --chown=comma:comma \
@@ -312,7 +276,6 @@ jobs:
             --output-dir "${{ env.OUTPUT_DIR }}" \
             --custom-name "${{ env.MODEL_NAME }}" \
             --upstream-branch "${{ inputs.upstream_branch }}" \
-            $([ -f "${{ env.MODELS_DIR }}/upstream_pkl.txt" ] && echo "--onnx-sha256 $(cut -d' ' -f3 "${{ env.MODELS_DIR }}/upstream_pkl.txt")") \
             ${{ inputs.is_20hz && '--is-20hz' || '' }}
 
       - name: Write artifact name to file
@@ -324,7 +287,6 @@ jobs:
         with:
           name: model-${{ env.MODEL_NAME }}${{ inputs.artifact_suffix }}-${{ github.run_number }}
           path: ${{ env.OUTPUT_DIR }}
-          compression-level: 0
 
       - name: Upload artifact name file
         uses: actions/upload-artifact@v4

.github/workflows/sunnypilot-build-prebuilt.yaml

@@ -170,9 +170,6 @@ jobs:
           scons -j1 cache_dir="$SCONS_CACHE" --minimal \
             openpilot/selfdrive/locationd openpilot/sunnypilot/selfdrive/locationd
           echo "Building rest of sunnypilot"
-          sudo rm -rf /tmp/* || true
-          mkdir -p "$BUILD_DIR/tmp"
-          export TMPDIR="$BUILD_DIR/tmp"
           SKIP_TINYGRAD_COMPILE=1 /usr/bin/time -v scons -j$(nproc) cache_dir="$SCONS_CACHE" --minimal
           touch ${BUILD_DIR}/prebuilt
           if [[ "${{ runner.debug }}" == "1" ]]; then
@@ -224,40 +221,37 @@ jobs:
       cancel-in-progress: false
     outputs:
       onnx_sha256: ${{ steps.resolve.outputs.onnx_sha256 }}
-      tinygrad_ref: ${{ steps.resolve.outputs.tinygrad_ref }}
     env:
       GH_REPO: ${{ github.repository }}
       HF_REPO: sunnypilot/sunnypilot_models_v1
       HF_DEFAULTS_PATH: models/defaults/big
     steps:
-      - name: Resolve tinygrad ref via API
+      - name: Resolve ONNX hash and tinygrad ref via API
         id: resolve
         run: |
           REF="${{ github.head_ref || github.ref_name }}"
 
-          BLOB_SHA=$(gh api "repos/${GH_REPO}/contents/openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl?ref=${REF}" --jq '.sha')
-          [ -n "$BLOB_SHA" ] || { echo "::error::Failed to resolve big_driving_tinygrad.pkl blob SHA"; exit 1; }
+          BLOB_SHA=$(gh api "repos/${GH_REPO}/contents/openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx?ref=${REF}" --jq '.sha')
           ONNX_HASH=$(gh api "repos/${GH_REPO}/git/blobs/${BLOB_SHA}" --jq '.content' | base64 -d | grep '^oid sha256:' | cut -d: -f2)
-          echo "big PKL hash: $ONNX_HASH"
-          [ -n "$ONNX_HASH" ] || { echo "::error::Failed to extract big PKL hash"; exit 1; }
-          echo "onnx_sha256=$ONNX_HASH" >> "$GITHUB_OUTPUT"
+          echo "ONNX hash: $ONNX_HASH"
+          [ -n "$ONNX_HASH" ] || { echo "::error::Failed to extract ONNX hash"; exit 1; }
+          echo "onnx_sha256=$ONNX_HASH" >> $GITHUB_OUTPUT
 
           TINYGRAD_REF=$(gh api "repos/${GH_REPO}/contents/tinygrad_repo?ref=${REF}" --jq '.sha')
           echo "tinygrad ref: $TINYGRAD_REF"
-          echo "tinygrad_ref=$TINYGRAD_REF" >> "$GITHUB_OUTPUT"
 
           JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
 
           check_defaults() {
             DEFAULTS=$(curl -fsSL "${JSON_URL}?t=$(date +%s)" 2>/dev/null) || return 1
-            BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" --arg ref "$TINYGRAD_REF" '
-              . as $root | [.bundles[] | select(.onnx_sha256 == $hash and (.tinygrad_ref == $ref or (.tinygrad_ref == null and $root.tinygrad_ref == $ref)))] | .[0] // empty
-            ' 2>/dev/null)
+            TINYGRAD_MATCH=$(echo "$DEFAULTS" | jq -r --arg ref "$TINYGRAD_REF" '.tinygrad_ref == $ref' 2>/dev/null)
+            [ "$TINYGRAD_MATCH" = "true" ] || return 1
+            BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" '.bundles[] | select(.onnx_sha256 == $hash)' 2>/dev/null)
             [ -n "$BUNDLE" ] && [ "$BUNDLE" != "null" ]
           }
 
           if check_defaults; then
-            echo "HF defaults match repo tinygrad ref"
+            echo "HF defaults match repo ONNX hash and tinygrad ref"
             exit 0
           fi
 
@@ -310,13 +304,12 @@ jobs:
       cancel-in-progress: false
     outputs:
       driving_onnx_sha256: ${{ steps.resolve.outputs.driving_onnx_sha256 }}
-      tinygrad_ref: ${{ steps.resolve.outputs.tinygrad_ref }}
     env:
       GH_REPO: ${{ github.repository }}
       HF_REPO: sunnypilot/sunnypilot_models_v1
       HF_DEFAULTS_PATH: models/defaults/small
     steps:
-      - name: Resolve tinygrad ref via API
+      - name: Resolve ONNX hash and tinygrad ref via API
         id: resolve
         run: |
           REF="${{ github.head_ref || github.ref_name }}"
@@ -325,24 +318,23 @@ jobs:
           DRIVING_HASH=$(gh api "repos/${GH_REPO}/git/blobs/${BLOB_SHA}" --jq '.content' | base64 -d | grep '^oid sha256:' | cut -d: -f2)
           echo "Driving ONNX hash: $DRIVING_HASH"
           [ -n "$DRIVING_HASH" ] || { echo "::error::Failed to extract driving ONNX hash"; exit 1; }
-          echo "driving_onnx_sha256=$DRIVING_HASH" >> "$GITHUB_OUTPUT"
+          echo "driving_onnx_sha256=$DRIVING_HASH" >> $GITHUB_OUTPUT
 
           TINYGRAD_REF=$(gh api "repos/${GH_REPO}/contents/tinygrad_repo?ref=${REF}" --jq '.sha')
           echo "tinygrad ref: $TINYGRAD_REF"
-          echo "tinygrad_ref=$TINYGRAD_REF" >> "$GITHUB_OUTPUT"
 
           JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
 
           check_defaults() {
             DEFAULTS=$(curl -fsSL "${JSON_URL}?t=$(date +%s)" 2>/dev/null) || return 1
-            DRIVING=$(echo "$DEFAULTS" | jq --arg hash "$DRIVING_HASH" --arg ref "$TINYGRAD_REF" '
-              . as $root | [.bundles[] | select(.onnx_sha256 == $hash and (.tinygrad_ref == $ref or (.tinygrad_ref == null and $root.tinygrad_ref == $ref)))] | .[0] // empty
-            ' 2>/dev/null)
-            [ -n "$DRIVING" ] && [ "$DRIVING" != "null" ]
+            TINYGRAD_MATCH=$(echo "$DEFAULTS" | jq -r --arg ref "$TINYGRAD_REF" '.tinygrad_ref == $ref' 2>/dev/null)
+            [ "$TINYGRAD_MATCH" = "true" ] || return 1
+            DRIVING=$(echo "$DEFAULTS" | jq --arg hash "$DRIVING_HASH" '.bundles[] | select(.onnx_sha256 == $hash)' 2>/dev/null)
+            [ -n "$DRIVING" ] && [ "$DRIVING" != "null" ] || return 1
           }
 
           if check_defaults; then
-            echo "HF defaults match repo tinygrad ref"
+            echo "HF defaults match repo ONNX hash and tinygrad ref"
             exit 0
           fi
 
@@ -395,13 +387,12 @@ jobs:
       cancel-in-progress: false
     outputs:
       dm_onnx_sha256: ${{ steps.resolve.outputs.dm_onnx_sha256 }}
-      tinygrad_ref: ${{ steps.resolve.outputs.tinygrad_ref }}
     env:
       GH_REPO: ${{ github.repository }}
       HF_REPO: sunnypilot/sunnypilot_models_v1
       HF_DEFAULTS_PATH: models/defaults/dm
     steps:
-      - name: Resolve tinygrad ref via API
+      - name: Resolve ONNX hash and tinygrad ref via API
         id: resolve
         run: |
           REF="${{ github.head_ref || github.ref_name }}"
@@ -410,24 +401,23 @@ jobs:
           DM_HASH=$(gh api "repos/${GH_REPO}/git/blobs/${BLOB_SHA}" --jq '.content' | base64 -d | grep '^oid sha256:' | cut -d: -f2)
           echo "DM ONNX hash: $DM_HASH"
           [ -n "$DM_HASH" ] || { echo "::error::Failed to extract DM ONNX hash"; exit 1; }
-          echo "dm_onnx_sha256=$DM_HASH" >> "$GITHUB_OUTPUT"
+          echo "dm_onnx_sha256=$DM_HASH" >> $GITHUB_OUTPUT
 
           TINYGRAD_REF=$(gh api "repos/${GH_REPO}/contents/tinygrad_repo?ref=${REF}" --jq '.sha')
           echo "tinygrad ref: $TINYGRAD_REF"
-          echo "tinygrad_ref=$TINYGRAD_REF" >> "$GITHUB_OUTPUT"
 
           JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
 
           check_defaults() {
             DEFAULTS=$(curl -fsSL "${JSON_URL}?t=$(date +%s)" 2>/dev/null) || return 1
-            DM=$(echo "$DEFAULTS" | jq --arg hash "$DM_HASH" --arg ref "$TINYGRAD_REF" '
-              . as $root | [.bundles[] | select(.onnx_sha256 == $hash and (.tinygrad_ref == $ref or (.tinygrad_ref == null and $root.tinygrad_ref == $ref)))] | .[0] // empty
-            ' 2>/dev/null)
-            [ -n "$DM" ] && [ "$DM" != "null" ]
+            TINYGRAD_MATCH=$(echo "$DEFAULTS" | jq -r --arg ref "$TINYGRAD_REF" '.tinygrad_ref == $ref' 2>/dev/null)
+            [ "$TINYGRAD_MATCH" = "true" ] || return 1
+            DM=$(echo "$DEFAULTS" | jq --arg hash "$DM_HASH" '.bundles[] | select(.onnx_sha256 == $hash)' 2>/dev/null)
+            [ -n "$DM" ] && [ "$DM" != "null" ] || return 1
           }
 
           if check_defaults; then
-            echo "HF defaults match DM tinygrad ref"
+            echo "HF defaults match DM ONNX hash and tinygrad ref"
             exit 0
           fi
 
@@ -503,12 +493,11 @@ jobs:
           mkdir -p ${{ env.OUTPUT_DIR }}
           tar xzf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }}
 
-      - name: Download models from HF
-        uses: ./.github/workflows/download-hf-model
+      - name: Download model chunks from HF
+        uses: ./.github/workflows/download-hf-model-chunks
         with:
           hf_repo: sunnypilot/sunnypilot_models_v1
           dest_dir: ${{ env.OUTPUT_DIR }}/openpilot/selfdrive/modeld/models
-          tinygrad_ref: ${{ needs.prepare_dm_model.outputs.tinygrad_ref }}
           models: |
             [
               {"hf_path": "models/defaults/small", "onnx_hash": "${{ needs.prepare_small_model.outputs.driving_onnx_sha256 }}", "canonical": "driving_tinygrad.pkl"},
@@ -573,12 +562,11 @@ jobs:
           mkdir -p ${{ env.OUTPUT_DIR }}
           tar xzf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }}
 
-      - name: Download models from HF
-        uses: ./.github/workflows/download-hf-model
+      - name: Download model chunks from HF
+        uses: ./.github/workflows/download-hf-model-chunks
         with:
           hf_repo: sunnypilot/sunnypilot_models_v1
           dest_dir: ${{ env.OUTPUT_DIR }}/openpilot/selfdrive/modeld/models
-          tinygrad_ref: ${{ needs.prepare_dm_model.outputs.tinygrad_ref }}
           models: |
             [
               {"hf_path": "models/defaults/small", "onnx_hash": "${{ needs.prepare_small_model.outputs.driving_onnx_sha256 }}", "canonical": "driving_tinygrad.pkl"},

.github/workflows/test-discourse.yaml.yml

@@ -0,0 +1,78 @@
+name: Debug Discourse Posting
+
+on:
+  push:
+
+jobs:
+  test-discourse-post:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Post test message to Discourse
+        uses: ./.github/workflows/post-to-discourse
+        with:
+          discourse-url: ${{ vars.DISCOURSE_URL }}
+          api-key: ${{ secrets.DISCOURSE_API_KEY }}
+          api-username: ${{ secrets.DISCOURSE_API_USERNAME }}
+          topic-id: ${{ vars.DISCOURSE_UPDATES_TOPIC_ID }}
+          message: |
+            ## 🧪 Test Post from GitHub Actions
+            
+            **This is a test post to verify Discourse integration**
+            
+            - **Workflow**: ${{ github.workflow }}
+            - **Run Number**: #${{ github.run_number }}
+            - **Branch**: `${{ github.ref_name }}`
+            - **Commit**: ${{ github.sha }}
+            - **Actor**: @${{ github.actor }}
+            - **Timestamp**: ${{ github.event.head_commit.timestamp }}
+            
+            ---
+            
+            ### Fake Build Info (for testing)
+            - **Version**: 0.9.8-test
+            - **Build**: #42
+            - **Branch**: release-test
+            
+            [View workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
+            
+            *This is an automated test message. Drive safe! 🚗💨*
+      
+      
+      - name: Create topic on Discourse
+        uses: ./.github/workflows/post-to-discourse
+        with:
+          discourse-url: ${{ vars.DISCOURSE_URL }}
+          api-key: ${{ secrets.DISCOURSE_API_KEY }}
+          api-username: ${{ secrets.DISCOURSE_API_USERNAME }}
+          #topic-id: ${{ vars.DISCOURSE_UPDATES_TOPIC_ID }}
+          category-id: 4
+          title: "This is a test of a new topic instead of a reply"
+          message: |
+            ## 🧪 Test Post from GitHub Actions
+            
+            **This is a test post to verify Discourse integration**
+            
+            - **Workflow**: ${{ github.workflow }}
+            - **Run Number**: #${{ github.run_number }}
+            - **Branch**: `${{ github.ref_name }}`
+            - **Commit**: ${{ github.sha }}
+            - **Actor**: @${{ github.actor }}
+            - **Timestamp**: ${{ github.event.head_commit.timestamp }}
+            
+            ---
+            
+            ### Fake Build Info (for testing)
+            - **Version**: 0.9.8-test
+            - **Build**: #42
+            - **Branch**: release-test
+            
+            [View workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
+            
+            *This is an automated test message. Drive safe! 🚗💨*
+      - name: Display results
+        if: always()
+        run: |
+          echo "::notice::Discourse post test completed"
+          echo "Check your Discourse topic to verify the post appeared correctly"

.github/workflows/test_models.yml

@@ -1,69 +0,0 @@
-name: Test Models Compatibility With Tinygrad Changes
-on:
-  pull_request:
-    paths:
-      - 'tinygrad_repo'
-  workflow_dispatch:
-
-jobs:
-  generate-matrix:
-    runs-on: ubuntu-latest
-    outputs:
-      models: ${{ steps.set-matrix.outputs.models }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Fetch and Parse json
-        id: set-matrix
-        run: |
-          python3 -c '
-          import json, urllib.request, os, re
-
-          with open("openpilot/sunnypilot/models/fetcher.py", "r") as f:
-            urls = re.findall(r"MODEL_URL(?:_CHESTNUT)?\s*=\s*[\"'"'"']([^\"'"'"']+)[\"'"'"']", f.read())
-
-          artifacts = []
-          for url in urls:
-            data = json.loads(urllib.request.urlopen(url).read())
-            for bundle in data.get("bundles", []):
-              for model in bundle.get("models", []):
-                if "artifact" in model:
-                  artifacts.append(model["artifact"])
-
-          with open(os.environ["GITHUB_OUTPUT"], "a") as f:
-            f.write(f"models={json.dumps(artifacts)}\n")
-          '
-
-  test-model:
-    name: Test ${{ matrix.artifact.file_name }}
-    needs: generate-matrix
-    runs-on: ubuntu-latest
-    container: ghcr.io/commaai/openpilot-base:latest
-    strategy:
-      fail-fast: false
-      matrix:
-        artifact: ${{ fromJson(needs.generate-matrix.outputs.models) }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-
-      - name: Download model
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          MODEL_URL: ${{ matrix.artifact.download_uri.url }}
-          MODEL_FILE: ${{ matrix.artifact.file_name }}
-        shell: bash
-        run: |
-          mkdir -p /tmp/models
-          AUTH=()
-          if [ -n "$HF_TOKEN" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi
-          curl --retry 3 --retry-all-errors -s -S -f -L "${AUTH[@]}" -o "/tmp/models/$MODEL_FILE" "$MODEL_URL"
-
-      - name: Run Model Compatibility Test
-        env:
-          MODEL_BASE_NAME: ${{ matrix.artifact.file_name }}
-          MODEL_DIR: "/tmp/models"
-        run: |
-          export PYTHONPATH="$GITHUB_WORKSPACE/tinygrad_repo:$GITHUB_WORKSPACE:$PYTHONPATH"
-          python3 -m pip uninstall -y tinygrad || uv pip uninstall -y tinygrad --system || true
-          python3 -m pytest openpilot/sunnypilot/modeld_v2/tests/test_models.py

.github/workflows/tests.yaml

@@ -22,7 +22,7 @@ env:
   PYTHONPATH: ${{ github.workspace }}
   GIT_CONFIG_COUNT: 1
   GIT_CONFIG_KEY_0: lfs.fetchexclude
-  GIT_CONFIG_VALUE_0: openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl
+  GIT_CONFIG_VALUE_0: openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx
 
 jobs:
   build_release:

.gitignore

@@ -50,8 +50,6 @@ st[0-9A-Za-z][0-9A-Za-z][0-9A-Za-z][0-9A-Za-z][0-9A-Za-z][0-9A-Za-z]
 *.stats
 *.pkl
 *.pkl*
-!openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl
-!openpilot/sunnypilot/modeld_v2/models/*.pkl
 config.json
 compile_commands.json
 compare_runtime*.html

.gitmodules

@@ -19,4 +19,3 @@
 [submodule "sunnypilot/neural_network_data"]
 	path = openpilot/sunnypilot/neural_network_data
   url = https://github.com/sunnypilot/neural-network-data.git
-

.lfsconfig

@@ -1,5 +1,4 @@
 [lfs]
-	url = https://huggingface.co/sunnypilot/sunnypilot-lfs.git/info/lfs
-	pushurl = https://huggingface.co/sunnypilot/sunnypilot-lfs.git/info/lfs
-
+	url = https://gitlab.com/sunnypilot/public/sunnypilot-new-lfs.git/info/lfs
+	pushurl = ssh://git@gitlab.com/sunnypilot/public/sunnypilot-new-lfs.git
 	locksverify = false

Jenkinsfile

@@ -12,17 +12,16 @@ def retryWithDelay(int maxRetries, int delay, Closure body) {
 def device(String ip, String step_label, String cmd) {
   withCredentials([file(credentialsId: 'id_rsa', variable: 'key_file')]) {
     def ssh_cmd = """
-ssh -o ControlMaster=no -o ControlPath=none -o ConnectTimeout=5 -o ServerAliveInterval=5 -o ServerAliveCountMax=12 -o BatchMode=yes -o StrictHostKeyChecking=no -i ${key_file} 'comma@${ip}' exec setpriv --pdeathsig HUP /usr/bin/bash <<'END'
+ssh -o ControlMaster=auto -o ControlPath=/tmp/ssh_control_%C -o ControlPersist=yes -o ConnectTimeout=5 -o ServerAliveInterval=5 -o ServerAliveCountMax=2 -o BatchMode=yes -o StrictHostKeyChecking=no -i ${key_file} 'comma@${ip}' exec /usr/bin/bash <<'END'
 
 set -e
 
 export TERM=xterm-256color
 
-trap 'kill 0' HUP # stop this process group on SSH disconnect
+shopt -s huponexit # kill all child processes when the shell exits
 
 export CI=1
 export PYTHONWARNINGS=error
-export PYTHONFAULTHANDLER=1
 export COMMA_CACHE=/data/tmp/comma_download_cache
 #export LOGPRINT=debug # this has gotten too spammy...
 export TEST_DIR=${env.TEST_DIR}
@@ -70,8 +69,7 @@ export LD_LIBRARY_PATH="\$(python -c 'import ffmpeg; print(ffmpeg.LIB_DIR)'):/us
 ln -snf ${env.TEST_DIR} /data/pythonpath
 
 cd ${env.TEST_DIR} || true
-time ( ${cmd} ) &
-wait \$!
+time ${cmd}
 END"""
 
     sh script: ssh_cmd, label: step_label
@@ -171,7 +169,7 @@ node {
   env.GIT_BRANCH = checkout(scm).GIT_BRANCH
   env.GIT_COMMIT = checkout(scm).GIT_COMMIT
 
-  def excludeBranches = ['__nightly', '__nightly-chestnut', 'devel', 'devel-staging',
+  def excludeBranches = ['__nightly', 'devel', 'devel-staging',
                          'release-tizi', 'release-tizi-staging', 'release-mici', 'release-mici-staging', 'testing-closet*', 'hotfix-*']
   def excludeRegex = excludeBranches.join('|').replaceAll('\\*', '.*')
 
@@ -203,12 +201,6 @@ node {
       )
     }
 
-    if (env.BRANCH_NAME == '__nightly-chestnut') {
-      deviceStage("build nightly-chestnut", "mici-chestnut-ci", [], [
-        step("build nightly-chestnut", "SCONSFLAGS=-j4 INCLUDE_BIG_MODEL=1 PANDA_DEBUG_BUILD=1 RELEASE_BRANCH=nightly-chestnut $SOURCE_DIR/tools/release/build_release.sh TestChestnutOnroad"),
-      ])
-    }
-
     if (!env.BRANCH_NAME.matches(excludeRegex)) {
     parallel (
       'onroad tests': {
@@ -260,14 +252,6 @@ node {
           step("test amp", "./openpilot/common/hardware/comma/tests/test_amplifier.py"),
         ])
       },
-      'chestnut': {
-        deviceStage("chestnut", "mici-chestnut-ci", ["UNSAFE=1", "CHESTNUT=1"], [
-          step("build", "./openpilot/selfdrive/test/chestnut.sh"),
-          step("model replay", "openpilot/selfdrive/test/process_replay/model_replay.py --chestnut"),
-          step("onroad tests", "./openpilot/selfdrive/test/test_onroad.py TestChestnutOnroad", [timeout: 120]),
-          step("test power draw", "./openpilot/selfdrive/test/test_power_draw.py"),
-        ])
-      },
 
     )
     }

SConstruct

@@ -87,6 +87,7 @@ acados_include_dirs = [
 # vendored in commaai/dependencies.
 allowed_system_libs = {
   "EGL", "GLESv2", "GL",
+  "Qt5Charts", "Qt5Core", "Qt5Gui", "Qt5Widgets",
   "dl", "drm", "gbm", "m", "pthread",
 }
 
@@ -120,7 +121,6 @@ def _libflags(target, source, env, for_signature):
 env = Environment(
   ENV={
     "PATH": os.environ['PATH'],
-    "TMPDIR": os.environ.get('TMPDIR', '/tmp'),
     "PYTHONPATH": os.pathsep.join(submodule_python_paths),
     "ACADOS_SOURCE_DIR": acados.DIR,
     "ACADOS_PYTHON_INTERFACE_PATH": acados.TEMPLATE_DIR,
@@ -346,8 +346,6 @@ AddPostAction(BUILD_TARGETS or [Dir('.')], prune_cache_dir)
 def check_build_product_size(target, source, env):
   limit = 50 * 1024 * 1024  # GitHub max size
   for t in target:
-    if str(t).endswith('.pkl'):  # chunked during release packaging
-      continue
     if hasattr(t, 'isfile') and t.isfile() and (size := os.path.getsize(t.abspath)) > limit:
       raise SCons.Errors.UserError(f"{t} is {size / (1024 * 1024):.1f} MiB, exceeding the {limit / (1024 * 1024):.1f} MiB limit")
 if not GetOption('extras'):

docs/CARS.md

@@ -34,7 +34,7 @@ A supported vehicle is one that just works when you install a comma device. All
 |Chrysler|Pacifica Hybrid 2019-25|Adaptive Cruise Control (ACC)|Stock|0 mph|39 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 FCA connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Chrysler Pacifica Hybrid 2019-25">Buy Here</a></sub></details>|||
 |comma|body|All|openpilot|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|None|<a href="https://youtu.be/VT-i3yRsX2s?t=2736" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
 |CUPRA[<sup>12</sup>](#footnotes)|Ateca 2018-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=CUPRA Ateca 2018-23">Buy Here</a></sub></details>|||
-|CUPRA|Born 2021-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot[<sup>16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW MEB connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=CUPRA Born 2021-23">Buy Here</a></sub></details>|||
+|CUPRA[<sup>12</sup>](#footnotes)|Born 2021-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot[<sup>16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=CUPRA Born 2021-23">Buy Here</a></sub></details>|||
 |Dodge|Durango 2020-21|Adaptive Cruise Control (ACC)|Stock|0 mph|39 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 FCA connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Dodge Durango 2020-21">Buy Here</a></sub></details>|||
 |Ford|Bronco Sport 2021-24|Co-Pilot360 Assist+|openpilot|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Ford Q3 connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Ford Bronco Sport 2021-24">Buy Here</a></sub></details>|||
 |Ford|Escape 2020-22|Co-Pilot360 Assist+|openpilot|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Ford Q3 connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Ford Escape 2020-22">Buy Here</a></sub></details>|||
@@ -99,7 +99,7 @@ A supported vehicle is one that just works when you install a comma device. All
 |Honda|Fit 2018-20|Honda Sensing|openpilot|26 mph|12 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-empty.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Nidec connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Fit 2018-20">Buy Here</a></sub></details>|||
 |Honda|Freed 2020|Honda Sensing|openpilot|26 mph|12 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-empty.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Nidec connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Freed 2020">Buy Here</a></sub></details>|||
 |Honda|HR-V 2019-22|Honda Sensing|openpilot|26 mph|12 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-empty.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Nidec connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda HR-V 2019-22">Buy Here</a></sub></details>|||
-|Honda|HR-V 2023-27|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch B connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda HR-V 2023-27">Buy Here</a></sub></details>|||
+|Honda|HR-V 2023-25|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch B connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda HR-V 2023-25">Buy Here</a></sub></details>|||
 |Honda|Insight 2019-22|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|3 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch A connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Insight 2019-22">Buy Here</a></sub></details>|||
 |Honda|Inspire 2018|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|3 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch A connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Inspire 2018">Buy Here</a></sub></details>|||
 |Honda|N-Box 2018|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|11 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch A connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda N-Box 2018">Buy Here</a></sub></details>|||
@@ -268,8 +268,8 @@ A supported vehicle is one that just works when you install a comma device. All
 |Škoda[<sup>12</sup>](#footnotes)|Superb 2015-22[<sup>15</sup>](#footnotes)|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Škoda Superb 2015-22">Buy Here</a></sub></details>|||
 |Tesla[<sup>10</sup>](#footnotes)|Model 3 (with HW3) 2019-23[<sup>9</sup>](#footnotes)|All|openpilot available[<sup>1</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Tesla A connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Tesla Model 3 (with HW3) 2019-23">Buy Here</a></sub></details>|||
 |Tesla[<sup>10</sup>](#footnotes)|Model 3 (with HW4) 2024-25[<sup>9</sup>](#footnotes)|All|openpilot available[<sup>1</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Tesla B connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Tesla Model 3 (with HW4) 2024-25">Buy Here</a></sub></details>|||
-|Tesla[<sup>10</sup>](#footnotes)|Model Y (with HW3) 2020-24[<sup>9</sup>](#footnotes)|All|openpilot available[<sup>1</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Tesla A connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Tesla Model Y (with HW3) 2020-24">Buy Here</a></sub></details>|||
-|Tesla[<sup>10</sup>](#footnotes)|Model Y (with HW4) 2023-25[<sup>9</sup>](#footnotes)|All|openpilot available[<sup>1</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Tesla B connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Tesla Model Y (with HW4) 2023-25">Buy Here</a></sub></details>|||
+|Tesla[<sup>10</sup>](#footnotes)|Model Y (with HW3) 2020-23[<sup>9</sup>](#footnotes)|All|openpilot available[<sup>1</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Tesla A connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Tesla Model Y (with HW3) 2020-23">Buy Here</a></sub></details>|||
+|Tesla[<sup>10</sup>](#footnotes)|Model Y (with HW4) 2024-25[<sup>9</sup>](#footnotes)|All|openpilot available[<sup>1</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Tesla B connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Tesla Model Y (with HW4) 2024-25">Buy Here</a></sub></details>|||
 |Toyota|Alphard 2019-20|All|openpilot|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Toyota A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Toyota Alphard 2019-20">Buy Here</a></sub></details>|||
 |Toyota|Alphard Hybrid 2021|All|openpilot|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Toyota A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Toyota Alphard Hybrid 2021">Buy Here</a></sub></details>|||
 |Toyota|Avalon 2016|Toyota Safety Sense P|Stock|19 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-empty.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Toyota A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Toyota Avalon 2016">Buy Here</a></sub></details>|||
@@ -335,8 +335,8 @@ A supported vehicle is one that just works when you install a comma device. All
 |Volkswagen[<sup>12</sup>](#footnotes)|Golf R 2015-19|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Golf R 2015-19">Buy Here</a></sub></details>|||
 |Volkswagen[<sup>12</sup>](#footnotes)|Golf SportsVan 2015-20|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Golf SportsVan 2015-20">Buy Here</a></sub></details>|||
 |Volkswagen[<sup>12</sup>](#footnotes)|Grand California 2019-24|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|31 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Grand California 2019-24">Buy Here</a></sub></details>|<a href="https://youtu.be/4100gLeabmo" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
-|Volkswagen|ID.4 2021-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot[<sup>16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW MEB connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen ID.4 2021-23">Buy Here</a></sub></details>|||
-|Volkswagen|ID.4 2024-25|Adaptive Cruise Control (ACC) & Lane Assist|openpilot[<sup>16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW MEB connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen ID.4 2024-25">Buy Here</a></sub></details>|||
+|Volkswagen[<sup>12</sup>](#footnotes)|ID.4 2021-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot[<sup>16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen ID.4 2021-23">Buy Here</a></sub></details>|||
+|Volkswagen[<sup>12</sup>](#footnotes)|ID.4 2024-25|Adaptive Cruise Control (ACC) & Lane Assist|openpilot[<sup>16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen ID.4 2024-25">Buy Here</a></sub></details>|||
 |Volkswagen[<sup>12</sup>](#footnotes)|Jetta 2019-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Jetta 2019-23">Buy Here</a></sub></details>|||
 |Volkswagen[<sup>12</sup>](#footnotes)|Jetta GLI 2021-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Jetta GLI 2021-23">Buy Here</a></sub></details>|||
 |Volkswagen|Passat 2015-22[<sup>14</sup>](#footnotes)|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Passat 2015-22">Buy Here</a></sub></details>|||
@@ -363,7 +363,7 @@ A supported vehicle is one that just works when you install a comma device. All
 <sup>6</sup>See more setup details for <a href="https://github.com/commaai/openpilot/wiki/nissan" target="_blank">Nissan</a>. <br />
 <sup>7</sup>In the non-US market, openpilot requires the car to come equipped with EyeSight with Lane Keep Assistance. <br />
 <sup>8</sup>Enabling longitudinal control (alpha) will disable all EyeSight functionality, including AEB, LDW, and RAB. <br />
-<sup>9</sup>Model years 2023 and 2024 can have either hardware type, depending on build date and factory. To check which hardware type your vehicle has, look for <b>Autopilot computer</b> under <b>Software -> Additional Vehicle Information</b> on your vehicle's touchscreen. See <a href="https://www.notateslaapp.com/news/2173/how-to-check-if-your-tesla-has-hardware-4-ai4-or-hardware-3">this page</a> for more information. <br />
+<sup>9</sup>Some 2023 model years have HW4. To check which hardware type your vehicle has, look for <b>Autopilot computer</b> under <b>Software -> Additional Vehicle Information</b> on your vehicle's touchscreen. See <a href="https://www.notateslaapp.com/news/2173/how-to-check-if-your-tesla-has-hardware-4-ai4-or-hardware-3">this page</a> for more information. <br />
 <sup>10</sup>See more setup details for <a href="https://github.com/commaai/openpilot/wiki/tesla" target="_blank">Tesla</a>. <br />
 <sup>11</sup>openpilot operates above 28mph for Camry 4CYL L, 4CYL LE and 4CYL SE which don't have Full-Speed Range Dynamic Radar Cruise Control. <br />
 <sup>12</sup>The J533 harness plugs in at the CAN gateway under the dashboard, just above the steering column. More information can be found at <a href="https://docs.howtocomma.com/docs/j533-harness-install" target="_blank">this guide</a>. <br />

docs/README.md

@@ -5,10 +5,10 @@ The site is updated on pushes to master by this [workflow](../.github/workflows/
 
 **1. Build the site**
 ``` bash
-op docs --build
+python docs/serve.py --build
 ```
 
 **2. Run the site locally** (rebuilds on change)
 ``` bash
-op docs
+python docs/serve.py
 ```

launch_chffrplus.sh

@@ -18,21 +18,21 @@ function agnos_init {
   sudo chmod 660 /dev/adsprpc-smd /dev/ion /dev/kgsl-3d0
 
   # Check if AGNOS update is required
-  if [ "$(< /VERSION)" != "$AGNOS_VERSION" ]; then
+  if [ $(< /VERSION) != "$AGNOS_VERSION" ]; then
     AGNOS_PY="$DIR/openpilot/common/hardware/comma/agnos.py"
     MANIFEST="$DIR/openpilot/system/hardware/comma/agnos.json"
-    if "$AGNOS_PY" --verify "$MANIFEST"; then
+    if $AGNOS_PY --verify $MANIFEST; then
       sudo reboot
     fi
     while true; do
-      "$DIR/openpilot/common/hardware/comma/updater" "$AGNOS_PY" "$MANIFEST"
+      $DIR/openpilot/common/hardware/comma/updater $AGNOS_PY $MANIFEST
     done
   fi
 }
 
 function launch {
   # Remove orphaned git lock if it exists on boot
-  [ -f "$DIR/.git/index.lock" ] && rm -f "$DIR/.git/index.lock"
+  [ -f "$DIR/.git/index.lock" ] && rm -f $DIR/.git/index.lock
 
   # Check to see if there's a valid overlay-based update available. Conditions
   # are as follows:
@@ -44,7 +44,7 @@ function launch {
   #    that completed successfully and synced to disk.
 
   if [ -f "${DIR}/.overlay_init" ]; then
-    find "${DIR}/.git" -newer "${DIR}/.overlay_init" | grep -q '.' 2> /dev/null
+    find ${DIR}/.git -newer ${DIR}/.overlay_init | grep -q '.' 2> /dev/null
     if [ $? -eq 0 ]; then
       echo "${DIR} has been modified, skipping overlay update installation"
     else
@@ -53,9 +53,9 @@ function launch {
           echo "Valid overlay update found, installing"
           LAUNCHER_LOCATION="${BASH_SOURCE[0]}"
 
-          mv "$DIR" /data/safe_staging/old_openpilot
-          mv "${STAGING_ROOT}/finalized" "$DIR"
-          cd "$DIR"
+          mv $DIR /data/safe_staging/old_openpilot
+          mv "${STAGING_ROOT}/finalized" $DIR
+          cd $DIR
 
           echo "Restarting launch script ${LAUNCHER_LOCATION}"
           unset AGNOS_VERSION
@@ -69,7 +69,7 @@ function launch {
   fi
 
   # handle pythonpath
-  ln -sfn "$(pwd)" /data/pythonpath
+  ln -sfn $(pwd) /data/pythonpath
   export PYTHONPATH="$PWD"
 
   # submodule package symlinks for PYTHONPATH imports on device.
@@ -90,7 +90,7 @@ function launch {
 
   # start manager
   cd openpilot/system/manager
-  if [ ! -f "$DIR/prebuilt" ]; then
+  if [ ! -f $DIR/prebuilt ]; then
     ./build.py
   fi
   ./manager.py

openpilot/cereal/log.capnp

@@ -2594,7 +2594,6 @@ struct Event {
     clocks @35 :Clocks;
     deviceState @6 :DeviceState;
     chestnutState @152 :ChestnutState;
-    chestnutGpuState @153 :ChestnutState;
     logMessage @18 :Text;
     errorLogMessage @85 :Text;
 

openpilot/cereal/services.py

@@ -25,8 +25,7 @@ _services: dict[str, tuple] = {
   "accelerometer": (True, 104., 104),
   "temperatureSensor": (True, 2., 200),
   "deviceState": (True, 2., 1),
-  "chestnutState": (True, 10., 1),
-  "chestnutGpuState": (False, 10.),
+  "chestnutState": (True, 10., 10),
   "touch": (True, 20., 1),
   "can": (True, 100., 2053, QueueSize.BIG),  # decimation gives ~3 msgs in a full segment
   "controlsState": (True, 100., 10, QueueSize.MEDIUM),

openpilot/common/esim/base.py

@@ -21,13 +21,6 @@ class Profile:
   def is_comma(self) -> bool:
     return self.provider == 'Webbing' and self.iccid.startswith('8985235')
 
-  @property
-  def display_name(self) -> str:
-    if self.is_comma:
-      return "comma prime"
-    name = self.nickname or self.provider or "<unnamed>"
-    return f"{name} (...{self.iccid[-4:]})"
-
 
 class LPABase(ABC):
   @abstractmethod

openpilot/common/esim/lpa.py

@@ -613,7 +613,7 @@ def parse_lpa_activation_code(activation_code: str) -> tuple[str, str]:
   if not activation_code.startswith("LPA:"):
     raise ValueError("Invalid activation code format")
   parts = activation_code[4:].split("$")
-  if len(parts) != 3 or not all(parts):
+  if len(parts) != 3:
     raise ValueError("Invalid activation code format")
   return parts[1], parts[2]
 

openpilot/common/file_chunker.py

@@ -24,7 +24,6 @@ def chunk_file(path, targets):
   manifest_path, *chunk_paths = targets
   actual_num_chunks = max(1, math.ceil(os.path.getsize(path) / CHUNK_SIZE))
   assert len(chunk_paths) >= actual_num_chunks, f"Allowed {len(chunk_paths)} chunks but needs at least {actual_num_chunks}, for path {path}"
-  Path(manifest_path).unlink(missing_ok=True)
   with open(path, 'rb') as f:
     for chunk_path in chunk_paths:
       with open(chunk_path, 'wb') as out:
@@ -32,6 +31,14 @@ def chunk_file(path, targets):
   Path(manifest_path).write_text(str(len(chunk_paths)))
   os.remove(path)
 
+def get_existing_chunks(path):
+  if os.path.isfile(path):
+    return [path]
+  if os.path.isfile(manifest := get_manifest_path(path)):
+    num_chunks = int(Path(manifest).read_text().strip())
+    return _chunk_paths(path, num_chunks)
+  raise FileNotFoundError(path)
+
 class ChunkStream(io.RawIOBase):
   def __init__(self, paths):
     self._paths = iter(paths)
@@ -59,11 +66,11 @@ class ChunkStream(io.RawIOBase):
 
 def open_file_chunked(path):
   manifest_path = get_manifest_path(path)
-  if os.path.isfile(path):
-    paths = [path]
-  elif os.path.isfile(manifest_path):
+  if os.path.isfile(manifest_path):
     num_chunks = int(Path(manifest_path).read_text().strip())
     paths = [get_chunk_name(path, i, num_chunks) for i in range(num_chunks)]
+  elif os.path.isfile(path):
+    paths = [path]
   else:
     raise FileNotFoundError(path)
   return io.BufferedReader(ChunkStream(paths))

openpilot/common/hardware/base.py

@@ -145,9 +145,6 @@ class HardwareBase(ABC):
   def get_modem_temperatures(self):
     return []
 
-  def get_modem_state(self) -> dict:
-    return {}
-
   def initialize_hardware(self):
     pass
 

openpilot/common/hardware/comma/power_monitor.py

@@ -9,25 +9,22 @@ from openpilot.common.realtime import Ratekeeper
 from openpilot.common.filter_simple import FirstOrderFilter
 
 
-def read_power(panda=None):
-  if panda is not None and panda.get_type() == panda.HW_TYPE_CUATRO:
-    health = panda.health()
-    return health['voltage'] * health['current'] / 1e6
+def read_power():
   with open("/sys/bus/i2c/devices/0-0040/hwmon/hwmon1/power1_input") as f:
     return int(f.read()) / 1e6
 
-def sample_power(seconds=5, panda=None) -> list[float]:
+def sample_power(seconds=5) -> list[float]:
   rate = 123
   rk = Ratekeeper(rate, print_delay_threshold=None)
 
   pwrs = []
   for _ in range(rate*seconds):
-    pwrs.append(read_power(panda))
+    pwrs.append(read_power())
     rk.keep_time()
   return pwrs
 
-def get_power(seconds=5, panda=None):
-  pwrs = sample_power(seconds, panda)
+def get_power(seconds=5):
+  pwrs = sample_power(seconds)
   return np.mean(pwrs)
 
 def wait_for_power(min_pwr, max_pwr, min_secs_in_range, timeout):

openpilot/common/hardware/comma/updater

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6a7adb302d378dda7b1788a841b89e4f905c872550a70a76650dcde977b4ece0
-size 24709209
+oid sha256:3a94ab8395f20d20a9d5a2a2bacca0694f072df8421cf13adca6250d28065bdc
+size 24709205

openpilot/common/params_keys.h

@@ -28,7 +28,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ControlsReady", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, BOOL}},
     {"CurrentBootlog", {PERSISTENT, STRING}},
     {"CurrentRoute", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, STRING}},
-    {"DisableDriverCameraIR", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, BOOL}},
     {"DisableLogging", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, BOOL}},
     {"DisablePowerDown", {PERSISTENT | BACKUP, BOOL}},
     {"DisableUpdates", {PERSISTENT | BACKUP, BOOL, "0"}},
@@ -139,6 +138,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"UptimeOnroad", {PERSISTENT, FLOAT, "0.0"}},
     {"ChestnutActive", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION | CLEAR_ON_IGNITION_ON, BOOL}},
     {"ChestnutLoading", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION | CLEAR_ON_IGNITION_ON, BOOL}},
+    {"ChestnutModelError", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION | CLEAR_ON_IGNITION_ON, BOOL}},
     {"Version", {PERSISTENT, STRING}},
 
     // --- sunnypilot params --- //
@@ -227,6 +227,11 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"SunnylinkEnabled", {PERSISTENT, BOOL, "1"}},
     {"SunnylinkTempFault", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL, "0"}},
 
+    {"SunnylinkLocalApps", {PERSISTENT, JSON}},
+    {"SunnylinkLocalPairingCode", {CLEAR_ON_MANAGER_START, JSON}},
+    {"SunnylinkLocalDiscoveredApp", {CLEAR_ON_MANAGER_START, JSON}},
+    {"SunnylinkLocalPairingRequest", {CLEAR_ON_MANAGER_START, BOOL}},
+
     // Backup Manager params
     {"BackupManager_CreateBackup", {PERSISTENT, BOOL}},
     {"BackupManager_RestoreVersion", {PERSISTENT, STRING}},

openpilot/common/qrcode.py

@@ -1,47 +1,16 @@
-"""QR code encoding, decoding, and UI textures."""
-
-import functools
-import itertools
+"""Small QR encoder for the UI's byte-mode, error-correction-level-L codes."""
 
 import numpy as np
 import pyray as rl
 
 
-# (ec codewords per block, block count) for levels L, M, Q, H, versions 1-40
-_EC = [
-  ((7, 1), (10, 1), (13, 1), (17, 1)), ((10, 1), (16, 1), (22, 1), (28, 1)), ((15, 1), (26, 1), (18, 2), (22, 2)),
-  ((20, 1), (18, 2), (26, 2), (16, 4)), ((26, 1), (24, 2), (18, 4), (22, 4)), ((18, 2), (16, 4), (24, 4), (28, 4)),
-  ((20, 2), (18, 4), (18, 6), (26, 5)), ((24, 2), (22, 4), (22, 6), (26, 6)), ((30, 2), (22, 5), (20, 8), (24, 8)),
-  ((18, 4), (26, 5), (24, 8), (28, 8)), ((20, 4), (30, 5), (28, 8), (24, 11)), ((24, 4), (22, 8), (26, 10), (28, 11)),
-  ((26, 4), (22, 9), (24, 12), (22, 16)), ((30, 4), (24, 9), (20, 16), (24, 16)), ((22, 6), (24, 10), (30, 12), (24, 18)),
-  ((24, 6), (28, 10), (24, 17), (30, 16)), ((28, 6), (28, 11), (28, 16), (28, 19)), ((30, 6), (26, 13), (28, 18), (28, 21)),
-  ((28, 7), (26, 14), (26, 21), (26, 25)), ((28, 8), (26, 16), (30, 20), (28, 25)), ((28, 8), (26, 17), (28, 23), (30, 25)),
-  ((28, 9), (28, 17), (30, 23), (24, 34)), ((30, 9), (28, 18), (30, 25), (30, 30)), ((30, 10), (28, 20), (30, 27), (30, 32)),
-  ((26, 12), (28, 21), (30, 29), (30, 35)), ((28, 12), (28, 23), (28, 34), (30, 37)), ((30, 12), (28, 25), (30, 34), (30, 40)),
-  ((30, 13), (28, 26), (30, 35), (30, 42)), ((30, 14), (28, 28), (30, 38), (30, 45)), ((30, 15), (28, 29), (30, 40), (30, 48)),
-  ((30, 16), (28, 31), (30, 43), (30, 51)), ((30, 17), (28, 33), (30, 45), (30, 54)), ((30, 18), (28, 35), (30, 48), (30, 57)),
-  ((30, 19), (28, 37), (30, 51), (30, 60)), ((30, 19), (28, 38), (30, 53), (30, 63)), ((30, 20), (28, 40), (30, 56), (30, 66)),
-  ((30, 21), (28, 43), (30, 59), (30, 70)), ((30, 22), (28, 45), (30, 62), (30, 74)), ((30, 24), (28, 47), (30, 65), (30, 77)),
-  ((30, 25), (28, 49), (30, 68), (30, 81)),
-]
+# Indexes are QR versions. These are the only two Reed-Solomon parameters needed
+# for error-correction level L.
+_ECC_LEN = (0, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28)
+_NUM_BLOCKS = (0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8)
 
-# GF(256) with the QR polynomial x^8 + x^4 + x^3 + x^2 + 1: powers of alpha and their logs
-_EXP = [1]
-for _ in range(254):
-  _EXP.append(_EXP[-1] << 1 ^ (0x11D if _EXP[-1] & 0x80 else 0))
-_LOG = {v: i for i, v in enumerate(_EXP)}
-
-
-def _bch_format(data: int) -> int:
-  v = data << 10
-  for shift in range(14, 9, -1):
-    if v >> shift & 1:
-      v ^= 0x537 << (shift - 10)
-  return (data << 10 | v) ^ 0x5412
-
-
-# 15-bit format info indexed by (level bits << 3 | mask). Level bits: L=01, M=00, Q=11, H=10.
-_FORMATS = [_bch_format(d) for d in range(32)]
+# 15 format-info bits for level L (01) with mask 0: ((0x08 << 10) | bch_remainder) ^ 0x5412
+_FORMAT_BITS = 0b111011111000100
 
 
 def _raw_modules(version: int) -> int:
@@ -52,24 +21,8 @@ def _raw_modules(version: int) -> int:
   return result - (36 if version >= 7 else 0)
 
 
-def _block_lengths(version: int, level: int) -> list[int]:
-  """Data codewords per Reed-Solomon block. The last blocks may be one longer."""
-  ec, nblocks = _EC[version - 1][level]
-  total = _raw_modules(version) // 8 - ec * nblocks
-  return [total // nblocks + (i >= nblocks - total % nblocks) for i in range(nblocks)]
-
-
-def _interleaved(version: int, level: int) -> list[tuple[int, int]]:
-  """(block, index within block) of each transmitted codeword: data column-major, then ECC column-major."""
-  ec, nblocks = _EC[version - 1][level]
-  lens = _block_lengths(version, level)
-  data = [(b, i) for i in range(max(lens)) for b in range(nblocks) if i < lens[b]]
-  ecc = [(b, lens[b] + i) for i in range(ec) for b in range(nblocks)]
-  return data + ecc
-
-
 def _capacity(version: int) -> int:
-  return sum(_block_lengths(version, 0))
+  return _raw_modules(version) // 8 - _ECC_LEN[version] * _NUM_BLOCKS[version]
 
 
 def _append_bits(bits: list[int], value: int, length: int) -> None:
@@ -96,18 +49,37 @@ def _data_codewords(data: bytes, version: int) -> bytes:
 def _codewords(data: bytes, version: int) -> bytes:
   """Split data codewords into Reed-Solomon blocks and interleave data + ECC."""
   data = _data_codewords(data, version)
-  divisor = _divisor(_EC[version - 1][0][0])
-  blocks = []
+  num_blocks = _NUM_BLOCKS[version]
+  ecc_len = _ECC_LEN[version]
+  raw_codewords = _raw_modules(version) // 8
+  short_len = raw_codewords // num_blocks
+  num_short = num_blocks - raw_codewords % num_blocks
+  divisor = _divisor(ecc_len)
+  blocks: list[tuple[bytes, bytes]] = []
   offset = 0
-  for length in _block_lengths(version, 0):
+  for i in range(num_blocks):
+    length = short_len - ecc_len + (0 if i < num_short else 1)
     block = data[offset:offset + length]
-    blocks.append(block + _remainder(block, divisor))
+    blocks.append((block, _remainder(block, divisor)))
     offset += length
-  return bytes(blocks[b][i] for b, i in _interleaved(version, 0))
+  result = bytearray()
+  for i in range(short_len - ecc_len + 1):
+    for block, _ in blocks:
+      result.extend(block[i:i + 1])
+  for i in range(ecc_len):
+    for _, ecc in blocks:
+      result.append(ecc[i])
+  return bytes(result)
 
 
 def _multiply(x: int, y: int) -> int:
-  return _EXP[(_LOG[x] + _LOG[y]) % 255] if x and y else 0
+  result = 0
+  for _ in range(8):
+    result = (result << 1) ^ (0x11D if result & 0x80 else 0)
+    if y & 0x80:
+      result ^= x
+    y <<= 1
+  return result
 
 
 def _divisor(degree: int) -> bytes:
@@ -136,7 +108,7 @@ def _alignment_positions(version: int) -> list[int]:
   if version == 1:
     return []
   count = version // 7 + 2
-  step = (version * 8 + count * 3 + 5) // (count * 4 - 4) * 2
+  step = ((version * 4 + count * 2 + 1) // (count * 2 - 2)) * 2
   return [6] + [version * 4 + 10 - step * i for i in range(count - 1)][::-1]
 
 
@@ -199,7 +171,7 @@ class _Qr:
 
   def _format(self) -> None:
     for i in range(15):
-      bit = ((_FORMATS[1 << 3 | 0] >> i) & 1) != 0  # level L, mask 0
+      bit = ((_FORMAT_BITS >> i) & 1) != 0
       y_pos = i if i < 6 else i + 1 if i < 8 else self.size - 15 + i
       self._set_function(8, y_pos, bit)
       x_pos = self.size - 1 - i if i < 8 else 15 - i if i < 9 else 14 - i
@@ -244,496 +216,3 @@ def make_texture(data: str, inverted: bool = False) -> rl.Texture:
   rl_image.mipmaps = 1
   rl_image.format = rl.PixelFormat.PIXELFORMAT_UNCOMPRESSED_R8G8B8A8
   return rl.load_texture_from_image(rl_image)
-
-
-# ---- Symbol structure for decoding ----
-
-
-class QRError(Exception):
-  pass
-
-
-_LEVELS = (1, 0, 3, 2)  # format info level bits -> column in _EC
-
-_MASKS = [
-  lambda i, j: (i + j) % 2 == 0,
-  lambda i, j: i % 2 == 0,
-  lambda i, j: j % 3 == 0,
-  lambda i, j: (i + j) % 3 == 0,
-  lambda i, j: (i // 2 + j // 3) % 2 == 0,
-  lambda i, j: (i * j) % 2 + (i * j) % 3 == 0,
-  lambda i, j: ((i * j) % 2 + (i * j) % 3) % 2 == 0,
-  lambda i, j: ((i + j) % 2 + (i * j) % 3) % 2 == 0,
-]
-
-_ALIGNMENT = np.ones((5, 5), dtype=bool)
-_ALIGNMENT[1:4, 1:4] = False
-_ALIGNMENT[2, 2] = True
-
-
-def _gf_inv(a: int) -> int:
-  return _EXP[-_LOG[a] % 255]
-
-
-@functools.lru_cache
-def _data_coords(version: int) -> tuple[np.ndarray, np.ndarray]:
-  """(rows, cols) of the data and error correction modules in placement order: two-column zigzag from the right."""
-  dim = version * 4 + 17
-  func = np.zeros((dim, dim), dtype=bool)  # finder, timing, alignment, format, and version modules
-  func[:9, :9] = func[:9, dim - 8:] = func[dim - 8:, :9] = True
-  func[6, :] = func[:, 6] = True
-  positions = _alignment_positions(version)
-  for r, c in itertools.product(positions, positions):
-    if (r, c) not in ((6, 6), (6, dim - 7), (dim - 7, 6)):
-      func[r - 2:r + 3, c - 2:c + 3] = True
-  if version >= 7:
-    func[:6, dim - 11:dim - 8] = func[dim - 11:dim - 8, :6] = True
-  ys = np.arange(dim)
-  rows, cols = [], []
-  # the vertical timing column is skipped, so the pairs left of it start at odd columns
-  for i, right in enumerate(col if col > 6 else col - 1 for col in range(dim - 1, 0, -2)):
-    r = np.repeat(ys[::-1] if i % 2 == 0 else ys, 2)
-    c = np.tile((right, right - 1), dim)
-    keep = ~func[r, c]
-    rows.append(r[keep])
-    cols.append(c[keep])
-  return np.concatenate(rows), np.concatenate(cols)
-
-
-# ---- Matrix decoding ----
-
-
-def _poly_eval(p: list[int], x: int) -> int:
-  # p is highest degree first
-  y = 0
-  for c in p:
-    y = _multiply(y, x) ^ c
-  return y
-
-
-_EXP_TABLE = np.array(_EXP)
-_LOG_TABLE = np.array([_LOG.get(v, 0) for v in range(256)])
-
-
-def _syndromes(msg: list[int], nsym: int) -> list[int]:
-  """syn[i] = msg(alpha^i), msg highest degree first."""
-  m = np.array(msg)
-  exponents = np.arange(nsym)[:, None] * (len(msg) - 1 - np.arange(len(msg)))
-  return np.bitwise_xor.reduce(_EXP_TABLE[(_LOG_TABLE[m] + exponents) % 255] * (m != 0), axis=1).tolist()
-
-
-def _rs_correct(msg: list[int], nsym: int) -> list[int]:
-  """Corrects up to nsym // 2 errors in a Reed-Solomon codeword, in place."""
-  n = len(msg)
-  syn = _syndromes(msg, nsym)
-  if not any(syn):
-    return msg
-
-  # Berlekamp-Massey, sigma is lowest degree first
-  sigma, prev, L, m, b = [1], [1], 0, 1, 1
-  for r in range(nsym):
-    d = syn[r]
-    for i in range(1, L + 1):
-      d ^= _multiply(sigma[i], syn[r - i])
-    if d == 0:
-      m += 1
-      continue
-    coef = _multiply(d, _gf_inv(b))
-    shifted = [0] * m + prev
-    saved = sigma[:]
-    sigma = sigma + [0] * max(0, len(shifted) - len(sigma))
-    for i, c in enumerate(shifted):
-      sigma[i] ^= _multiply(coef, c)
-    if 2 * L <= r:
-      L, prev, b, m = r + 1 - L, saved, d, 1
-    else:
-      m += 1
-  sigma = sigma[:L + 1]
-  if 2 * L > nsym:
-    raise QRError("too many errors")
-
-  # Chien search: codeword position p has locator alpha^(n-1-p)
-  positions = [p for p in range(n) if _poly_eval(sigma[::-1], _EXP[(p - n + 1) % 255]) == 0]
-  if len(positions) != L:
-    raise QRError("error locator mismatch")
-
-  # solve syn[i] = sum_k e_k * X_k^i for the magnitudes e_k
-  xlog = [(n - 1 - p) % 255 for p in positions]
-  A = [[_EXP[(xlog[k] * i) % 255] for k in range(L)] + [syn[i]] for i in range(L)]
-  for col in range(L):
-    piv = next((r for r in range(col, L) if A[r][col]), None)
-    if piv is None:
-      raise QRError("singular")
-    A[col], A[piv] = A[piv], A[col]
-    inv = _gf_inv(A[col][col])
-    A[col] = [_multiply(inv, v) for v in A[col]]
-    for r in range(L):
-      if r != col and A[r][col]:
-        f = A[r][col]
-        A[r] = [a ^ _multiply(f, c) for a, c in zip(A[r], A[col], strict=True)]
-  for k, p in enumerate(positions):
-    msg[p] ^= A[k][L]
-
-  if any(_syndromes(msg, nsym)):
-    raise QRError("uncorrectable")
-  return msg
-
-
-def _read_format(m: np.ndarray) -> int:
-  """Returns the closest format info (level bits << 3 | mask) from either copy."""
-  dim = m.shape[0]
-  copies = ([(8, i) for i in range(6)] + [(8, 7), (8, 8), (7, 8)] + [(5 - i, 8) for i in range(6)],
-            [(dim - 1 - i, 8) for i in range(7)] + [(8, dim - 8 + i) for i in range(8)])  # (row, col), msb first
-  candidates = []
-  for coords in copies:
-    bits = int("".join(str(int(m[r, c])) for r, c in coords), 2)
-    candidates += [((bits ^ f).bit_count(), i) for i, f in enumerate(_FORMATS)]
-  distance, fmt = min(candidates)
-  if distance > 3:
-    raise QRError("bad format info")
-  return fmt
-
-
-_ALNUM = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"
-
-_ECI_ENCODINGS = {
-  0: "cp437", 2: "cp437", 1: "iso8859-1", 3: "iso8859-1",
-  **{i + 2: f"iso8859-{i}" for i in range(2, 17) if i != 12},
-  20: "shift_jis", 21: "cp1250", 22: "cp1251", 23: "cp1252", 24: "cp1256",
-  25: "utf-16-be", 26: "utf-8", 27: "ascii", 170: "ascii", 28: "big5", 29: "gb18030", 30: "euc_kr",
-}
-
-
-class _Bits:
-  def __init__(self, data: list[int]):
-    self._value = int.from_bytes(bytes(data), "big")
-    self.remaining = len(data) * 8
-
-  def read(self, n: int) -> int:
-    if n > self.remaining:
-      raise QRError("bitstream underflow")
-    self.remaining -= n
-    return self._value >> self.remaining & (1 << n) - 1
-
-  def read_below(self, n: int, limit: int) -> int:
-    v = self.read(n)
-    if v >= limit:
-      raise QRError("value out of range")
-    return v
-
-
-def _parse_data(data: list[int], version: int) -> str:
-  bits = _Bits(data)
-  out: list[str] = []
-  encoding = None
-  band = 0 if version <= 9 else 1 if version <= 26 else 2
-  while bits.remaining >= 4:
-    mode = bits.read(4)
-    if mode == 0:
-      break
-    if mode == 7:  # ECI character set assignment
-      first = bits.read(8)
-      extra = 0 if first < 0x80 else 8 if first < 0xC0 else 16 if first < 0xE0 else -1  # 1, 2, or 3 byte assignment
-      if extra < 0:
-        raise QRError("bad ECI assignment")
-      assignment = (first & 0x7F >> extra // 8) << extra | bits.read(extra)
-      encoding = _ECI_ENCODINGS.get(assignment)
-      if encoding is None:
-        raise QRError(f"unsupported ECI assignment {assignment}")
-    elif mode == 1:
-      n = bits.read((10, 12, 14)[band])
-      while n > 0:
-        k = min(n, 3)  # 3 digits in 10 bits, the last 2 or 1 in 7 or 4
-        out.append(f"{bits.read_below((4, 7, 10)[k - 1], 10 ** k):0{k}d}")
-        n -= k
-    elif mode == 2:
-      n = bits.read((9, 11, 13)[band])
-      while n > 0:
-        k = min(n, 2)  # 2 characters in 11 bits, a last one in 6
-        v = bits.read_below((6, 11)[k - 1], 45 ** k)
-        out.append(_ALNUM[v // 45] * (k - 1) + _ALNUM[v % 45])
-        n -= k
-    elif mode == 4:
-      n = bits.read((8, 16, 16)[band])
-      segment = bytes(bits.read(8) for _ in range(n))
-      try:
-        out.append(segment.decode(encoding or "utf-8"))
-      except UnicodeDecodeError as e:
-        if encoding is not None:
-          raise QRError("invalid ECI byte segment") from e
-        out.append(segment.decode("latin-1"))
-    elif mode == 8:
-      n = bits.read((8, 10, 12)[band])
-      for _ in range(n):
-        v = bits.read(13)
-        c = (v // 0xC0) << 8 | v % 0xC0
-        c += 0x8140 if c < 0x1F00 else 0xC140
-        try:
-          out.append(c.to_bytes(2, "big").decode("shift_jis"))
-        except UnicodeDecodeError as e:
-          raise QRError("invalid Kanji character") from e
-    else:
-      raise QRError(f"unsupported mode {mode}")
-  return "".join(out)
-
-
-def decode_matrix(m: np.ndarray) -> str:
-  """Decodes a square boolean module matrix (True = dark) without a quiet zone."""
-  dim = m.shape[0]
-  if m.shape != (dim, dim) or dim % 4 != 1 or not 21 <= dim <= 177:
-    raise QRError("bad matrix size")
-  version = (dim - 17) // 4
-
-  fmt = _read_format(m)
-  level = _LEVELS[fmt >> 3]
-  rows, cols = _data_coords(version)
-  bits = m[rows, cols] ^ _MASKS[fmt & 7](rows, cols)
-  codewords = np.packbits(bits[:len(bits) // 8 * 8]).tolist()
-
-  ec, _ = _EC[version - 1][level]
-  lens = _block_lengths(version, level)
-  blocks = [[0] * (n + ec) for n in lens]
-  for (b, i), codeword in zip(_interleaved(version, level), codewords, strict=True):
-    blocks[b][i] = codeword
-
-  data: list[int] = []
-  for block, n in zip(blocks, lens, strict=True):
-    data += _rs_correct(block, ec)[:n]
-  return _parse_data(data, version)
-
-
-# ---- Image decoding ----
-
-
-def _box_sums(a: np.ndarray, radii: tuple[int, ...]) -> list[np.ndarray]:
-  """Sums over (2r + 1)^2 neighborhoods of the last two axes, edge padded, from one integral image."""
-  P = max(radii)
-  lead = [(0, 0)] * (a.ndim - 2)
-  cs = np.pad(np.cumsum(np.cumsum(np.pad(a, lead + [(P, P), (P, P)], mode="edge"), -2), -1), lead + [(1, 0), (1, 0)])
-  H, W = a.shape[-2:]
-  out = []
-  for r in radii:
-    lo, hi = P - r, P + r + 1
-    out.append(cs[..., hi:hi + H, hi:hi + W] - cs[..., lo:lo + H, hi:hi + W] - cs[..., hi:hi + H, lo:lo + W] + cs[..., lo:lo + H, lo:lo + W])
-  return out
-
-
-def _binarize(gray: np.ndarray) -> np.ndarray:
-  """Adaptive threshold: each pixel against the mean of the surrounding tiles that have contrast."""
-  h, w = gray.shape
-  if h < 21 or w < 21:
-    raise QRError("image too small")
-  B = max(8, min(h, w) // 128 * 2)
-  H, W = -(-h // B), -(-w // B)
-  padded = np.pad(gray, ((0, H * B - h), (0, W * B - w)), mode="edge")
-  # block statistics from a subsample are plenty
-  sub = np.ascontiguousarray(padded[::2, ::2].reshape(H, B // 2, W, B // 2).transpose(0, 2, 1, 3)).reshape(H, W, -1)
-  blocks = sub.sum(axis=2, dtype=np.uint32) / sub.shape[2]
-  known = sub.max(axis=2) - sub.min(axis=2) >= 32
-  # Flat tiles cannot estimate their own threshold: use the tiles with contrast nearby, then
-  # further out, then the global midrange. A flat tile is then all dark or all light.
-  est = np.full((H, W), (blocks.min() + blocks.max()) / 2)
-  filled = np.zeros((H, W), dtype=bool)
-  for total, count in _box_sums(np.stack((known * blocks, known.astype(float))), (2, 6)):
-    fill = ~filled & (count > 0)
-    est[fill] = total[fill] / count[fill]
-    filled |= fill
-  thr = np.where(known, np.minimum(est, 254) + 1, np.where(blocks <= est, 255, 0)).astype(np.uint8)
-  return (padded.reshape(H, B, W, B) < thr[:, None, :, None]).reshape(H * B, W * B)[:h, :w]
-
-
-class _Runs:
-  """Run-length table of a padded, flattened binary image with a per-pixel run index."""
-
-  def __init__(self, padded: np.ndarray):
-    self.flat = padded.ravel()
-    self.lines, self.stride = padded.shape
-    change = self.flat[1:] != self.flat[:-1]
-    self.starts = np.concatenate(([0], np.flatnonzero(change) + 1))
-    self.lengths = np.diff(np.append(self.starts, self.flat.size)).astype(np.int32)
-
-  def run_at(self, line: np.ndarray, pos: np.ndarray) -> np.ndarray:
-    """Index of the run containing the pixel at `pos` along `line`."""
-    return np.searchsorted(self.starts, line * self.stride + pos + 1, side="right") - 1
-
-  @staticmethod
-  def _match(lengths: list[np.ndarray], ratios: tuple[int, ...]) -> tuple[np.ndarray, np.ndarray]:
-    """Checks windows of runs against the ratios, given the length of each run. Returns (ok, module size)."""
-    S = sum(ratios)
-    total = sum(lengths[1:], start=lengths[0])
-    ok = total >= 2 * S  # modules need to be at least 2 px
-    for L, r in zip(lengths, ratios, strict=True):
-      ok &= np.abs(2 * S * L - 2 * r * total) <= r * total  # integer form of |L - r * total / S| <= r * total / (2 * S)
-    return ok, total / S
-
-  def scan(self, ratios: tuple[int, ...]) -> np.ndarray:
-    """Returns the indices of all dark runs starting a window of runs matching the ratios."""
-    n = len(ratios)
-    N = len(self.lengths) - n + 1
-    if N <= 0:
-      return np.zeros(0, dtype=int)
-    ok, _ = self._match([self.lengths[k:N + k] for k in range(n)], ratios)
-    ok &= self.flat[self.starts[:N]]
-    first = np.flatnonzero(ok)
-    return first[self.starts[first] // self.stride == self.starts[first + n - 1] // self.stride]
-
-  def check(self, first: np.ndarray, ratios: tuple[int, ...]) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Checks the run windows starting at run index `first`. Returns (ok, center position along the line, module size)."""
-    n, half = len(ratios), len(ratios) // 2
-    ok = (first >= 0) & (first + n <= len(self.starts))
-    idx = np.clip(first[:, None] + np.arange(n), 0, len(self.starts) - 1)
-    matched, module = self._match([self.lengths[idx[:, k]] for k in range(n)], ratios)
-    ok &= matched & self.flat[self.starts[idx[:, 0]]]
-    ok &= self.starts[idx[:, 0]] // self.stride == self.starts[idx[:, -1]] // self.stride
-    center = self.starts[idx[:, half]] % self.stride - 1 + self.lengths[idx[:, half]] / 2
-    return ok, center, module
-
-
-def _find_patterns(binary: np.ndarray, ratios: tuple[int, ...]) -> list[tuple[float, float, float]]:
-  """Finds dark/light run patterns with the given module ratios. Returns (x, y, module size)."""
-  half = len(ratios) // 2
-  step = 2  # the center rows of a 2 px finder pattern still get scanned twice
-  rows_t = _Runs(np.pad(binary[::step], ((0, 0), (1, 1))))
-  first = rows_t.scan(ratios)
-  if len(first) == 0:
-    return []
-  _, cx, hmod = rows_t.check(first, ratios)
-  row = rows_t.starts[first] // rows_t.stride * step
-
-  xi = cx.astype(int)
-  xs, col = np.unique(xi, return_inverse=True)
-  cols_t = _Runs(np.pad(binary[:, xs].T, ((0, 0), (1, 1))))
-  ok, cy, vmod = cols_t.check(cols_t.run_at(col, row) - half, ratios)
-  ok &= (0.5 <= vmod / hmod) & (vmod / hmod <= 2)
-  line = np.clip(np.rint(cy / step), 0, rows_t.lines - 1).astype(int)
-  ok2, cx2, hmod2 = rows_t.check(rows_t.run_at(line, xi) - half, ratios)
-  ok &= ok2 & (0.5 <= hmod2 / vmod) & (hmod2 / vmod <= 2)
-
-  found: list[list[float]] = []  # [x, y, module, count]
-  for x, y, module in zip(cx2[ok], cy[ok], (hmod2[ok] + vmod[ok]) / 2, strict=True):
-    for f in found:
-      if abs(f[0] - x) <= f[2] and abs(f[1] - y) <= f[2] and 0.5 <= f[2] / module <= 2:
-        c = f[3]
-        f[0], f[1], f[2], f[3] = (f[0] * c + x) / (c + 1), (f[1] * c + y) / (c + 1), (f[2] * c + module) / (c + 1), c + 1
-        break
-    else:
-      found.append([x, y, module, 1])
-  found.sort(key=lambda f: -f[3])
-  return [(f[0], f[1], f[2]) for f in found if f[3] >= 2]
-
-
-def _pick_finders(patterns: list[tuple[float, float, float]]) -> tuple[np.ndarray, np.ndarray, np.ndarray, float]:
-  """Returns (top-left, top-right, bottom-left) centers and the module size of the most square-looking triple."""
-  best = None
-  for a, b, c in itertools.combinations(patterns[:10], 3):
-    mods = sorted((a[2], b[2], c[2]))
-    if mods[2] / mods[0] > 1.5:
-      continue
-    pts = [np.array(p[:2]) for p in (a, b, c)]
-    d = [np.linalg.norm(pts[(i + 1) % 3] - pts[(i + 2) % 3]) for i in range(3)]
-    tl = int(np.argmax(d))  # opposite the hypotenuse
-    p1, p2 = pts[(tl + 1) % 3], pts[(tl + 2) % 3]
-    v1, v2 = p1 - pts[tl], p2 - pts[tl]
-    n1, n2 = np.linalg.norm(v1), np.linalg.norm(v2)
-    if n1 == 0 or n2 == 0:
-      continue
-    cos = abs(np.dot(v1, v2)) / (n1 * n2)
-    if cos > 0.35 or not 0.6 <= n1 / n2 <= 1.6:
-      continue
-    score = cos + abs(np.log(n1 / n2)) + np.log(mods[2] / mods[0])
-    if best is not None and score >= best[0]:
-      continue
-    if v1[0] * v2[1] - v1[1] * v2[0] < 0:
-      p1, p2 = p2, p1
-    best = (score, pts[tl], p1, p2, float(sum(mods) / 3))
-  if best is None:
-    raise QRError("no finder patterns")
-  return best[1:]
-
-
-def _perspective(src: np.ndarray, dst: np.ndarray) -> np.ndarray:
-  """Homography mapping the four src points onto the four dst points."""
-  A = [row for (x, y), (u, v) in zip(src, dst, strict=True)
-       for row in ([x, y, 1, 0, 0, 0, -u * x, -u * y], [0, 0, 0, x, y, 1, -v * x, -v * y])]
-  try:
-    h = np.linalg.solve(np.array(A, dtype=float), np.asarray(dst, dtype=float).ravel())
-  except np.linalg.LinAlgError as e:
-    raise QRError("degenerate geometry") from e
-  return np.append(h, 1).reshape(3, 3)
-
-
-def _transform(H: np.ndarray, pts: np.ndarray) -> np.ndarray:
-  p = np.column_stack((pts, np.ones(len(pts)))) @ H.T
-  return p[:, :2] / p[:, 2:3]
-
-
-def _match_alignment(binary: np.ndarray, est: np.ndarray, offs: np.ndarray, r: int, module: float) -> np.ndarray | None:
-  h, w = binary.shape
-  dy = np.arange(max(0, int(est[1]) - r), min(h, int(est[1]) + r)) - est[1]
-  dx = np.arange(max(0, int(est[0]) - r), min(w, int(est[0]) + r)) - est[0]
-  if len(dy) == 0 or len(dx) == 0:
-    return None
-  y = np.rint(est[1] + dy[:, None, None] + offs[None, None, :, 1]).astype(int)
-  x = np.rint(est[0] + dx[None, :, None] + offs[None, None, :, 0]).astype(int)
-  valid = ((y >= 0) & (y < h) & (x >= 0) & (x < w)).all(axis=2)
-  samples = binary[np.clip(y, 0, h - 1), np.clip(x, 0, w - 1)]
-  score = np.where(valid, (samples == _ALIGNMENT.ravel()).sum(axis=2), 0)
-  if score.max() < 23:
-    return None
-  hits = np.argwhere(score == score.max())
-  centers = np.column_stack((est[0] + dx[hits[:, 1]], est[1] + dy[hits[:, 0]]))
-  closest = centers[np.argmin(np.linalg.norm(centers - est, axis=1))]
-  return centers[np.linalg.norm(centers - closest, axis=1) <= module / 2].mean(axis=0)
-
-
-def _locate_alignment(binary: np.ndarray, H: np.ndarray, center: float, module: float) -> np.ndarray | None:
-  """Template matches the 5x5 alignment pattern around its position estimated from H."""
-  grid = np.mgrid[-2:3, -2:3].reshape(2, -1).T[:, ::-1] + center  # (25, 2) module coords (x, y)
-  pts = _transform(H, grid)
-  # the affine estimate can be off in both position and local scale under perspective
-  for radius in (2, 4, 8, 16):
-    for scale in (1.0, 0.8, 1.25, 0.65, 1.5):
-      found = _match_alignment(binary, pts[12], (pts - pts[12]) * scale, int(module * radius), module)
-      if found is not None:
-        return found
-  return None
-
-
-def _sample(binary: np.ndarray, tl: np.ndarray, tr: np.ndarray, bl: np.ndarray, module: float, dim: int, use_alignment: bool) -> np.ndarray:
-  src = np.array([(3.5, 3.5), (dim - 3.5, 3.5), (3.5, dim - 3.5), (dim - 3.5, dim - 3.5)])
-  dst = np.array([tl, tr, bl, tr + bl - tl])
-  H = _perspective(src, dst)
-  if use_alignment and dim > 21:
-    align = _locate_alignment(binary, H, dim - 6.5, module)
-    if align is not None:
-      src[3], dst[3] = (dim - 6.5, dim - 6.5), align
-      H = _perspective(src, dst)
-
-  rows, cols = np.mgrid[0:dim, 0:dim]
-  pts = _transform(H, np.column_stack((cols.ravel() + 0.5, rows.ravel() + 0.5)))
-  xy = np.rint(pts).astype(int)
-  h, w = binary.shape
-  if (xy < 0).any() or (xy[:, 0] >= w).any() or (xy[:, 1] >= h).any():
-    raise QRError("code extends outside image")
-  return binary[xy[:, 1], xy[:, 0]].reshape(dim, dim)
-
-
-def decode(gray: np.ndarray) -> str | None:
-  """Decodes the QR code in a 2D uint8 grayscale image. Modules need to be at least 2 px.
-  Returns None if nothing could be decoded."""
-  try:
-    binary = _binarize(gray)
-    tl, tr, bl, module = _pick_finders(_find_patterns(binary, (1, 1, 3, 1, 1)))
-  except QRError:
-    return None
-
-  d = (np.linalg.norm(tr - tl) + np.linalg.norm(bl - tl)) / 2
-  dim = int(round((d / module + 7 - 17) / 4)) * 4 + 17
-  dims = [cand for cand in (dim, dim - 4, dim + 4) if 21 <= cand <= 177]
-  for cand, use_alignment, transpose in itertools.product(dims, (True, False), (False, True)):
-    try:
-      m = _sample(binary, tl, tr, bl, module, cand, use_alignment)
-      return decode_matrix(m.T if transpose else m)
-    except QRError:
-      pass
-  return None

openpilot/common/tests/test_qrcode.py

@@ -1,178 +0,0 @@
-import hashlib
-import math
-from pathlib import Path
-
-import numpy as np
-
-from openpilot.common import qrcode as qr
-from openpilot.common.test import OpenpilotTestCase
-
-LPA = "LPA:1$rsp.truphone.com$QRF-BETTERROAMING-PMRDGIR2EARDEIT5"
-
-
-# Matrices generated with python-qrcode 8.2, covering all versions and EC levels.
-# Packed fixtures keep the decoder tests independent of our encoder.
-FIXTURES = {}
-for path in Path(__file__).with_name("fixtures").glob("qrcode_*.npz"):
-  with np.load(path) as fixtures:
-    FIXTURES.update({key: fixtures[key] for key in fixtures.files})
-
-
-def fixture(key: str) -> np.ndarray:
-  bits = np.unpackbits(FIXTURES[key])
-  size = math.isqrt(len(bits))
-  return bits[:size * size].reshape(size, size).astype(bool)
-
-
-def render(matrix: np.ndarray, box: int = 6, border: int = 4) -> np.ndarray:
-  img = np.repeat(np.repeat(np.pad(matrix, border), box, axis=0), box, axis=1)
-  return np.where(img, 0, 255).astype(np.uint8)
-
-
-def make(data: str, version: int | None = None, level: int = 0, box: int = 6, border: int = 4):
-  matrix = fixture(hashlib.sha256(f"{version}:{level}:{data}".encode()).hexdigest())
-  return matrix, render(matrix, box, border)
-
-
-def warp(img: np.ndarray, H: np.ndarray) -> np.ndarray:
-  """Bilinear resampling through the output -> input homography H, white outside the image."""
-  h, w = img.shape
-  rows, cols = np.mgrid[0:h, 0:w]
-  pts = qr._transform(H, np.column_stack((cols.ravel() + 0.5, rows.ravel() + 0.5))) - 0.5
-  x0, y0 = np.floor(pts[:, 0]).astype(int), np.floor(pts[:, 1]).astype(int)
-  fx, fy = pts[:, 0] - x0, pts[:, 1] - y0
-  padded = np.pad(img.astype(float), 1, constant_values=255)
-
-  def at(y, x):
-    return padded[np.clip(y + 1, 0, h + 1), np.clip(x + 1, 0, w + 1)]
-
-  out = at(y0, x0) * (1 - fx) * (1 - fy) + at(y0, x0 + 1) * fx * (1 - fy) + at(y0 + 1, x0) * (1 - fx) * fy + at(y0 + 1, x0 + 1) * fx * fy
-  return np.clip(out, 0, 255).astype(np.uint8).reshape(h, w)
-
-
-def rotate(img: np.ndarray, angle: float) -> np.ndarray:
-  h, w = img.shape
-  t = np.radians(angle)
-  R = np.array([[np.cos(t), -np.sin(t)], [np.sin(t), np.cos(t)]])
-  center = np.array([w / 2, h / 2])
-  corners = np.array([(0, 0), (w, 0), (w, h), (0, h)], dtype=float)
-  return warp(img, qr._perspective((corners - center) @ R.T + center, corners))
-
-
-class TestQRCode(OpenpilotTestCase):
-  def test_alignment_positions(self):
-    assert qr._alignment_positions(7) == [6, 22, 38]
-    assert qr._alignment_positions(32) == [6, 34, 60, 86, 112, 138]
-    assert qr._alignment_positions(40) == [6, 30, 58, 86, 114, 142, 170]
-
-  def test_all_versions(self):
-    for version in range(1, 41):
-      for level in range(4):
-        with self.subTest(version=version, level=level):
-          data = "".join(chr(ord("a") + i % 26) for i in range(version))
-          matrix, img = make(data, version, level, box=3)
-          assert qr.decode_matrix(matrix) == data
-          assert qr.decode(img) == data
-
-  def test_modes(self):
-    for data in ["0123456789012345", "HELLO WORLD $1.50", LPA, "こんにちは", "ünïcødé", "mixed 123 ABC xyz"]:
-      with self.subTest(data=data):
-        matrix, img = make(data)
-        assert qr.decode_matrix(matrix) == data
-        assert qr.decode(img) == data
-
-  def test_error_correction(self):
-    matrix, _ = make(LPA, level=2)
-    rng = np.random.default_rng(0)
-    flipped = matrix.copy()
-    for r, c in rng.integers(9, matrix.shape[0] - 9, size=(40, 2)):
-      flipped[r, c] ^= True
-    assert qr.decode_matrix(flipped) == LPA
-
-  def test_large_modules(self):
-    for data in ["0123456789012345", "HELLO WORLD $1.50", LPA, "mixed 123 ABC xyz"]:
-      for box in [16, 20, 24, 32]:
-        for dark, light in [(0, 255), (60, 200), (140, 250)]:
-          with self.subTest(data=data, box=box, dark=dark):
-            _, img = make(data, box=box)
-            img = np.where(img == 0, dark, light).astype(np.uint8)
-            assert qr.decode(img) == data
-
-  def test_image_edges(self):
-    # a code touching the image edge must not lose the rows and columns left over from tiling
-    matrix, _ = make(LPA)
-    for size in (200, 203):
-      with self.subTest(size=size):
-        img = np.full((size, size), 255, dtype=np.uint8)
-        code = render(matrix, box=5, border=0)
-        img[size - code.shape[0]:, size - code.shape[1]:] = code
-        assert qr.decode(img) == LPA
-
-  def test_eci(self):
-    # qrcode_eci.npz: packed Segno 1.6.6 matrices, generated with mode='byte',
-    # eci=True, micro=False and the named encoding. Mixed also includes numeric,
-    # alphanumeric, and Kanji segments after changing the byte encoding twice.
-    cases = {
-      "iso8859-5": "Привет", "utf-16-be": "héllo", "utf-8": "こんにちは",
-      "shift_jis": "日本語", "cp1251": "Привет", "iso8859-1": "héllo",
-      "mixed": "hélloПривет日本語123ABC漢字",
-    }
-    for encoding, expected in cases.items():
-      with self.subTest(encoding=encoding):
-        matrix = fixture(encoding)
-        assert qr.decode_matrix(matrix) == expected
-        assert qr.decode(render(matrix)) == expected
-
-  def test_parse_data(self):
-    def parse(stream: str) -> str:
-      stream += '0' * (-len(stream) % 8)
-      return qr._parse_data([int(stream[i:i + 8], 2) for i in range(0, len(stream), 8)], 1)
-
-    def eci(assignment: str, payload: bytes = b'A') -> str:
-      return parse('0111' + assignment + '0100' + f'{len(payload):08b}' + ''.join(f'{b:08b}' for b in payload) + '0000')
-
-    # ASCII assignment 170 uses the two-byte ECI representation.
-    assert eci('1000000010101010') == 'A'
-    for assignment in ['00001110', '1000001111100111', '110000010000000000000000', '11100000']:
-      with self.subTest(assignment=assignment), self.assertRaises(qr.QRError):
-        eci(assignment)
-    with self.assertRaises(qr.QRError):
-      eci('00011010', b'\xff')  # Invalid UTF-8 must not fall back to Latin-1.
-
-    # out-of-range numeric, alphanumeric, and Kanji values are format errors, not crashes
-    for stream in ['0001' + '0000000011' + '1111111111', '0001' + '0000000010' + '1111111',
-                   '0010' + '000000010' + '11111111111', '0010' + '000000001' + '111111',
-                   '1000' + '00000001' + '0000000111111']:
-      with self.subTest(stream=stream), self.assertRaises(qr.QRError):
-        parse(stream)
-
-  def test_rotation(self):
-    for angle in [0, 90, 180, 270, 25, 110]:
-      with self.subTest(angle=angle):
-        _, img = make(LPA, box=8, border=12)
-        assert qr.decode(rotate(img, angle)) == LPA
-
-  def test_mirrored(self):
-    _, img = make(LPA)
-    assert qr.decode(img[:, ::-1]) == LPA
-
-  def test_perspective_and_noise(self):
-    _, img = make(LPA, box=10, border=8)
-    h, w = img.shape
-    corners = np.array([(40, 60), (w - 20, 30), (w - 60, h - 40), (30, h - 90)])
-    arr = warp(img, qr._perspective(corners, np.array([(0, 0), (w, 0), (w, h), (0, h)]))).astype(float)
-    rng = np.random.default_rng(1)
-    arr = arr * 0.6 + 60 + rng.normal(0, 12, arr.shape)  # low contrast + noise
-    # uneven lighting
-    arr += np.linspace(-40, 40, w)[None, :]
-    assert qr.decode(np.clip(arr, 0, 255).astype(np.uint8)) == LPA
-
-  def test_no_code(self):
-    rng = np.random.default_rng(2)
-    assert qr.decode(rng.integers(0, 256, size=(240, 320), dtype=np.uint8)) is None
-    assert qr.decode(np.full((240, 320), 200, dtype=np.uint8)) is None
-
-  def test_encoder_roundtrip(self):
-    for version in range(1, 21):
-      with self.subTest(version=version):
-        assert qr.decode_matrix(np.array(qr._Qr(version, b"hello").modules)) == "hello"

openpilot/selfdrive/assets/prep-svg.sh

@@ -23,8 +23,8 @@ done
 
 # sudo apt install inkscape
 
-for svg in $(find "$DIR" -type f | grep svg$); do
-  bunx svgo "$svg" --multipass --pretty --indent 2
+for svg in $(find $DIR -type f | grep svg$); do
+  bunx svgo $svg --multipass --pretty --indent 2
 
   # convert to PNG
   png="${svg%.svg}.png"

openpilot/selfdrive/car/card.py

@@ -186,6 +186,9 @@ class Car:
     # card is driven by can recv, expected at 100Hz
     self.rk = Ratekeeper(100, print_delay_threshold=None)
 
+    # log fingerprint in sentry
+    sunnypilot_interfaces.log_fingerprint(self.CP)
+
   def state_update(self) -> tuple[car.CarState, custom.CarStateSP, structs.RadarDataT | None]:
     """carState update loop, driven by can"""
 

openpilot/selfdrive/locationd/locationd.py

@@ -278,12 +278,12 @@ def main():
   estimator = LocationEstimator(DEBUG)
 
   filter_initialized = False
-  critical_services = ["accelerometer", "gyroscope", "cameraOdometry"]
+  critcal_services = ["accelerometer", "gyroscope", "cameraOdometry"]
   observation_input_invalid = defaultdict(int)
 
-  input_invalid_limit = {s: round(INPUT_INVALID_LIMIT * (SERVICE_LIST[s].frequency / 20.)) for s in critical_services}
-  input_invalid_threshold = {s: input_invalid_limit[s] - 0.5 for s in critical_services}
-  input_invalid_decay = {s: calculate_invalid_input_decay(input_invalid_limit[s], INPUT_INVALID_RECOVERY, SERVICE_LIST[s].frequency) for s in critical_services}
+  input_invalid_limit = {s: round(INPUT_INVALID_LIMIT * (SERVICE_LIST[s].frequency / 20.)) for s in critcal_services}
+  input_invalid_threshold = {s: input_invalid_limit[s] - 0.5 for s in critcal_services}
+  input_invalid_decay = {s: calculate_invalid_input_decay(input_invalid_limit[s], INPUT_INVALID_RECOVERY, SERVICE_LIST[s].frequency) for s in critcal_services}
 
   initial_pose_data = params.get("LocationFilterInitialState")
   if initial_pose_data is not None:
@@ -313,7 +313,7 @@ def main():
         if valid:
           t = log_mono_time * 1e-9
           res = estimator.handle_log(t, which, msg)
-          if which not in critical_services:
+          if which not in critcal_services:
             continue
 
           if res == HandleLogResult.TIMING_INVALID:
@@ -328,7 +328,7 @@ def main():
       filter_initialized = sm.all_checks() and sensor_all_checks(acc_msgs, gyro_msgs, sensor_valid, sensor_recv_time, sensor_alive, SIMULATION)
 
     if sm.updated["cameraOdometry"]:
-      critical_service_inputs_valid = all(observation_input_invalid[s] < input_invalid_threshold[s] for s in critical_services)
+      critical_service_inputs_valid = all(observation_input_invalid[s] < input_invalid_threshold[s] for s in critcal_services)
       inputs_valid = sm.all_valid() and critical_service_inputs_valid
       sensors_valid = sensor_all_checks(acc_msgs, gyro_msgs, sensor_valid, sensor_recv_time, sensor_alive, SIMULATION)
 

openpilot/selfdrive/modeld/SConscript

@@ -1,90 +1,142 @@
 import glob
+import json
 import os
 import time
 from SCons.Script import Action, Value
+from openpilot.common.file_chunker import chunk_file, get_chunk_targets, get_existing_chunks
 from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
 from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE, DM_INPUT_SIZE
-from openpilot.selfdrive.modeld.helpers import chestnut_present
-from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+from openpilot.selfdrive.modeld.constants import ModelConstants
+from openpilot.selfdrive.modeld.helpers import TG_INPUT_DEVICES_PATH, chestnut_present, modeld_pkl_path
 
 
 Import('env', 'arch')
+chunker_file = File("#openpilot/common/file_chunker.py")
 lenv = env.Clone()
-lenv.PrependENVPath('PYTHONPATH', Dir('#tinygrad_repo').abspath)
 
 tinygrad_root = env.Dir("#").abspath
 tinygrad_files = ["#"+x for x in glob.glob(env.Dir("#tinygrad_repo").relpath + "/**", recursive=True, root_dir=tinygrad_root)
                   if 'pycache' not in x and os.path.isfile(os.path.join(tinygrad_root, x))]
 
-camera_configs = [(c.width, c.height) for c in (_ar_ox_fisheye, _os_fisheye)]
+def estimate_pickle_max_size(onnx_size):
+  # QCOM programs for models with spatial recurrent features can approach 2x
+  # the ONNX size. Overestimating only adds an empty trailing chunk.
+  return 2.0 * onnx_size + 10 * 1024 * 1024
 
 if arch == 'comma_arm64':
-  tg_flags = 'DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1'
+  from openpilot.common.hardware import HARDWARE
+  camera = _os_fisheye if HARDWARE.get_device_type() == "mici" else _ar_ox_fisheye
+  camera_configs = [(camera.width, camera.height)]
+  tg_backend = 'QCOM'
+  tg_flags = f'DEV={tg_backend} IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1'
 else:
-  # JIT=2 disables graph batching, which produces incorrect outputs after buffers change.
-  tg_flags = 'DEV=METAL JIT=2' if arch == 'Darwin' else 'DEV=CPU:LLVM'
+  camera_configs = [(c.width, c.height) for c in (_ar_ox_fisheye, _os_fisheye)]
+  tg_backend = 'CPU'
+  tg_flags = f'DEV=CPU' if arch == 'Darwin' else 'DEV=CPU:LLVM'
+
+tg_devices = { # which device to put jit inputs to at runtime
+  'openpilot.selfdrive.modeld.dmonitoringmodeld': {
+    'default': {'DEV': tg_backend}
+  },
+}
 
 CHESTNUT = chestnut_present()
 if CHESTNUT:
-  chestnut_tg_flags = 'DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32'
+  chestnut_tg_flags = 'DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2 TC_OCCUPANCY_OPT=1'
   # the USB+AMD GPU takes an exclusive flock; serialize all targets that touch it
   chestnut_lock = File("models/.chestnut.lock").abspath
 
+def write_tg_devices(target, source, env):
+  with open(str(target[0]), "w") as f:
+    json.dump(tg_devices, f)
+    f.write("\n")
+
+tg_devices_node = lenv.Command(
+  str(TG_INPUT_DEVICES_PATH),
+  [Value(tg_devices)],
+  write_tg_devices,
+)
+
 # tinygrad calls brew which needs a $HOME in the env
 mac_brew_string = f'HOME={os.path.expanduser("~")}' if arch == 'Darwin' else ''
 
-warp_deps = [File("#openpilot/system/camerad/cameras/nv12_info.py")]
-compiler = Dir('#tinygrad_repo/examples/openpilot').abspath
-# CPU 7 is isolated with isolcpus on AGNOS, so explicitly pin the compiler to it.
-taskset = 'taskset -c 7 ' if arch == 'comma_arm64' else ''
-
-def chestnut_action(command):
-  def do_compile(target, source, env):
-    from openpilot.system.hardware.chestnut.flash import link_up
-    # chestnut can enumerate before its PCIe link is up due to varying 12V power behavior across cars
-    for _ in range(10):
-      if link_up():
-        break
-      time.sleep(1)
-    else:
-      print("Chestnut not ready, skipping warp build")
-      return
-    return env.Execute(command)
-  return Action(do_compile, "  [CHESTNUT] $TARGET")
-
-def compile_model(onnx_path, pkl_path):
-  onnx_path, target_pkl_path = File(onnx_path).abspath, File(pkl_path).abspath
-  cmd = (f'{tg_flags} {mac_brew_string} {taskset}python3 "{compiler}/compile_onnx.py" '
-         f'"{onnx_path}" "{target_pkl_path}" --out-of-band --benchmark-runs 1')
-  lenv.Command(
-    target_pkl_path,
-    tinygrad_files + [onnx_path, Value(cmd)],
-    Action(cmd, "  [ONNX] $TARGET"),
-  )
-
-compile_model('models/dmonitoring_model.onnx', 'models/dmonitoring_model_tinygrad.pkl')
-compile_model('models/driving_supercombo.onnx', 'models/driving_tinygrad.pkl')
-
+modeld_dir = Dir("#openpilot/selfdrive/modeld").abspath
+compile_modeld_script = [
+  File(f"{modeld_dir}/compile_modeld.py"),
+  File(f"{modeld_dir}/get_model_metadata.py"),
+  File("#openpilot/system/camerad/cameras/nv12_info.py"),
+  File("#openpilot/common/hardware/hw.py"),
+]
 model_w, model_h = MEDMODEL_INPUT_SIZE
-for chestnut in [False, True] if CHESTNUT else [False]:
-  file_prefix, cmd_flags = ('big_', chestnut_tg_flags) if chestnut else ('', tg_flags)
-  for cam_w, cam_h in camera_configs:
-    warp_pkl_path = File(f"models/{file_prefix}driving_warp_{cam_w}x{cam_h}_tinygrad.pkl").abspath
-    stride, y_height, uv_height, _ = get_nv12_info(cam_w, cam_h)
-    cmd = (f'{cmd_flags} {mac_brew_string} {taskset}python3 "{compiler}/compile_warp.py" '
-           f'--frame {cam_w},{cam_h},{stride},{y_height},{uv_height},{stride * (y_height + uv_height)} '
-           f'--warp-to {model_w}x{model_h} --layout yuv420 --frames 2 '
-           f'--output {warp_pkl_path}')
-    action = chestnut_action(cmd) if chestnut else cmd
-    node = lenv.Command(warp_pkl_path, tinygrad_files + warp_deps + [Value(cmd)], action)
+frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ
+
+if not os.getenv('SKIP_TINYGRAD_COMPILE'):
+  for chestnut in [False, True] if CHESTNUT else [False]:
+    target_pkl_path = File(modeld_pkl_path(chestnut)).abspath
+    file_prefix, cmd_flags = ('big_', chestnut_tg_flags) if chestnut else ('', tg_flags)
+    driving_onnx_deps = get_existing_chunks(File(f"models/{file_prefix}driving_supercombo.onnx").abspath)
+    camera_res_args = ' '.join(f'{cw}x{ch}' for cw, ch in camera_configs)
+    # CPU 7 is isolated with isolcpus on AGNOS, so explicitly pin the compiler to it.
+    taskset = 'taskset -c 7 ' if arch == 'comma_arm64' else ''
+    cmd = (f'{cmd_flags} {mac_brew_string} {taskset}python3 {modeld_dir}/compile_modeld.py '
+          f'--model-size {model_w}x{model_h} '
+          f'--camera-resolutions {camera_res_args} '
+          f'--onnx {File(f"models/{file_prefix}driving_supercombo.onnx").abspath} '
+          f'--output {target_pkl_path} --frame-skip {frame_skip}')
+    onnx_sizes_sum = sum(os.path.getsize(f) for f in driving_onnx_deps)
+    chunk_targets = get_chunk_targets(target_pkl_path, estimate_pickle_max_size(onnx_sizes_sum))
+    def do_compile(target, source, env, command=cmd, pkl=target_pkl_path, chunks=chunk_targets):
+      from openpilot.system.hardware.chestnut.flash import link_up
+      # chestnut can enumerate before its PCIe link is up due to varying 12V power behavior across cars
+      for _ in range(10):
+        if link_up():
+          break
+        time.sleep(1)
+      else:
+        print("Chestnut not ready, skipping big model build")
+        return
+      if ret := env.Execute(command):
+        return ret
+      chunk_file(pkl, chunks)
+    def do_chunk(target, source, env, pkl=target_pkl_path, chunks=chunk_targets):
+      chunk_file(pkl, chunks)
+    actions = Action(do_compile, "  [CHESTNUT] $TARGET") if chestnut else [cmd, Action(do_chunk, "  [CHUNK] $TARGET")]
+    node = lenv.Command(
+      chunk_targets,
+      tinygrad_files + compile_modeld_script + driving_onnx_deps + [Value(camera_res_args), Value(chunk_targets), chunker_file],
+      actions,
+    )
     if chestnut:
       lenv.SideEffect(chestnut_lock, node)
 
+# get model metadata
+fn = File(f"models/dmonitoring_model").abspath
+script_files = [File(Dir("#openpilot/selfdrive/modeld").File("get_model_metadata.py").abspath)]
+cmd = f'{tg_flags} {mac_brew_string} python3 {Dir("#openpilot/selfdrive/modeld").abspath}/get_model_metadata.py {fn}.onnx'
+lenv.Command(fn + "_metadata.pkl", [fn + ".onnx"] + tinygrad_files + script_files + [tg_devices_node], cmd)
+
 dm_w, dm_h = DM_INPUT_SIZE
+compile_dm_warp_script = [File(f"{modeld_dir}/compile_dm_warp.py")]
 for cam_w, cam_h in camera_configs:
   dm_pkl_path = File(f"models/dm_warp_{cam_w}x{cam_h}_tinygrad.pkl").abspath
-  stride, y_height, uv_height, frame_size = get_nv12_info(cam_w, cam_h)
-  cmd = (f'{tg_flags} {mac_brew_string} python3 "{compiler}/compile_warp.py" '
-         f'--frame {cam_w},{cam_h},{stride},{y_height},{uv_height},{frame_size} --warp-to {dm_w}x{dm_h} '
-         f'--layout luma --border-fill 16 --transform-device NPY --output {dm_pkl_path}')
-  lenv.Command(dm_pkl_path, tinygrad_files + warp_deps + [Value(cmd)], cmd)
+  cmd = (f'{tg_flags} {mac_brew_string} python3 {modeld_dir}/compile_dm_warp.py '
+         f'--camera-resolution {cam_w}x{cam_h} --warp-to {dm_w}x{dm_h} '
+         f'--output {dm_pkl_path}')
+  lenv.Command(dm_pkl_path, tinygrad_files + compile_dm_warp_script + compile_modeld_script + [tg_devices_node], cmd)
+
+def tg_compile(flags, model_name):
+  pythonpath_string = 'PYTHONPATH="${PYTHONPATH}:' + env.Dir("#tinygrad_repo").abspath + '"'
+  fn = File(f"models/{model_name}").abspath
+  pkl = fn + "_tinygrad.pkl"
+  onnx_path = fn + ".onnx"
+  chunk_targets = get_chunk_targets(pkl, estimate_pickle_max_size(os.path.getsize(onnx_path)))
+  def do_chunk(target, source, env):
+    chunk_file(pkl, chunk_targets)
+  return lenv.Command(
+    chunk_targets,
+    [onnx_path] + tinygrad_files + [Value(chunk_targets), chunker_file, tg_devices_node],
+    [f'{pythonpath_string} {flags} python3 {Dir("#tinygrad_repo").abspath}/examples/openpilot/compile3.py {fn}.onnx {pkl}',
+     Action(do_chunk, "  [CHUNK] $TARGET")],
+  )
+
+tg_compile(tg_flags, 'dmonitoring_model')

openpilot/selfdrive/modeld/compile_dm_warp.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+import argparse
+import pickle
+import time
+
+from tinygrad.tensor import Tensor
+from tinygrad.device import Device
+from tinygrad.engine.jit import TinyJit
+
+from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+from openpilot.selfdrive.modeld.compile_modeld import NV12Frame, warp_perspective_tinygrad, _parse_size
+
+
+def make_warp_dm(nv12: NV12Frame, dm_w, dm_h):
+  cam_w, cam_h, stride, _, _, _ = nv12
+  stride_pad = stride - cam_w
+
+  def warp_dm(input_frame, M_inv):
+    M_inv = M_inv.to(Device.DEFAULT).realize()
+    return warp_perspective_tinygrad(input_frame[:cam_h*stride], M_inv,
+                                     (dm_w, dm_h), (cam_h, cam_w), stride_pad, border_fill_val=16).reshape(-1, dm_h * dm_w) # Y
+  return warp_dm
+
+
+def compile_dm_warp(nv12: NV12Frame, dm_w, dm_h, pkl_path):
+  print(f"Compiling DM warp for {nv12.width}x{nv12.height} -> {dm_w}x{dm_h}...")
+
+  warp_dm_jit = TinyJit(make_warp_dm(nv12, dm_w, dm_h), prune=True)
+
+  for i in range(10):
+    frame = Tensor.randint(nv12.size, low=0, high=256, dtype='uint8').realize()
+    M_inv = Tensor(Tensor.randn(3, 3).mul(8).realize().numpy(), device='NPY')
+    Device.default.synchronize()
+    st = time.perf_counter()
+    warp_dm_jit(frame, M_inv).realize()
+    mt = time.perf_counter()
+    Device.default.synchronize()
+    et = time.perf_counter()
+    print(f"  [{i+1}/10] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")
+
+  with open(pkl_path, "wb") as f:
+    pickle.dump(warp_dm_jit, f)
+  print(f"  Saved to {pkl_path}")
+
+
+if __name__ == "__main__":
+  p = argparse.ArgumentParser()
+  p.add_argument('--camera-resolution', type=_parse_size, required=True, help='camera resolution WxH')
+  p.add_argument('--warp-to', type=_parse_size, required=True, help='DM input WxH')
+  p.add_argument('--output', required=True)
+  args = p.parse_args()
+
+  cam_w, cam_h = args.camera_resolution
+  nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
+  dm_w, dm_h = args.warp_to
+  compile_dm_warp(nv12, dm_w, dm_h, args.output)

openpilot/selfdrive/modeld/compile_modeld.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+import argparse
+import atexit
+import math
+import os
+import tempfile
+import time
+import shutil
+from functools import partial
+from collections import namedtuple
+
+import numpy as np
+
+from openpilot.selfdrive.modeld.helpers import dump_oob, load_oob
+
+def _patch_tinygrad_fetch_fw():
+  import hashlib
+  import pathlib
+  import zstandard
+  from tinygrad import helpers
+  _orig = helpers.fetch_fw
+  def fetch_fw(path, name, sha256):
+    p = pathlib.Path(f"/lib/firmware/{path}/{name}.zst")
+    if p.is_file():
+      blob = zstandard.ZstdDecompressor().stream_reader(p.read_bytes()).read()
+      if hashlib.sha256(blob).hexdigest() == sha256:
+        return blob
+    return _orig(path, name, sha256)
+  helpers.fetch_fw = fetch_fw
+_patch_tinygrad_fetch_fw()
+
+
+from tinygrad.tensor import Tensor
+from tinygrad.helpers import Context
+from tinygrad.device import Device
+from tinygrad.engine.jit import TinyJit
+
+
+NV12Frame = namedtuple("NV12Frame", ['width', 'height', 'stride', 'y_height', 'uv_height', 'size'])
+MODELD_INPUTS = ['img_q', 'big_img_q', 'feat_q', 'desire_q', 'packed_npy_inputs']
+
+
+def nv12_copy_size(stride: int, y_height: int, uv_height: int) -> int:
+  # Retain the padded Y and UV plane storage, but skip the trailing kernel/guard allocation.
+  return stride * (y_height + uv_height)
+
+
+def warp_perspective_tinygrad(src_flat, M_inv, dst_shape, src_shape, stride_pad, border_fill_val=None):
+  w_dst, h_dst = dst_shape
+  h_src, w_src = src_shape
+
+  x = Tensor.arange(w_dst).reshape(1, w_dst).expand(h_dst, w_dst).reshape(-1)
+  y = Tensor.arange(h_dst).reshape(h_dst, 1).expand(h_dst, w_dst).reshape(-1)
+
+  # inline 3x3 matmul as elementwise to avoid reduce op (enables fusion with gather)
+  src_x = M_inv[0, 0] * x + M_inv[0, 1] * y + M_inv[0, 2]
+  src_y = M_inv[1, 0] * x + M_inv[1, 1] * y + M_inv[1, 2]
+  src_w = M_inv[2, 0] * x + M_inv[2, 1] * y + M_inv[2, 2]
+
+  src_x = src_x / src_w
+  src_y = src_y / src_w
+
+  x_round = Tensor.round(src_x)
+  y_round = Tensor.round(src_y)
+  x_nn_clipped = x_round.clip(0, w_src - 1).cast('int')
+  y_nn_clipped = y_round.clip(0, h_src - 1).cast('int')
+  idx = y_nn_clipped * (w_src + stride_pad) + x_nn_clipped
+  sampled = src_flat[idx]
+
+  if border_fill_val is None:
+    return sampled
+
+  in_bounds = ((x_round >= 0) & (x_round <= w_src - 1) &
+               (y_round >= 0) & (y_round <= h_src - 1)).cast(sampled.dtype)
+  return sampled * in_bounds + Tensor(border_fill_val, dtype=sampled.dtype) * (1 - in_bounds)
+
+
+def frames_to_tensor(frames):
+  H = (frames.shape[0] * 2) // 3
+  W = frames.shape[1]
+  in_img1 = Tensor.cat(frames[0:H:2, 0::2],
+                       frames[1:H:2, 0::2],
+                       frames[0:H:2, 1::2],
+                       frames[1:H:2, 1::2],
+                       frames[H:H+H//4].reshape((H//2, W//2)),
+                       frames[H+H//4:H+H//2].reshape((H//2, W//2)), dim=0).reshape((6, H//2, W//2))
+  return in_img1
+
+
+def make_frame_prepare(nv12: NV12Frame, model_w, model_h):
+  cam_w, cam_h, stride, y_height, uv_height, _ = nv12
+  uv_offset = stride * y_height
+  stride_pad = stride - cam_w
+
+  def frame_prepare_tinygrad(input_frame, M_inv):
+    # UV_SCALE @ M_inv @ UV_SCALE_INV simplifies to elementwise scaling
+    M_inv_uv = M_inv * Tensor([[1.0, 1.0, 0.5], [1.0, 1.0, 0.5], [2.0, 2.0, 1.0]], device=Device.DEFAULT)
+    # deinterleave NV12 UV plane (UVUV... -> separate U, V)
+    uv = input_frame[uv_offset:uv_offset + uv_height * stride].reshape(uv_height, stride)
+    with Context(SPLIT_REDUCEOP=0):
+      y = warp_perspective_tinygrad(input_frame[:cam_h*stride],
+                                    M_inv, (model_w, model_h),
+                                    (cam_h, cam_w), stride_pad).realize()
+      u = warp_perspective_tinygrad(uv[:cam_h//2, :cam_w:2].flatten(),
+                                    M_inv_uv, (model_w//2, model_h//2),
+                                    (cam_h//2, cam_w//2), 0).realize()
+      v = warp_perspective_tinygrad(uv[:cam_h//2, 1:cam_w:2].flatten(),
+                                    M_inv_uv, (model_w//2, model_h//2),
+                                    (cam_h//2, cam_w//2), 0).realize()
+    yuv = y.cat(u).cat(v).reshape((model_h * 3 // 2, model_w))
+    tensor = frames_to_tensor(yuv)
+    return tensor
+  return frame_prepare_tinygrad
+
+
+def get_policy_npy_shapes(input_shapes):
+  dp = input_shapes['desire_pulse']  # (1, 25, 8)
+  tc = input_shapes['traffic_convention']  # (1, 2)
+  at = input_shapes['action_t']  # (1, 2)
+  fb = input_shapes['features_buffer']  # (1, T-1, ...) e.g. (1, 24, 32, 512) with spatial features
+  feat_dim = math.prod(fb[2:])
+  # TODO prev_feat shouldn't exist and be handled inside the JIT, but corrupt on QCOM for now
+  shapes = {'desire': (dp[2],), 'traffic_convention': tuple(tc), 'action_t': tuple(at), 'prev_feat': (fb[0], feat_dim)}
+  return shapes, [math.prod(s) for s in shapes.values()]
+
+
+def make_input_queues(input_shapes, frame_skip, device, frame_copy_size):
+  img = input_shapes['img']  # (1, 12, 128, 256)
+  fb = input_shapes['features_buffer']  # (1, T-1, ...), past features only; the model appends the current frame's feature
+  feat_dim = math.prod(fb[2:])
+  dp = input_shapes['desire_pulse']  # (1, 25, 8)
+  n_frames = img[1] // 6
+  img_buf_shape = (frame_skip * (n_frames - 1) + 1, 6, img[2], img[3])
+
+  policy_shapes, _ = get_policy_npy_shapes(input_shapes)
+  shapes = {'tfm': (3, 3), 'big_tfm': (3, 3)} | policy_shapes
+  sizes = [math.prod(s) for s in shapes.values()]
+  packed_npy_size = sum(sizes) * np.dtype(np.float32).itemsize
+  packed_input = np.zeros(packed_npy_size + 2 * frame_copy_size, dtype=np.uint8)
+  packed_npy_inputs = packed_input[:packed_npy_size].view(np.float32)
+  frames = packed_input[packed_npy_size:]
+  frame_views = {'img': frames[:frame_copy_size], 'big_img': frames[frame_copy_size:]}
+  # views into the packed inputs, to be refilled at runtime
+  npy = {k: v.reshape(s) for (k, s), v in zip(shapes.items(), np.split(packed_npy_inputs, np.cumsum(sizes[:-1])), strict=True)}
+  input_queues = {
+    'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
+    'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
+    'feat_q': Tensor(np.zeros((frame_skip * fb[1], fb[0], feat_dim), dtype=np.float32), device=device).contiguous().realize(),
+    'desire_q': Tensor(np.zeros((frame_skip * dp[1], dp[0], dp[2]), dtype=np.float32), device=device).contiguous().realize(),
+    'packed_npy_inputs': Tensor(packed_input, device='NPY').realize(),
+  }
+  return input_queues, npy, frame_views
+
+
+def shift_and_sample(buf, new_val, sample_fn):
+  buf.assign(buf[1:].cat(new_val, dim=0).contiguous())
+  return sample_fn(buf)
+
+
+def sample_skip(buf, frame_skip):
+  return buf[::frame_skip].contiguous().flatten(0, 1).unsqueeze(0)
+
+
+def sample_desire(buf, frame_skip):
+  return buf.reshape(-1, frame_skip, *buf.shape[1:]).max(1).flatten(0, 1).unsqueeze(0)
+
+
+def make_warp(nv12, model_w, model_h):
+  frame_prepare = make_frame_prepare(nv12, model_w, model_h)
+
+  def warp(tfm, big_tfm, frame, big_frame):
+    tfm = tfm.to(Device.DEFAULT)
+    big_tfm = big_tfm.to(Device.DEFAULT)
+    frame = frame.to(Device.DEFAULT)
+    big_frame = big_frame.to(Device.DEFAULT)
+    Tensor.realize(tfm, big_tfm, frame, big_frame)
+
+    warped_frame = frame_prepare(frame, tfm).unsqueeze(0)
+    warped_big_frame = frame_prepare(big_frame, big_tfm).unsqueeze(0)
+    return Tensor.cat(warped_frame, warped_big_frame)
+
+  return warp
+
+
+def make_run_policy(model_runner, model_metadata, frame_skip):
+  sample_desire_fn = partial(sample_desire, frame_skip=frame_skip)
+  sample_skip_fn = partial(sample_skip, frame_skip=frame_skip)
+  npy_shapes, npy_sizes = get_policy_npy_shapes(model_metadata['input_shapes'])
+  model_input_dtypes = {name: spec.dtype for name, spec in model_runner.graph_inputs.items()}
+
+  def run_policy(warped, img_q, big_img_q, feat_q, desire_q, packed_npy_inputs):
+    packed_npy_inputs = packed_npy_inputs.to(Device.DEFAULT)
+    Tensor.realize(packed_npy_inputs, warped)
+
+    img = shift_and_sample(img_q, warped[0:1], sample_skip_fn)
+    big_img = shift_and_sample(big_img_q, warped[1:2], sample_skip_fn)
+
+    desire, traffic_convention, action_t, prev_feat = (t.reshape(s) for t, s in zip(packed_npy_inputs.split(npy_sizes), npy_shapes.values(), strict=True))
+    desire_buf = shift_and_sample(desire_q, desire.reshape(1, 1, -1), sample_desire_fn)
+    feat_buf = shift_and_sample(feat_q, prev_feat.reshape(1, 1, -1), sample_skip_fn)
+
+    inputs = {
+      'img': img,
+      'big_img': big_img,
+      'features_buffer': feat_buf.reshape(model_metadata['input_shapes']['features_buffer']),
+      'desire_pulse': desire_buf,
+      'traffic_convention': traffic_convention,
+      'action_t': action_t,
+    }
+    inputs = {name: value.cast(model_input_dtypes[name]) for name, value in inputs.items()}
+    out = next(iter(model_runner(inputs).values())).cast('float32')
+    return out,
+  return run_policy
+
+
+def make_run_model(warp, run_policy, model_metadata, frame_copy_size):
+  _, policy_sizes = get_policy_npy_shapes(model_metadata['input_shapes'])
+  packed_npy_size = (18 + sum(policy_sizes)) * np.dtype(np.float32).itemsize
+
+  def run_model(img_q, big_img_q, feat_q, desire_q, packed_npy_inputs):
+    packed_input = packed_npy_inputs.to(Device.DEFAULT)
+    Tensor.realize(packed_input)
+    packed_npy_inputs = packed_input[:packed_npy_size].bitcast('float32')
+    frame = packed_input[packed_npy_size:packed_npy_size + frame_copy_size]
+    big_frame = packed_input[packed_npy_size + frame_copy_size:]
+    tfm, big_tfm, policy_inputs = packed_npy_inputs.split([9, 9, sum(policy_sizes)])
+    warped = warp(tfm.reshape(3, 3), big_tfm.reshape(3, 3), frame, big_frame)
+    return run_policy(warped, img_q, big_img_q, feat_q, desire_q, policy_inputs)
+  return run_model
+
+
+def compile_jit(jit, input_keys, make_queues, benchmark_runs):
+  if benchmark_runs < 1:
+    raise ValueError("benchmark_runs must be at least 1")
+
+  SEED = 42
+  def random_inputs_run(fn, seed, n_runs, test_val=None, test_buffers=None, expect_match=True):
+    input_queues, npy, frame_views = make_queues(Device.DEFAULT)
+    rng = np.random.default_rng(seed)
+
+    for i in range(n_runs):
+      for v in npy.values():
+        v[:] = rng.standard_normal(v.shape).astype(v.dtype)
+      for v in frame_views.values():
+        v[:] = rng.integers(0, 256, size=v.shape, dtype=np.uint8)
+      Device.default.synchronize()
+      st = time.perf_counter()
+      outs = fn(**{k: input_queues[k] for k in input_keys})
+      mt = time.perf_counter()
+      Device.default.synchronize()
+      et = time.perf_counter()
+      print(f"  [{i+1}/{n_runs}] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")
+
+      if i == 0:
+        val = [np.copy(v.numpy()) for v in outs]
+        buffers = [np.copy(v.numpy().copy()) for v in input_queues.values()]
+
+    if test_val is not None:
+      match = all(np.array_equal(a, b) for a, b in zip(val, test_val, strict=True))
+      assert match == expect_match, f"outputs {'differ from' if expect_match else 'match'} baseline (seed={seed})"
+    if test_buffers is not None:
+      match = all(np.array_equal(a, b) for a, b in zip(buffers, test_buffers, strict=True))
+      assert match == expect_match, f"buffers {'differ from' if expect_match else 'match'} baseline (seed={seed})"
+    return val, buffers
+
+  print('capture + replay')
+  test_val, test_buffers = random_inputs_run(jit, SEED, 3)
+  print(f'pickle round trip ({benchmark_runs} runs per seed)')
+  with tempfile.TemporaryFile(dir=".") as f:
+    dump_oob(jit, f)
+    f.seek(0)
+    loaded_jit = load_oob(f)
+  random_inputs_run(loaded_jit, SEED, benchmark_runs, test_val, test_buffers, expect_match=True)
+  random_inputs_run(loaded_jit, SEED+1, benchmark_runs, test_val, test_buffers, expect_match=False)
+  # Keep the original so per-resolution JITs share model weight buffers in the final pickle.
+  return jit
+
+
+def _parse_size(s):
+  w, h = s.lower().split('x')
+  return int(w), int(h)
+
+
+def read_file_chunked_to_disk(path):
+  from openpilot.common.file_chunker import open_file_chunked
+  tmp_path = f'{path}.unchunked'
+  with open(tmp_path, 'wb') as f, open_file_chunked(path) as src:
+    shutil.copyfileobj(src, f)
+  atexit.register(lambda: os.path.exists(tmp_path) and os.remove(tmp_path))
+  return tmp_path
+
+
+if __name__ == "__main__":
+  from tinygrad.nn.onnx import OnnxRunner
+  from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+  from openpilot.selfdrive.modeld.get_model_metadata import make_metadata_dict
+  p = argparse.ArgumentParser()
+  p.add_argument('--model-size', type=_parse_size, required=True, help='model input WxH')
+  p.add_argument('--camera-resolutions', type=_parse_size, nargs='+', required=True,
+                 help='camera resolutions WxH (one or more)')
+  p.add_argument('--onnx', required=True)
+  p.add_argument('--output', required=True)
+  p.add_argument('--frame-skip', type=int, required=True)
+  p.add_argument('--benchmark-runs', type=int, default=1,
+                 help='timed loaded-JIT runs for each correctness seed')
+  args = p.parse_args()
+
+  model_path = read_file_chunked_to_disk(args.onnx)
+  model_w, model_h = args.model_size
+
+  model_runner = OnnxRunner(model_path)
+  out = {
+    'metadata': make_metadata_dict(model_path),
+    'input_devices': {'model': Device.DEFAULT},
+    'run_model': {},
+  }
+
+  run_policy = make_run_policy(model_runner, out['metadata'], args.frame_skip)
+
+  for cam_w, cam_h in args.camera_resolutions:
+    nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
+    frame_copy_size = nv12_copy_size(nv12.stride, nv12.y_height, nv12.uv_height)
+    make_model_queues = partial(make_input_queues, out['metadata']['input_shapes'], args.frame_skip,
+                                frame_copy_size=frame_copy_size)
+    warp = make_warp(nv12, model_w, model_h)
+    run_model_jit = TinyJit(make_run_model(warp, run_policy, out['metadata'], frame_copy_size), prune=True)
+    out['run_model'][(cam_w,cam_h)] = compile_jit(run_model_jit, MODELD_INPUTS, make_model_queues,
+                                                  args.benchmark_runs)
+
+  with open(args.output, "wb") as f:
+    dump_oob(out, f)
+  print(f"Saved JITs to {args.output} ({os.path.getsize(args.output) / 1e6:.2f} MB)")

openpilot/selfdrive/modeld/dmonitoringmodeld.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
 import os
-import base64
-from openpilot.selfdrive.modeld.helpers import MODELS_DIR, load_oob
+from openpilot.selfdrive.modeld.helpers import MODELS_DIR, get_tg_input_devices
 from tinygrad.tensor import Tensor
 import time
 import pickle
@@ -16,10 +15,13 @@ from openpilot.common.realtime import config_realtime_process
 from openpilot.common.transformations.model import dmonitoringmodel_intrinsics
 from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
 from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+from openpilot.common.file_chunker import open_file_chunked
 from openpilot.selfdrive.modeld.parse_model_outputs import sigmoid, safe_exp
 
+PROCESS_NAME = "openpilot.selfdrive.modeld.dmonitoringmodeld"
 SEND_RAW_PRED = os.getenv('SEND_RAW_PRED')
 MODEL_PKL_PATH = MODELS_DIR / 'dmonitoring_model_tinygrad.pkl'
+METADATA_PATH = MODELS_DIR / 'dmonitoring_model_metadata.pkl'
 
 
 class ModelState:
@@ -27,10 +29,11 @@ class ModelState:
   output: np.ndarray
 
   def __init__(self, cam_w: int, cam_h: int):
-    jits = load_oob(MODEL_PKL_PATH)
-    self.DEV = jits['input_specs']['input_img'][2]
-    self.input_shapes = jits['metadata']['input_shapes']
-    self.output_slices = pickle.loads(base64.b64decode(jits['metadata']['metadata']['output_slices']))
+    self.DEV = get_tg_input_devices(PROCESS_NAME, chestnut=False)['DEV']
+    with open(METADATA_PATH, 'rb') as f:
+      model_metadata = pickle.load(f)
+      self.input_shapes = model_metadata['input_shapes']
+      self.output_slices = model_metadata['output_slices']
 
     self.numpy_inputs = {
       'calib': np.zeros(self.input_shapes['calib'], dtype=np.float32),
@@ -39,19 +42,16 @@ class ModelState:
     self.warp_inputs_np = {'transform': np.zeros((3,3), dtype=np.float32)}
     self.warp_inputs = {k: Tensor(v, device='NPY') for k,v in self.warp_inputs_np.items()}
     self.frame_buf_params = get_nv12_info(cam_w, cam_h)
-    self.tensor_inputs = {k: Tensor(v, device=self.DEV).realize() for k,v in self.numpy_inputs.items()}
-    self.calib_host = Tensor(self.numpy_inputs['calib'], device='NPY')._buffer()
+    self.tensor_inputs = {k: Tensor(v, device='NPY').realize() for k,v in self.numpy_inputs.items()}
     self._blob_cache : dict[int, Tensor] = {}
-    self.model_run = jits['run']
-    self.outputs = {name: Tensor(np.zeros(shape, dtype=dtype), device=device).realize() for name, (shape, dtype, device) in jits['output_specs'].items()}
+    self.model_run = pickle.load(open_file_chunked(str(MODEL_PKL_PATH)))
     with open(MODELS_DIR / f'dm_warp_{cam_w}x{cam_h}_tinygrad.pkl', "rb") as f:
-      self.image_warp = pickle.load(f)['run']
+      self.image_warp = pickle.load(f)
 
   def run(self, buf: VisionBuf, calib: np.ndarray, transform: np.ndarray) -> tuple[np.ndarray, float]:
     self.numpy_inputs['calib'][0,:] = calib
 
     t1 = time.perf_counter()
-    self.tensor_inputs['calib']._buffer().copy_from(self.calib_host)
 
     ptr = np.frombuffer(buf.data, dtype=np.uint8).ctypes.data
     # There is a ringbuffer of imgs, just cache tensors pointing to all of them
@@ -59,10 +59,9 @@ class ModelState:
       self._blob_cache[ptr] = Tensor.from_blob(ptr, (self.frame_buf_params[3],), dtype='uint8', device=self.DEV)
 
     self.warp_inputs_np['transform'][:] = transform[:]
-    self.tensor_inputs['input_img'] = self.image_warp(input_frame=self._blob_cache[ptr], M_inv=self.warp_inputs['transform'])
+    self.tensor_inputs['input_img'] = self.image_warp(self._blob_cache[ptr], self.warp_inputs['transform'])
 
-    self.model_run(output_buffers=self.outputs, **self.tensor_inputs)
-    output = self.outputs['outputs'].numpy().astype(np.float32).reshape(-1)
+    output = self.model_run(**self.tensor_inputs).numpy().flatten()
 
     t2 = time.perf_counter()
     return output, t2 - t1

openpilot/selfdrive/modeld/get_model_metadata.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+import sys
+import pathlib
+import codecs
+import pickle
+from typing import Any
+
+from tinygrad.nn.onnx import OnnxPBParser
+
+
+class MetadataOnnxPBParser(OnnxPBParser):
+  def _parse_ModelProto(self) -> dict:
+    obj: dict[str, Any] = {"graph": {"input": [], "output": []}, "metadata_props": []}
+    for fid, wire_type in self._parse_message(self.reader.len):
+      match fid:
+        case 7:
+          obj["graph"] = self._parse_GraphProto()
+        case 14:
+          obj["metadata_props"].append(self._parse_StringStringEntryProto())
+        case _:
+          self.reader.skip_field(wire_type)
+    return obj
+
+
+def get_name_and_shape(value_info: dict[str, Any]) -> tuple[str, tuple[int, ...]]:
+  shape = tuple(int(dim) if isinstance(dim, int) else 0 for dim in value_info["parsed_type"].shape)
+  name = value_info["name"]
+  return name, shape
+
+
+def get_metadata_value_by_name(model: dict[str, Any], name: str) -> str | Any:
+  for prop in model["metadata_props"]:
+    if prop["key"] == name:
+      return prop["value"]
+  return None
+
+
+def make_metadata_dict(model_path):
+  model = MetadataOnnxPBParser(model_path).parse()
+  output_slices = get_metadata_value_by_name(model, 'output_slices')
+  assert output_slices is not None, 'output_slices not found in metadata'
+  return {
+    'model_checkpoint': get_metadata_value_by_name(model, 'model_checkpoint'),
+    'output_slices': pickle.loads(codecs.decode(output_slices.encode(), "base64")),
+    'input_shapes': dict(get_name_and_shape(x) for x in model["graph"]["input"]),
+    'output_shapes': dict(get_name_and_shape(x) for x in model["graph"]["output"]),
+  }
+
+
+if __name__ == "__main__":
+  model_path = pathlib.Path(sys.argv[1])
+  metadata_path = model_path.parent / (model_path.stem + '_metadata.pkl')
+  with open(metadata_path, 'wb') as f:
+    pickle.dump(make_metadata_dict(model_path), f)
+  print(f'saved metadata to {metadata_path}')

openpilot/selfdrive/modeld/helpers.py

@@ -1,34 +1,51 @@
 import io
-import os
+import json
 import pickle
+import shutil
 import struct
-import sys
+import tempfile
 from pathlib import Path
 
-from openpilot.common.file_chunker import get_chunk_name, get_manifest_path, open_file_chunked
-from openpilot.common.hardware import AGNOS
+from openpilot.common.file_chunker import get_manifest_path
 from openpilot.common.hardware.usb import CHESTNUT_USB_PRODUCT, USB_DEVICES_PATH, is_chestnut_usb_id
 
 MODELS_DIR = Path(__file__).resolve().parent / 'models'
+TG_INPUT_DEVICES_PATH = MODELS_DIR / 'tg_input_devices.json'
+CHESTNUT_POWERED_VOLTAGE = 5000
+CHESTNUT_PCIE_READY = 0x78
 
 
+def get_tg_input_devices(process_name: str, chestnut: bool):
+  with open(TG_INPUT_DEVICES_PATH) as f:
+    return json.load(f)[process_name]['default' if not chestnut else 'chestnut']
+
 def modeld_pkl_path(chestnut: bool):
   prefix = 'big_' if chestnut else ''
   return MODELS_DIR / f'{prefix}driving_tinygrad.pkl'
 
-def load_oob(path, chestnut=False):
-  from tinygrad import Context, Device
-  from tinygrad.device import Buffer
-  device = 'USB+AMD:LLVM' if chestnut else 'QCOM' if AGNOS else 'METAL' if sys.platform == 'darwin' else 'CPU:LLVM'
-  chunks = 0 if os.path.isfile(path) else int(Path(get_manifest_path(path)).read_text())
-  paths = [get_chunk_name(path, i, chunks) for i in range(chunks)] or [path]
-  with Context(DEV=device), open_file_chunked(path) as f:
-    opcodes = f.read(struct.unpack('<q', f.read(8))[0])
-    buffers, stage = Buffer(Device.DEFAULT, sum(map(os.path.getsize, paths)) - 8 - len(opcodes)).ensure_allocated(), bytearray(64 << 20)
-    for offset in range(0, buffers.nbytes, len(stage)):
-      n = f.readinto(piece := memoryview(stage)[:min(len(stage), buffers.nbytes - offset)])
-      buffers.view(n, offset).ensure_allocated().copy_from(Buffer("PYTHON", n, initial_value=piece[:n]))
-    return type("_Unpickler", (pickle.Unpickler,), {"persistent_load": lambda self, pid: buffers.view(*pid)})(io.BytesIO(opcodes)).load()
+def dump_oob(obj, f):
+  with tempfile.TemporaryFile(dir=".") as tmp:
+    def buffer_callback(pb: pickle.PickleBuffer):
+      m = pb.raw()
+      tmp.write(struct.pack('<q', m.nbytes))
+      tmp.write(m)
+      pb.release() # keep peak ram at ~1 buffer
+    stream = io.BytesIO()
+    pickle.Pickler(stream, protocol=5, buffer_callback=buffer_callback).dump(obj)
+    opcodes = stream.getvalue()
+    f.write(struct.pack('<q', len(opcodes)))
+    f.write(opcodes)
+    tmp.seek(0)
+    shutil.copyfileobj(tmp, f)
+
+def load_oob(f):
+  opcodes = f.read(struct.unpack('<q', f.read(8))[0])
+  def buffers():
+    while (h := f.read(8)):
+      pb = pickle.PickleBuffer(bytearray(struct.unpack('<q', h)[0]))
+      f.readinto(pb)
+      yield pb
+  return pickle.load(io.BytesIO(opcodes), buffers=buffers())
 
 def chestnut_present() -> bool:
   for d in USB_DEVICES_PATH.glob("*"):
@@ -42,6 +59,8 @@ def chestnut_present() -> bool:
   return False
 
 def chestnut_compiled() -> bool:
-  path = modeld_pkl_path(chestnut=True)
-  return (path.is_file() or Path(get_manifest_path(path)).is_file()) and all(
-    (MODELS_DIR / f'big_driving_warp_{size}_tinygrad.pkl').is_file() for size in ('1344x760', '1928x1208'))
+  return Path(get_manifest_path(modeld_pkl_path(chestnut=True))).is_file()
+
+
+def chestnut_ready(state) -> bool:
+  return state.supplyVoltage >= CHESTNUT_POWERED_VOLTAGE and not state.supplyFault and state.pcieLtssm == CHESTNUT_PCIE_READY

openpilot/selfdrive/modeld/modeld.py

@@ -1,18 +1,12 @@
 #!/usr/bin/env python3
 from collections.abc import Callable
-import base64
 import ctypes
 from functools import cached_property
 import os
 os.environ['GMMU'] = '0' # for chestnut fast loading, noop for qcom
-from tinygrad.device import Buffer, Device
-from tinygrad.engine.realize import lower_and_compile
-from tinygrad.dtype import DType, dtypes
-from tinygrad.tensor import Tensor
-from tinygrad.helpers import round_up
-from tinygrad.uop.ops import UOp
-import math
-import pickle
+from tinygrad.device import Device
+import usb1
+import struct
 import threading
 import time
 import numpy as np
@@ -34,9 +28,13 @@ from openpilot.common.transformations.model import get_warp_matrix
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.selfdrive.controls.lib.drive_helpers import get_accel_from_plan, should_stop, smooth_value, get_curvature_from_plan
 from openpilot.selfdrive.modeld.parse_model_outputs import Parser
+from openpilot.selfdrive.modeld.compile_modeld import make_input_queues, nv12_copy_size, MODELD_INPUTS
 from openpilot.selfdrive.modeld.fill_model_msg import fill_model_msg, fill_driving_model_data, fill_pose_msg, PublishState
+from openpilot.common.file_chunker import open_file_chunked
+from openpilot.common.hardware.usb import CHESTNUT_USB_IDS
 from openpilot.selfdrive.modeld.constants import ModelConstants, Plan
-from openpilot.selfdrive.modeld.helpers import MODELS_DIR, chestnut_present, chestnut_compiled, modeld_pkl_path, load_oob
+from openpilot.selfdrive.modeld.helpers import chestnut_present, chestnut_compiled, chestnut_ready, modeld_pkl_path, load_oob
+
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
 from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
@@ -77,14 +75,45 @@ def get_action_from_model(model_output: dict[str, np.ndarray], prev_action: log.
                                 shouldStop=bool(stop))
 
 
-class ChestnutGpuState:
-  # GPU metrics require modeld's GPU context
+class ChestnutState:
+  # only modeld can access chestnut
   def __init__(self, pm: PubMaster, big: bool):
     self.pm = pm
     self.big = big
     self.valid = True
     self.sends = 0
     self.metrics = {}
+    self._asm_usb = None
+
+  def _close_asm_usb(self) -> None:
+    if self._asm_usb is not None:
+      self._asm_usb.close()
+      self._asm_usb = None
+
+  def _open_asm_usb(self):
+    context = usb1.USBContext()
+    for vendor_id, product_id in CHESTNUT_USB_IDS:
+      if (handle := context.openByVendorIDAndProductID(vendor_id, product_id, skip_on_error=True)) is not None:
+        return handle
+    context.close()
+
+  def _read_ina(self) -> tuple[int, int, bool]:
+    if "AMD" in Device._opened_devices and self._asm_usb is None:
+      try:
+        raw = Device["AMD"].iface.pci_dev.usb.usb.control_read(0xC0, 5)
+        return struct.unpack('<Hh?', bytes(raw))
+      except Exception:
+        pass
+    if self._asm_usb is None:
+      self._asm_usb = self._open_asm_usb()
+    if self._asm_usb is None:
+      raise usb1.USBErrorNoDevice
+    try:
+      raw = self._asm_usb.controlRead(0xC0, 0xC0, 0, 0, 5, timeout=100)
+    except usb1.USBError:
+      self._close_asm_usb()
+      raise
+    return struct.unpack('<Hh?', bytes(raw))
 
   @cached_property
   def power_limit(self) -> int:
@@ -92,8 +121,8 @@ class ChestnutGpuState:
     return smu._send_msg(smu.smu_mod.PPSMC_MSG_GetPptLimit, 0, read_back_arg=True, timeout=100)
 
   def send(self) -> None:
-    msg = messaging.new_message('chestnutGpuState')
-    state = msg.chestnutGpuState
+    msg = messaging.new_message('chestnutState')
+    state = msg.chestnutState
     self.sends += 1
     if self.big and "AMD" in Device._opened_devices and self.sends % 100 == 1:
       try:
@@ -119,8 +148,21 @@ class ChestnutGpuState:
       for k, v in self.metrics.items():
         setattr(state, k, v)
 
-    msg.valid = not self.big or (self.valid and bool(self.metrics))
-    self.pm.send('chestnutGpuState', msg)
+    asm_valid = False
+    try:
+      # ASM runs on USB-C power, these still read without a gpu
+      state.supplyVoltage, state.supplyCurrent, state.supplyFault = self._read_ina()
+      asm_valid = True
+    except Exception:
+      pass
+    if "AMD" in Device._opened_devices:
+      try:
+        state.pcieLtssm = Device["AMD"].iface.pci_dev.usb.read(0xB450, 1)[0]
+      except Exception:
+        pass
+
+    msg.valid = asm_valid and (not self.big or self.valid)
+    self.pm.send('chestnutState', msg)
 
 
 class FrameMeta:
@@ -133,67 +175,37 @@ class FrameMeta:
       self.frame_id, self.timestamp_sof, self.timestamp_eof = vipc.frame_id, vipc.timestamp_sof, vipc.timestamp_eof
 
 
-def input_view(buffer: Buffer, shape: tuple[int, ...], dtype: DType, offset: int) -> Tensor:
-  view = buffer.view(math.prod(shape) * dtype.itemsize, offset).ensure_allocated()
-  return Tensor(UOp.from_buffer(view, dtype)).reshape(shape)
-
-
 class ModelState(ModelStateBase):
   prev_desire: np.ndarray  # for tracking the rising edge of the pulse
 
   def __init__(self, cam_w: int, cam_h: int, chestnut: bool):
     ModelStateBase.__init__(self)
-    jits = load_oob(modeld_pkl_path(chestnut), chestnut)
-    self.model_device = jits['input_specs']['new_img'][2]
-    self.input_shapes = {name: (shape, np.dtype(dtype)) for name, (shape, dtype, _) in jits['input_specs'].items()}
-    self.state_pairs = {name: f'next_{name}' for name in self.input_shapes if f'next_{name}' in jits['metadata']['output_shapes']}
-    self.vision_input_names = ('img', 'big_img')
-    self.output_slices = pickle.loads(base64.b64decode(jits['metadata']['metadata']['output_slices']))
+    jits = load_oob(open_file_chunked(modeld_pkl_path(chestnut)))
+    input_devices = jits['input_devices']
+    self.model_device = input_devices['model']
+    metadata = jits['metadata']
+    self.input_shapes = metadata['input_shapes']
+    self.vision_input_names = [k for k in self.input_shapes if 'img' in k]
+    self.output_slices = metadata['output_slices']
 
     self.prev_desire = np.zeros(ModelConstants.DESIRE_LEN, dtype=np.float32)
     self.chestnut = chestnut
 
-    stride, y_height, uv_height, _ = get_nv12_info(cam_w, cam_h)
-    self.frame_copy_size = stride * (y_height + uv_height)
-    self.pack_inputs()
-    with open(MODELS_DIR / f'{"big_" if chestnut else ""}driving_warp_{cam_w}x{cam_h}_tinygrad.pkl', 'rb') as f:
-      self.run_warp = pickle.load(f)['run']
-    self.run_warp.captured._linear = lower_and_compile(self.run_warp.captured._linear)
-    self.run_model = jits['run']
-    self.run_model.captured._linear = lower_and_compile(self.run_model.captured._linear)
-    self.outputs = {name: Tensor(np.zeros(shape, dtype=dtype), device=device).realize() for name, (shape, dtype, device) in jits['output_specs'].items()}
-    for name, next_name in self.state_pairs.items():
-      state = self.input_queues[name]
-      self.outputs[next_name] = input_view(state._buffer(), state.shape, state.dtype, 0)
+    self.frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ
+    self.frame_copy_size = nv12_copy_size(*get_nv12_info(cam_w, cam_h)[:3])
+    self.input_queues, self.npy, self.frame_views = make_input_queues(
+      self.input_shapes, self.frame_skip, device=self.model_device, frame_copy_size=self.frame_copy_size)
     self.parser = Parser()
-
-  def pack_inputs(self) -> None:
-    # Pack host inputs into one upload to reduce USB transfer overhead for the eGPU.
-    self.input_queues = {name: Tensor(np.zeros(shape, dtype=dtype), device=self.model_device).realize()
-                         for name, (shape, dtype) in self.input_shapes.items() if name in self.state_pairs}
-    shapes = {'tfm': (2, 3, 3)} | {name: shape for name, (shape, _) in self.input_shapes.items()
-                                   if name not in self.state_pairs and name != 'new_img'}
-    npy_size = sum(round_up(math.prod(shape) * 4, 128) for shape in shapes.values())
-    self.packed_input = np.zeros(npy_size + 2 * self.frame_copy_size, dtype=np.uint8)
-    self.input_host = Tensor(self.packed_input, device='NPY')._buffer()
-    self.input_device = Tensor(self.packed_input, device=self.model_device)._buffer()
-    self.npy = {}
-    offset = 0
-    for name, shape in shapes.items():
-      self.npy[name] = np.ndarray(shape, dtype=np.float32, buffer=self.packed_input, offset=offset)
-      self.input_queues[name] = input_view(self.input_device, shape, dtypes.float32, offset)
-      offset += round_up(self.npy[name].nbytes, 128)
-    self.frames = self.packed_input[npy_size:].reshape(2, self.frame_copy_size)
-    self.warp_inputs = {'input_frame': input_view(self.input_device, self.frames.shape, dtypes.uint8, npy_size), 'M_inv': self.input_queues.pop('tfm')}
+    self.run_model = jits['run_model'][(cam_w,cam_h)]
 
   def slice_outputs(self, model_outputs: np.ndarray, output_slices: dict[str, slice]) -> dict[str, np.ndarray]:
-    return {k: model_outputs[np.newaxis, v] for k,v in output_slices.items()}
+    parsed_model_outputs = {k: model_outputs[np.newaxis, v] for k,v in output_slices.items()}
+    return parsed_model_outputs
 
   def run(self, bufs: dict[str, VisionBuf], transforms: dict[str, np.ndarray],
           inputs: dict[str, np.ndarray], after_enqueue: Callable[[], None] | None = None) -> dict[str, np.ndarray]:
-    for i, key in enumerate(self.vision_input_names):
-      np.copyto(self.frames[i], np.frombuffer(bufs[key].data, dtype=np.uint8, count=self.frame_copy_size))
-      self.npy['tfm'][i] = transforms[key]
+    for key, buf in bufs.items():
+      np.copyto(self.frame_views[key], np.frombuffer(buf.data, dtype=np.uint8, count=self.frame_copy_size))
 
     # Model decides when action is completed, so desire input is just a pulse triggered on rising edge
     inputs['desire_pulse'][0] = 0
@@ -201,16 +213,17 @@ class ModelState(ModelStateBase):
     self.prev_desire[:] = inputs['desire_pulse']
     self.npy['traffic_convention'][:] = inputs['traffic_convention']
     self.npy['action_t'][:] = inputs['action_t']
+    self.npy['tfm'][:,:] = transforms['img'][:,:]
+    self.npy['big_tfm'][:,:] = transforms['big_img'][:,:]
 
-    self.input_device.copy_from(self.input_host)
-    self.input_queues['new_img'] = self.run_warp(**self.warp_inputs)
-    self.run_model(output_buffers=self.outputs, **self.input_queues)
+    outs, = self.run_model(**{k: self.input_queues[k] for k in MODELD_INPUTS})
     if after_enqueue is not None:
       after_enqueue()
-    model_output = self.outputs['outputs'].numpy()[0]
+    model_output = outs.numpy()[0]
     if self.chestnut and not np.all(np.isfinite(model_output)):
       raise RuntimeError("model output not finite")
     outputs_dict = self.parser.parse_outputs(self.slice_outputs(model_output, self.output_slices))
+    self.npy['prev_feat'][:] = model_output[self.output_slices['hidden_state']]
 
     if SEND_RAW_PRED:
       outputs_dict['raw_pred'] = model_output.copy()
@@ -221,22 +234,33 @@ class ModelState(ModelStateBase):
     eye = np.eye(3, dtype=np.float32)
     dims = {'desire_pulse': ModelConstants.DESIRE_LEN, 'traffic_convention': 2, 'action_t': 2}
     self.run(dummy_frames, dict.fromkeys(self.vision_input_names, eye), {k: np.zeros(v, dtype=np.float32) for k, v in dims.items()})
-    self.packed_input[:] = 0
-    for key in self.state_pairs:
-      self.input_queues[key].assign(0).realize()
+    self.input_queues, self.npy, self.frame_views = make_input_queues(
+      self.input_shapes, self.frame_skip, device=self.model_device, frame_copy_size=self.frame_copy_size)
     self.prev_desire[:] = 0
 
 
 def main(demo=False):
   cloudlog.warning("modeld init")
 
-  CHESTNUT = chestnut_present() and chestnut_compiled()
+  chestnut_available = chestnut_present() and chestnut_compiled()
+  CHESTNUT = False
+  if chestnut_available:
+    poller = messaging.Poller()
+    sock = messaging.sub_sock("chestnutState", poller=poller, conflate=True)
+    deadline = time.monotonic() + 4. / SERVICE_LIST['deviceState'].frequency
+    while not CHESTNUT and (remaining := deadline - time.monotonic()) > 0.:
+      if not poller.poll(round(remaining * 1000)):
+        break
+      msg = messaging.recv_one_or_none(sock)
+      CHESTNUT = msg is not None and msg.valid and chestnut_ready(msg.chestnutState)
   if CHESTNUT:
-    from tinygrad.runtime.ops_amd import AMDDevice
-    AMDDevice.wait_timeout_ms = 3000
+    os.environ['HCQDEV_WAIT_TIMEOUT_MS'] = '3000'
   params = Params()
   params.put_bool("ChestnutLoading", CHESTNUT)
-  params.remove("ChestnutActive")
+  if chestnut_available and not CHESTNUT:
+    params.put_bool("ChestnutActive", False)
+  else:
+    params.remove("ChestnutActive")
 
   config_realtime_process(7, 54)
 
@@ -280,23 +304,27 @@ def main(demo=False):
     loader.start()
     loader.join(BIG_MODEL_TIMEOUT)
     model = big_model
+    if model is None:
+      params.put_bool("ChestnutModelError", True)
     params.put_bool("ChestnutActive", model is not None)
+    if model is not None:
+      params.remove("ChestnutModelError")
 
   small_model = ModelState(vipc_client_main.width, vipc_client_main.height, False) if model is None or CHESTNUT else None
   if model is None:
     model = small_model
-  assert model is not None
   params.put_bool("ChestnutLoading", False)
+  assert model is not None
   cloudlog.warning(f"models loaded in {time.monotonic() - st:.1f}s, modeld starting")
 
   # messaging
-  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutGpuState"] if CHESTNUT else [])
+  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutState"] if CHESTNUT else [])
   pm = PubMaster(pub_socks)
   sm = SubMaster(["deviceState", "carState", "narrowRoadCameraState", "extrinsicsCalibration", "driverMonitoringState", "carControl", "lateralDelay"])
 
   publish_state = PublishState()
   params = Params()
-  chestnut_state = ChestnutGpuState(pm, model.chestnut) if CHESTNUT else None
+  chestnut_state = ChestnutState(pm, model.chestnut) if CHESTNUT else None
 
   # setup filter to track dropped frames
   frame_dropped_filter = FirstOrderFilter(0., 10., 1. / ModelConstants.MODEL_RUN_FREQ)
@@ -407,13 +435,14 @@ def main(demo=False):
     mt1 = time.perf_counter()
     try:
       send_chestnut = (chestnut_state is not None and
-                       run_count % round(ModelConstants.MODEL_RUN_FREQ / SERVICE_LIST['chestnutGpuState'].frequency) == 0)
+                       run_count % round(ModelConstants.MODEL_RUN_FREQ / SERVICE_LIST['chestnutState'].frequency) == 0)
       model_output = model.run(bufs, transforms, inputs, chestnut_state.send if send_chestnut else None)
     except Exception:
       if not params.get_bool("ChestnutActive"):
         raise
       # fallback to small model
       cloudlog.exception("big model failed, fall back to small")
+      params.put_bool("ChestnutModelError", True)
       params.put_bool("ChestnutActive", False)
       assert small_model is not None
       model = small_model
@@ -428,7 +457,6 @@ def main(demo=False):
       modelv2_send = messaging.new_message('modelV2')
       drivingdata_send = messaging.new_message('drivingModelData')
       posenet_send = messaging.new_message('cameraOdometry')
-      mdv2sp_send = messaging.new_message('modelDataV2SP')
 
       action = get_action_from_model(model_output, prev_action, lat_action_t, long_action_t, v_ego)
       prev_action = action
@@ -441,11 +469,11 @@ def main(demo=False):
       l_lane_change_prob = desire_state[log.Desire.laneChangeLeft]
       r_lane_change_prob = desire_state[log.Desire.laneChangeRight]
       lane_change_prob = l_lane_change_prob + r_lane_change_prob
+      mdv2sp_send = messaging.new_message('modelDataV2SP')
       left_edge, right_edge = RELC.update_and_fill(modelv2_send.modelV2, mdv2sp_send.modelDataV2SP, v_ego)
       DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob, left_edge, right_edge)
       modelv2_send.modelV2.meta.laneChangeState = DH.lane_change_state
       modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
-      mdv2sp_send.valid = modelv2_send.valid
       mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction
 
       fill_driving_model_data(drivingdata_send, modelv2_send)

openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx

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

openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl

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

openpilot/selfdrive/modeld/models/driving_supercombo.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:65a08adc31d5c456219687d99b7bf5e44d61dae2d49ea67850e76105c7248cce
-size 60918562
+oid sha256:659727c4d4839adc4992a254409a54259a8756a743f2d567bf5fdc6579f8009b
+size 60881999

openpilot/selfdrive/pandad/__init__.py

@@ -1 +1,3 @@
-from openpilot.selfdrive.pandad.pandad_api_impl import can_list_to_can_capnp as can_list_to_can_capnp, can_capnp_to_list as can_capnp_to_list
+from openpilot.selfdrive.pandad.pandad_api_impl import can_list_to_can_capnp, can_capnp_to_list
+assert can_list_to_can_capnp
+assert can_capnp_to_list

openpilot/selfdrive/pandad/pandad.cc

@@ -342,8 +342,8 @@ void process_peripheral_state(Panda *panda, PubMaster *pm, bool no_fan_control,
       }
     }
 
-    // Disable IR on input timeout or when requested offroad.
-    if (nanos_since_boot() - last_cabin_camera_t > 1e9 || (!is_onroad && params.getBool("DisableDriverCameraIR"))) {
+    // Disable IR on input timeout
+    if (nanos_since_boot() - last_cabin_camera_t > 1e9) {
       ir_pwr = 0;
     }
 

openpilot/selfdrive/selfdrived/selfdrived.py

@@ -453,12 +453,11 @@ class SelfdriveD(CruiseHelper):
       self.logged_comm_issue = None
 
     if not self.CP.notCar and not big_model_settling:  # localization has nothing to work with during the load
-      # the defaults of a message that was never received are not a localizer failure
-      if self.sm.seen['deviceMotion'] and not self.sm['deviceMotion'].posenetOK:
+      if not self.sm['deviceMotion'].posenetOK:
         self.events.add(EventName.posenetInvalid)
-      if self.sm.seen['deviceMotion'] and not self.sm['deviceMotion'].inputsOK:
+      if not self.sm['deviceMotion'].inputsOK:
         self.events.add(EventName.locationdTemporaryError)
-      if (self.sm.seen['vehicleParameters'] and not self.sm['vehicleParameters'].valid and cal_status == log.ExtrinsicsCalibration.Status.calibrated and
+      if (not self.sm['vehicleParameters'].valid and cal_status == log.ExtrinsicsCalibration.Status.calibrated and
           not TESTING_CLOSET and (not SIMULATION or REPLAY)):
         self.events.add(EventName.paramsdTemporaryError)
 

openpilot/selfdrive/test/chestnut.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-sudo python3 openpilot/system/hardware/chestnut/flash.py
-
-SCONSFLAGS="-j4" ./openpilot/system/manager/build.py

openpilot/selfdrive/test/process_replay/model_replay.py

@@ -20,13 +20,11 @@ from openpilot.tools.lib.framereader import FrameReader
 from openpilot.tools.lib.logreader import LogReader, save_log
 from openpilot.tools.lib.github_utils import GithubUtils
 
-TEST_ROUTE = "98395b7c5b27882e|0000002b--2686b5a2d0"
-SEGMENT = 1
+TEST_ROUTE = "8494c69d3c710e81|000001d4--2648a9a404"
+SEGMENT = 4
 START_FRAME = 0
 END_FRAME = 60
 
-CHESTNUT = "--chestnut" in sys.argv
-
 SEND_EXTRA_INPUTS = bool(int(os.getenv("SEND_EXTRA_INPUTS", "0")))
 
 DATA_TOKEN = os.getenv("CI_ARTIFACTS_TOKEN","")
@@ -41,7 +39,7 @@ EXEC_TIMINGS = [
 ]
 
 def get_log_fn(test_route, ref="master"):
-  return f"{test_route}_model_{'chestnut' if CHESTNUT else 'tici'}_{ref}.zst"
+  return f"{test_route}_model_tici_{ref}.zst"
 
 def plot(proposed, master, title, tmp):
   proposed = list(proposed)
@@ -172,8 +170,6 @@ def model_replay(lr, frs):
 
   msgs = modeld_msgs + dmonitoringmodeld_msgs
   chestnut = any(m.modelV2.big for m in modeld_msgs if m.which() == "modelV2")
-  if CHESTNUT:
-    assert chestnut and all(m.modelV2.big for m in modeld_msgs if m.which() == "modelV2"), "Chestnut replay must run the big model without fallback"
 
   header = ['model', 'max instant', 'max instant allowed', 'average', 'max average allowed', 'test result']
   rows = []
@@ -289,8 +285,7 @@ if __name__ == "__main__":
       diff_short, diff_long, failed = format_diff(results, log_paths, 'master')
 
       if "CI" in os.environ:
-        if not CHESTNUT:
-          comment_replay_report(log_msgs, cmp_log, log_msgs)
+        comment_replay_report(log_msgs, cmp_log, log_msgs)
         failed = False
         print(diff_long)
       print('-------------\n'*5)

openpilot/selfdrive/test/process_replay/process_replay.py

@@ -17,7 +17,7 @@ from openpilot.common.hardware.hw import Paths
 import openpilot.cereal.messaging as messaging
 from opendbc.car.structs import car
 from openpilot.cereal.services import SERVICE_LIST
-from msgq.visionipc import VisionIpcClient, VisionIpcServer, get_endpoint_name as vipc_get_endpoint_name
+from msgq.visionipc import VisionIpcServer, get_endpoint_name as vipc_get_endpoint_name
 from opendbc.car.can_definitions import CanData
 from opendbc.car.car_helpers import get_car, interfaces
 from openpilot.common.params import Params
@@ -210,7 +210,6 @@ class ProcessContainer:
         stride, y_height, _, yuv_size = get_nv12_info(frame_size[0], frame_size[1])
         vipc_server.create_buffers_with_sizes(meta.stream, 2, frame_size[0], frame_size[1], yuv_size, stride, stride * y_height)
     vipc_server.start_listener()
-    VisionIpcClient.available_streams("camerad", block=True)
 
     self.vipc_server = vipc_server
     self.cfg.vision_pubs = [meta.camera_state for meta in streams_metas if meta.camera_state in self.cfg.vision_pubs]

openpilot/selfdrive/test/scons_build_test.sh

@@ -3,7 +3,7 @@ set -e
 
 SCRIPT_DIR=$(dirname "$0")
 BASEDIR=$(realpath "$SCRIPT_DIR/../../../")
-cd "$BASEDIR"
+cd $BASEDIR
 
 # tests that our build system's dependencies are configured properly,
 # needs a machine with lots of cores
@@ -11,7 +11,7 @@ cd "$BASEDIR"
 # helpful commands:
 # scons -Q --tree=derived
 
-cd "$BASEDIR/opendbc_repo/"
+cd $BASEDIR/opendbc_repo/
 scons --clean
 scons --no-cache --random
 if ! scons -q; then

openpilot/selfdrive/test/setup_device_ci.sh

@@ -29,7 +29,7 @@ if [ -d /data/safe_staging/ ]; then
 fi
 
 CONTINUE_PATH="/data/continue.sh"
-tee "$CONTINUE_PATH" << EOF
+tee $CONTINUE_PATH << EOF
 #!/usr/bin/env bash
 
 sudo abctl --set_success
@@ -54,18 +54,13 @@ done
 
 sleep infinity
 EOF
-chmod +x "$CONTINUE_PATH"
+chmod +x $CONTINUE_PATH
 
 export GIT_LFS_SKIP_SMUDGE=1
 pull_lfs() {
-  if [ -n "${CHESTNUT:-}" ]
-  then
-    git lfs pull --exclude=''
-    return
-  fi
-
-  # Keep the precompiled big model as a pointer on devices without Chestnut.
-  LFS_EXCLUDE="openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl"
+  # The big driving model is not used on these devices yet. Keep its pointer in
+  # the worktree, but don't download or copy the 1.8 GB LFS object.
+  LFS_EXCLUDE="openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx"
 
   git config --local lfs.fetchexclude "$LFS_EXCLUDE"
   git lfs pull --exclude="$LFS_EXCLUDE"
@@ -86,16 +81,16 @@ pull_lfs() {
 safe_checkout() {
   # completely clean TEST_DIR
 
-  cd "$SOURCE_DIR"
+  cd $SOURCE_DIR
 
   # cleanup orphaned locks
   find .git -type f -name "*.lock" -exec rm {} +
 
   git reset --hard
-  git fetch --no-tags --no-recurse-submodules -j4 --verbose --depth 1 origin "$GIT_COMMIT"
+  git fetch --no-tags --no-recurse-submodules -j4 --verbose --depth 1 origin $GIT_COMMIT
   find . -maxdepth 1 -not -path './.git' -not -name '.' -not -name '..' -exec rm -rf '{}' \;
-  git reset --hard "$GIT_COMMIT"
-  git checkout "$GIT_COMMIT"
+  git reset --hard $GIT_COMMIT
+  git checkout $GIT_COMMIT
   git clean -xdff
   git submodule sync
   git submodule foreach --recursive "git reset --hard && git clean -xdff"
@@ -105,22 +100,22 @@ safe_checkout() {
   pull_lfs
 
   echo "git checkout done, t=$SECONDS"
-  du -hs "$SOURCE_DIR" "$SOURCE_DIR/.git"
+  du -hs $SOURCE_DIR $SOURCE_DIR/.git
 
-  rsync -a --delete "$SOURCE_DIR" "$TEST_DIR"
+  rsync -a --delete $SOURCE_DIR $TEST_DIR
 }
 
 unsafe_checkout() {( set -e
   # checkout directly in test dir, leave old build products
 
-  cd "$TEST_DIR"
+  cd $TEST_DIR
 
   # cleanup orphaned locks
   find .git -type f -name "*.lock" -exec rm {} +
 
-  git fetch --no-tags --no-recurse-submodules -j8 --verbose --depth 1 origin "$GIT_COMMIT"
-  git checkout --force --no-recurse-submodules "$GIT_COMMIT"
-  git reset --hard "$GIT_COMMIT"
+  git fetch --no-tags --no-recurse-submodules -j8 --verbose --depth 1 origin $GIT_COMMIT
+  git checkout --force --no-recurse-submodules $GIT_COMMIT
+  git reset --hard $GIT_COMMIT
   git clean -dff
   git submodule sync
   git submodule foreach --recursive "git reset --hard && git clean -df"
@@ -134,7 +129,7 @@ export GIT_PACK_THREADS=8
 
 # set up environment
 if [ ! -d "$SOURCE_DIR" ]; then
-  git clone https://github.com/commaai/openpilot.git "$SOURCE_DIR"
+  git clone https://github.com/commaai/openpilot.git $SOURCE_DIR
 fi
 
 if [ ! -z "$UNSAFE" ]; then
@@ -151,7 +146,7 @@ else
 fi
 
 # submodule package symlinks for PYTHONPATH imports on device (same as launch_chffrplus.sh)
-cd "$TEST_DIR"
+cd $TEST_DIR
 ln -sfn msgq_repo/msgq msgq
 ln -sfn opendbc_repo/opendbc opendbc
 ln -sfn rednose_repo/rednose rednose

openpilot/selfdrive/test/test_onroad.py

@@ -20,12 +20,8 @@ from openpilot.common.basedir import BASEDIR
 from openpilot.common.timeout import Timeout
 from openpilot.common.params import Params
 from openpilot.selfdrive.selfdrived.events import EVENTS, ET
-from openpilot.selfdrive.test.helpers import set_params_enabled, release_only, processes_context, log_collector
-from openpilot.common.hardware import HARDWARE
+from openpilot.selfdrive.test.helpers import set_params_enabled, release_only
 from openpilot.common.hardware.hw import Paths
-from openpilot.common.mock import mock_messages
-from opendbc.car.car_helpers import get_demo_car_params
-from openpilot.selfdrive.modeld.helpers import chestnut_present, chestnut_compiled
 from openpilot.tools.lib.logreader import LogReader
 from openpilot.tools.lib.log_time_series import msgs_to_time_series
 
@@ -461,43 +457,5 @@ class TestOnroad(OpenpilotTestCase):
            f"Not engageable for whole segment:\n- selfdriveState.engageable: {Counter(eng)}\n- No entry events: {no_entries}"
 
 
-@unittest.skipUnless(HARDWARE.get_device_type() == "mici", "requires MICI")
-class TestChestnutOnroad(OpenpilotTestCase):
-  COMMA_HARDWARE_TEST = True
-
-  @mock_messages(['deviceMotion'])
-  def test_camera_models(self, subtests):
-    assert chestnut_present() and chestnut_compiled()
-    Params().put("CarParams", get_demo_car_params().to_bytes(), block=True)
-    services = ['narrowRoadCameraState', 'wideRoadCameraState', 'cabinCameraState', 'modelV2', 'driverStateV2']
-    sm = messaging.SubMaster(services)
-    pm = messaging.PubMaster(['deviceState'])
-    device_state = messaging.new_message('deviceState')
-    device_state.deviceState.deviceType = HARDWARE.get_device_type()
-    device_state_bytes = device_state.to_bytes()
-    with processes_context(['camerad', 'calibrationd', 'modeld', 'dmonitoringmodeld']):
-      with Timeout(60, "camera models didn't start"):
-        while not all(sm.seen.values()) or not sm.valid['modelV2']:
-          pm.send('deviceState', device_state_bytes)
-          sm.update(1000)
-      with log_collector(services) as (logs, _):
-        time.sleep(TEST_DURATION)
-
-    msgs = {s: [m for m in logs if m.which() == s] for s in services}
-    for service, messages in msgs.items():
-      with subtests.test(service=service):
-        expected = TEST_DURATION * SERVICE_LIST[service].frequency
-        assert np.isclose(len(messages), expected, rtol=0.05, atol=2), f"{service}: expected {expected}, got {len(messages)}"
-        assert all(m.valid for m in messages)
-        frame_ids = [getattr(m, service).frameId for m in messages]
-        assert np.all(np.diff(frame_ids) > 0), f"{service}: repeated or reordered frames"
-
-    camera_frames = {m.narrowRoadCameraState.frameId for m in msgs['narrowRoadCameraState']}
-    model_frames = {m.modelV2.frameId for m in msgs['modelV2']}
-    assert len(camera_frames & model_frames) >= TEST_DURATION * SERVICE_LIST['modelV2'].frequency * 0.9
-    assert all(m.modelV2.big for m in msgs['modelV2']), "Chestnut fell back to the small model"
-    assert all(np.isfinite(m.modelV2.position.x).all() for m in msgs['modelV2'])
-
-
 if __name__ == "__main__":
   unittest.main()

openpilot/selfdrive/test/test_power_draw.py

@@ -5,8 +5,6 @@ import time
 import unittest
 import numpy as np
 from dataclasses import dataclass
-from panda import Panda
-from openpilot.common.hardware import HARDWARE
 from openpilot.common.test import OpenpilotTestCase
 from openpilot.common.utils import tabulate
 
@@ -16,14 +14,11 @@ from opendbc.car.car_helpers import get_demo_car_params
 from openpilot.common.mock import mock_messages
 from openpilot.common.params import Params
 from openpilot.common.hardware.comma.power_monitor import get_power
-from openpilot.selfdrive.modeld.helpers import chestnut_present
 from openpilot.system.manager.process_config import managed_processes
 from openpilot.system.manager.manager import manager_cleanup
 
 SAMPLE_TIME = 2       # seconds to sample power
 MAX_WARMUP_TIME = 30  # seconds to wait for SAMPLE_TIME consecutive valid samples
-MICI = HARDWARE.get_device_type() == "mici"
-CHESTNUT = chestnut_present()
 
 @dataclass
 class Proc:
@@ -38,10 +33,9 @@ class Proc:
     return '+'.join(self.procs)
 
 
-# MICI readings exclude the separately powered Chestnut GPU.
 PROCS = [
-  Proc(['camerad'], 0.85 if MICI else 1.65, atol=0.4, msgs=['narrowRoadCameraState', 'wideRoadCameraState', 'cabinCameraState']),
-  Proc(['modeld'], 0.45 if MICI and CHESTNUT else 1.5, atol=0.2, msgs=['modelV2']),
+  Proc(['camerad'], 1.65, atol=0.4, msgs=['narrowRoadCameraState', 'wideRoadCameraState', 'cabinCameraState']),
+  Proc(['modeld'], 1.5, atol=0.2, msgs=['modelV2']),
   Proc(['dmonitoringmodeld'], 0.65, atol=0.35, msgs=['driverStateV2']),
   Proc(['encoderd'], 0.23, msgs=[]),
 ]
@@ -52,13 +46,6 @@ class TestPowerDraw(OpenpilotTestCase):
 
   def setup_method(self):
     Params().put("CarParams", get_demo_car_params().to_bytes(), block=True)
-    self.panda = None
-    if MICI:
-      HARDWARE.reset_internal_panda()
-      self.addCleanup(HARDWARE.reset_internal_panda)
-      Panda.wait_for_panda(None, 30)
-      self.panda = Panda(cli=False)
-      self.addCleanup(self.panda.close)
 
   def teardown_method(self):
     manager_cleanup()
@@ -91,7 +78,7 @@ class TestPowerDraw(OpenpilotTestCase):
     start_time = time.monotonic()
 
     while (time.monotonic() - start_time) < MAX_WARMUP_TIME:
-      power = get_power(1, self.panda)
+      power = get_power(1)
       iteration_msg_counts = {}
       for msg,sock in socks.items():
         iteration_msg_counts[msg] = len(messaging.drain_sock_raw(sock))
@@ -110,7 +97,7 @@ class TestPowerDraw(OpenpilotTestCase):
 
   @mock_messages(['deviceMotion'])
   def test_camera_procs(self, subtests):
-    baseline = get_power(panda=self.panda)
+    baseline = get_power()
 
     prev = baseline
     used = {}

openpilot/selfdrive/ui/lib/prime_state.py

@@ -101,10 +101,6 @@ class PrimeState:
     with self._lock:
       return bool(self.prime_type > PrimeType.NONE)
 
-  def is_full_prime(self) -> bool:
-    with self._lock:
-      return self.prime_type > PrimeType.NONE and self.prime_type != PrimeType.LITE
-
   def is_paired(self) -> bool:
     with self._lock:
       return self.prime_type > PrimeType.UNPAIRED

openpilot/selfdrive/ui/mici/layouts/home.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import datetime
 import math
 import time
@@ -41,13 +39,16 @@ class AlertsPill(Widget):
     self.set_rect(rl.Rectangle(0, 0, 104, 52))
 
     self._pill_bg_txt = gui_app.texture("icons_mici/alerts_pill.png", 104, 52)
+    self._icon_red = gui_app.texture("icons_mici/offroad_alerts/red_warning.png", 36, 36)
+    self._icon_orange = gui_app.texture("icons_mici/offroad_alerts/orange_warning.png", 36, 36)
+    self._icon_green = gui_app.texture("icons_mici/offroad_alerts/green_wheel.png", 36, 36)
     self._alert_count_callback: Callable[[], int] | None = None
-    self._alert_icon_callback: Callable[[], rl.Texture | None] | None = None
+    self._max_severity_callback: Callable[[], int | None] | None = None
 
   def set_alert_count_callback(self, callback: Callable[[], int] | None,
-                               icon_callback: Callable[[], rl.Texture | None] | None = None):
+                               severity_callback: Callable[[], int | None] | None = None):
     self._alert_count_callback = callback
-    self._alert_icon_callback = icon_callback
+    self._max_severity_callback = severity_callback
 
   def _render(self, _):
     alert_count = self._alert_count_callback() if self._alert_count_callback else 0
@@ -55,12 +56,17 @@ class AlertsPill(Widget):
       pill_w, pill_h = self._pill_bg_txt.width, self._pill_bg_txt.height
       rl.draw_texture_ex(self._pill_bg_txt, rl.Vector2(self.rect.x, self.rect.y), 0.0, 1.0, rl.WHITE)
 
-      warning_txt = self._alert_icon_callback() if self._alert_icon_callback else None
-      if warning_txt is not None:
-        scale = 36 / max(warning_txt.width, warning_txt.height)
-        warn_x = self.rect.x + self.ICON_OFFSET
-        warn_y = self.rect.y + (pill_h - warning_txt.height * scale) / 2
-        rl.draw_texture_ex(warning_txt, rl.Vector2(warn_x, warn_y), 0.0, scale, rl.WHITE)
+      severity = self._max_severity_callback() if self._max_severity_callback else None
+      if severity == -1:
+        warning_txt = self._icon_green
+      elif severity is not None and severity > 0:
+        warning_txt = self._icon_red
+      else:
+        warning_txt = self._icon_orange
+
+      warn_x = self.rect.x + self.ICON_OFFSET
+      warn_y = self.rect.y + (pill_h - warning_txt.height) / 2
+      rl.draw_texture_ex(warning_txt, rl.Vector2(warn_x, warn_y), 0.0, 1.0, rl.WHITE)
 
       count_rect = rl.Rectangle(self.rect.x + self.COUNT_OFFSET, self.rect.y, pill_w - self.COUNT_OFFSET, pill_h)
       gui_label(count_rect, str(alert_count), font_size=36,
@@ -71,21 +77,21 @@ class AlertsPill(Widget):
 class NetworkIcon(Widget):
   def __init__(self):
     super().__init__()
-    self.set_rect(rl.Rectangle(0, 0, 60, 47))  # max size of all icons
+    self.set_rect(rl.Rectangle(0, 0, 54, 44))  # max size of all icons
     self._net_type = NetworkType.none
     self._net_strength = 0
 
-    self._wifi_slash_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_slash.png", 54, 47)
-    self._wifi_none_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_none.png", 54, 40)
-    self._wifi_low_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_low.png", 54, 40)
-    self._wifi_medium_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_medium.png", 54, 40)
-    self._wifi_full_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_full.png", 54, 40)
+    self._wifi_slash_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_slash.png", 50, 44)
+    self._wifi_none_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_none.png", 50, 37)
+    self._wifi_low_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_low.png", 50, 37)
+    self._wifi_medium_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_medium.png", 50, 37)
+    self._wifi_full_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_full.png", 50, 37)
 
-    self._cell_none_txt = gui_app.texture("icons_mici/settings/network/cell_strength_none.png", 60, 40)
-    self._cell_low_txt = gui_app.texture("icons_mici/settings/network/cell_strength_low.png", 60, 40)
-    self._cell_medium_txt = gui_app.texture("icons_mici/settings/network/cell_strength_medium.png", 60, 40)
-    self._cell_high_txt = gui_app.texture("icons_mici/settings/network/cell_strength_high.png", 60, 40)
-    self._cell_full_txt = gui_app.texture("icons_mici/settings/network/cell_strength_full.png", 60, 40)
+    self._cell_none_txt = gui_app.texture("icons_mici/settings/network/cell_strength_none.png", 54, 36)
+    self._cell_low_txt = gui_app.texture("icons_mici/settings/network/cell_strength_low.png", 54, 36)
+    self._cell_medium_txt = gui_app.texture("icons_mici/settings/network/cell_strength_medium.png", 54, 36)
+    self._cell_high_txt = gui_app.texture("icons_mici/settings/network/cell_strength_high.png", 54, 36)
+    self._cell_full_txt = gui_app.texture("icons_mici/settings/network/cell_strength_full.png", 54, 36)
 
   def _update_state(self):
     device_state = ui_state.sm['deviceState']
@@ -135,7 +141,7 @@ class MiciHomeLayout(Widget):
 
     self._experimental_icon = IconWidget("icons_mici/experimental_mode.png", (48, 48))
     self._usb_icon = IconWidget("icons_mici/usb.png", (62, 40))
-    self._chestnut_icon = IconWidget("icons_mici/chestnut_green.png", (54, 40))
+    self._chestnut_icon = IconWidget("icons_mici/chestnut_green.png", (68, 40))
     self._chestnut_loading_icon = IconWidget("icons_mici/chestnut.png", (68, 40))
     self._chestnut_failed_icon = IconWidget("icons_mici/chestnut_orange.png", (68, 40))
     self._mic_icon = IconWidget("icons_mici/microphone.png", (32, 46))
@@ -181,11 +187,11 @@ class MiciHomeLayout(Widget):
 
   def set_callbacks(self, on_settings: Callable | None = None, on_alerts: Callable | None = None,
                     alert_count_callback: Callable[[], int] | None = None,
-                    alert_icon_callback: Callable[[], rl.Texture | None] | None = None):
+                    max_severity_callback: Callable[[], int | None] | None = None):
     self._on_settings_click = on_settings
     self._on_alerts_click = on_alerts
     self._alert_count_callback = alert_count_callback
-    self._alerts_pill.set_alert_count_callback(alert_count_callback, alert_icon_callback)
+    self._alerts_pill.set_alert_count_callback(alert_count_callback, max_severity_callback)
 
   def _handle_mouse_release(self, mouse_pos: MousePos):
     if not self._did_long_press:

openpilot/selfdrive/ui/mici/layouts/main.py

@@ -77,7 +77,7 @@ class MiciMainLayout(Scroller):
       on_settings=lambda: gui_app.push_widget(self._settings_layout),
       on_alerts=lambda: self._scroll_to(self._alerts_layout),
       alert_count_callback=self._alerts_layout.active_alerts,
-      alert_icon_callback=self._alerts_layout.highest_severity_icon,
+      max_severity_callback=self._alerts_layout.max_severity,
     )
     for layout in (self._car_onroad_layout, self._body_onroad_layout):
       layout.set_click_callback(lambda: self._scroll_to(self._home_layout))

openpilot/selfdrive/ui/mici/layouts/offroad_alerts.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import pyray as rl
 import re
 import threading
@@ -31,7 +29,6 @@ class AlertData:
   text: str
   severity: int
   visible: bool = False
-  icon: str | None = None
 
 
 class AlertItem(Widget):
@@ -59,20 +56,10 @@ class AlertItem(Widget):
     self._bg_big = gui_app.texture("icons_mici/offroad_alerts/big_alert.png", self.ALERT_WIDTH, self.ALERT_HEIGHT_BIG)
     self._bg_big_pressed = gui_app.texture("icons_mici/offroad_alerts/big_alert_pressed.png", self.ALERT_WIDTH, self.ALERT_HEIGHT_BIG)
 
-    # Load alert icons
+    # Load warning icons
     self._icon_orange = gui_app.texture("icons_mici/offroad_alerts/orange_warning.png", self.ICON_SIZE, self.ICON_SIZE)
     self._icon_red = gui_app.texture("icons_mici/offroad_alerts/red_warning.png", self.ICON_SIZE, self.ICON_SIZE)
     self._icon_green = gui_app.texture("icons_mici/offroad_alerts/green_wheel.png", self.ICON_SIZE, self.ICON_SIZE)
-    self._custom_icon = gui_app.texture(alert_data.icon, self.ICON_SIZE, self.ICON_SIZE) if alert_data.icon else None
-
-    if self._custom_icon is not None:
-      self._icon = self._custom_icon
-    elif alert_data.severity == -1:
-      self._icon = self._icon_green
-    elif alert_data.severity > 0:
-      self._icon = self._icon_red
-    else:
-      self._icon = self._icon_orange
 
     self._title_label = UnifiedLabel(text="", font_size=32, font_weight=FontWeight.SEMI_BOLD, text_color=self.TEXT_COLOR,
                                      alignment=TextAlignment.LEFT,
@@ -88,10 +75,6 @@ class AlertItem(Widget):
 
     self._update_content()
 
-  @property
-  def icon(self) -> rl.Texture:
-    return self._icon
-
   def _split_text(self, text: str) -> tuple[str, str]:
     """Split text into title (first sentence) and body (remaining text)."""
     # Find the end of the first sentence (period, exclamation, or question mark followed by space or end)
@@ -193,9 +176,16 @@ class AlertItem(Widget):
       self._body_label.render(body_rect)
 
     # Draw warning icon on the right side
+    # Use green icon for update alerts (severity = -1), red for high severity, orange for low severity
+    if self.alert_data.severity == -1:
+      icon_texture = self._icon_green
+    elif self.alert_data.severity > 0:
+      icon_texture = self._icon_red
+    else:
+      icon_texture = self._icon_orange
     icon_x = self._rect.x + self.ALERT_WIDTH - self.ALERT_PADDING - self.ICON_SIZE
     icon_y = self._rect.y + self.ALERT_PADDING
-    rl.draw_texture_ex(self._icon, rl.Vector2(icon_x, icon_y), 0.0, 1.0, rl.WHITE)
+    rl.draw_texture_ex(icon_texture, rl.Vector2(icon_x, icon_y), 0.0, 1.0, rl.WHITE)
 
 
 class MiciOffroadAlerts(Scroller):
@@ -224,10 +214,8 @@ class MiciOffroadAlerts(Scroller):
   def active_alerts(self) -> int:
     return sum(alert.visible for alert in self.sorted_alerts)
 
-  def highest_severity_icon(self) -> rl.Texture | None:
-    item = max((item for item in self.alert_items if item.alert_data.visible),
-               key=lambda item: (item.alert_data.severity, bool(item.alert_data.icon)), default=None)
-    return item.icon if item is not None else None
+  def max_severity(self) -> int | None:
+    return max((alert.severity for alert in self.sorted_alerts if alert.visible), default=None)
 
   def scrolling(self):
     return self._scroller.scroll_panel.is_touch_valid()
@@ -247,7 +235,7 @@ class MiciOffroadAlerts(Scroller):
     # Add regular alerts sorted by severity
     for key, config in sorted(OFFROAD_ALERTS.items(), key=lambda x: x[1].get("severity", 0), reverse=True):
       severity = config.get("severity", 0)
-      alert_data = AlertData(key=key, text="", severity=severity, icon=config.get("icon"))
+      alert_data = AlertData(key=key, text="", severity=severity)
       self.sorted_alerts.append(alert_data)
 
       # Create alert item widget

openpilot/selfdrive/ui/mici/layouts/settings/developer.py

@@ -23,6 +23,8 @@ class AlphaLongConfirmPage(NavScroller):
       GreyBigButton("", "WARNING: alpha longitudinal control may disable Automatic Emergency Braking (AEB)"),
       GreyBigButton("", "On this car, openpilot defaults to the stock system's built-in ACC."),
       GreyBigButton("", "Enabling this will switch to openpilot longitudinal control."),
+      GreyBigButton("", "Using Experimental mode is recommended with openpilot longitudinal control alpha."),
+      GreyBigButton("", "Changing this setting will restart openpilot if the car is powered on."),
       accept,
     ])
 
@@ -61,31 +63,28 @@ class DeveloperLayoutMici(NavScroller):
 
     txt_ssh = gui_app.texture("icons_mici/settings/developer/ssh.png", 56, 64)
     github_username = ui_state.params.get("GithubUsername") or ""
-    self._ssh_keys_btn = BigButton("SSH keys", "Not set" if not github_username else github_username, icon=txt_ssh,
-                                   description="Grant SSH access to all public keys in your GitHub settings. Only enter your own username.")
+    self._ssh_keys_btn = BigButton("SSH keys", "Not set" if not github_username else github_username, icon=txt_ssh)
     self._ssh_keys_btn.set_click_callback(ssh_keys_callback)
 
     # adb, ssh, ssh keys, debug mode, joystick debug mode, longitudinal maneuver mode, ip address
     # ******** Main Scroller ********
-    self._adb_toggle = BigCircleParamControl(gui_app.texture("icons_mici/adb_short.png", 82, 82), "AdbEnabled", icon_offset=(0, 12),
-                                             description="Use Android Debug Bridge (ADB) over USB or the network.", title="enable ADB")
-    self._ssh_toggle = BigCircleParamControl(gui_app.texture("icons_mici/ssh_short.png", 82, 82), "SshEnabled", icon_offset=(0, 12),
-                                             description="Access the device remotely using your SSH keys.", title="enable SSH")
-    self._joystick_toggle = BigToggle("joystick debug\nmode", initial_state=ui_state.params.get_bool("JoystickDebugMode"),
-                                      toggle_callback=self._on_joystick_debug_mode, description="Control the car with a joystick for debugging.")
-    self._long_maneuver_toggle = BigToggle("longitudinal maneuver mode", initial_state=ui_state.params.get_bool("LongitudinalManeuverMode"),
-                                           toggle_callback=self._on_long_maneuver_mode,
-                                           description="Run longitudinal maneuvers for testing gas and brake control.")
-    self._lat_maneuver_toggle = BigToggle("lateral maneuver mode", initial_state=ui_state.params.get_bool("LateralManeuverMode"),
-                                          toggle_callback=self._on_lat_maneuver_mode,
-                                          description="Run lateral maneuvers for testing steering control.")
-    self._alpha_long_toggle = BigToggle("alpha longitudinal", initial_state=ui_state.params.get_bool("AlphaLongitudinalEnabled"),
-                                        toggle_callback=self._on_alpha_long_enabled,
-                                        description="Use alpha openpilot longitudinal control instead of stock ACC. This may disable Automatic Emergency " +
-                                                    "Braking (AEB).")
+    self._adb_toggle = BigCircleParamControl(gui_app.texture("icons_mici/adb_short.png", 82, 82), "AdbEnabled", icon_offset=(0, 12))
+    self._ssh_toggle = BigCircleParamControl(gui_app.texture("icons_mici/ssh_short.png", 82, 82), "SshEnabled", icon_offset=(0, 12))
+    self._joystick_toggle = BigToggle("joystick debug mode",
+                                      initial_state=ui_state.params.get_bool("JoystickDebugMode"),
+                                      toggle_callback=self._on_joystick_debug_mode)
+    self._long_maneuver_toggle = BigToggle("longitudinal maneuver mode",
+                                           initial_state=ui_state.params.get_bool("LongitudinalManeuverMode"),
+                                           toggle_callback=self._on_long_maneuver_mode)
+    self._lat_maneuver_toggle = BigToggle("lateral maneuver mode",
+                                          initial_state=ui_state.params.get_bool("LateralManeuverMode"),
+                                          toggle_callback=self._on_lat_maneuver_mode)
+    self._alpha_long_toggle = BigToggle("alpha longitudinal",
+                                        initial_state=ui_state.params.get_bool("AlphaLongitudinalEnabled"),
+                                        toggle_callback=self._on_alpha_long_enabled)
     self._debug_mode_toggle = BigParamControl("ui debug mode", "ShowDebugInfo",
-                                              toggle_callback=lambda checked: (gui_app.set_show_touches(checked), gui_app.set_show_fps(checked)),
-                                              description="Show touch locations and the UI frame rate.")
+                                              toggle_callback=lambda checked: (gui_app.set_show_touches(checked),
+                                                                               gui_app.set_show_fps(checked)))
 
     self._scroller.add_widgets([
       self._adb_toggle,

openpilot/selfdrive/ui/mici/layouts/settings/device.py

@@ -1,7 +1,6 @@
 import os
 import pyray as rl
 from collections.abc import Callable
-from typing import Union
 
 from openpilot.common.basedir import BASEDIR
 from openpilot.common.params import Params
@@ -78,16 +77,15 @@ def _engaged_confirmation_click(callback: Callable, action_text: str, icon: rl.T
 
 class EngagedConfirmationCircleButton(BigCircleButton):
   def __init__(self, title: str, icon: rl.Texture, callback: Callable[[], None], exit_on_confirm: bool = True,
-               red: bool = False, icon_offset: tuple[int, int] = (0, 0), *, description: str = ""):
-    super().__init__(icon, red, icon_offset, description=description, title=title)
+               red: bool = False, icon_offset: tuple[int, int] = (0, 0)):
+    super().__init__(icon, red, icon_offset)
     self.set_click_callback(lambda: _engaged_confirmation_click(callback, title, icon, exit_on_confirm=exit_on_confirm, red=red))
 
 
 class EngagedConfirmationButton(BigButton):
   def __init__(self, text: str, action_text: str, icon: rl.Texture, callback: Callable[[], None],
-               exit_on_confirm: bool = True, red: bool = False, *, description: str = "",
-               description_icon: Union[rl.Texture, None] = None):
-    super().__init__(text, "", icon, description=description, description_icon=description_icon)
+               exit_on_confirm: bool = True, red: bool = False):
+    super().__init__(text, "", icon)
     self.set_click_callback(lambda: _engaged_confirmation_click(callback, action_text, icon, exit_on_confirm=exit_on_confirm, red=red))
 
 
@@ -179,9 +177,7 @@ class DeviceLayoutMici(NavScroller):
       params.put_bool("OnroadCycleRequested", True, block=True)
 
     reset_calibration_btn = EngagedConfirmationButton("reset calibration", "reset", gui_app.texture("icons_mici/settings/device/lkas.png", 122, 64),
-                                                      reset_calibration_callback,
-                                                      description="Mount the device within 4° left or right and 5° up or 9° down. openpilot calibrates " +
-                                                                  "continuously; resetting is rarely needed. Resetting clears learned calibration.")
+                                                      reset_calibration_callback)
 
     reboot_btn = EngagedConfirmationCircleButton("reboot", gui_app.texture("icons_mici/settings/device/reboot.png", 64, 70),
                                                  reboot_callback, exit_on_confirm=False)
@@ -193,8 +189,7 @@ class DeviceLayoutMici(NavScroller):
     regulatory_btn = BigButton("regulatory info", "", gui_app.texture("icons_mici/settings/device/info.png", 64, 64))
     regulatory_btn.set_click_callback(self._on_regulatory)
 
-    cabin_cam_btn = BigButton("driver\ncamera preview", "", gui_app.texture("icons_mici/settings/device/cameras.png", 64, 64),
-                              description="Preview the cabin camera to check driver monitoring visibility. The vehicle must be off.")
+    cabin_cam_btn = BigButton("driver\ncamera preview", "", gui_app.texture("icons_mici/settings/device/cameras.png", 64, 64))
     cabin_cam_btn.set_click_callback(lambda: gui_app.push_widget(CabinCameraDialog()))
     cabin_cam_btn.set_enabled(lambda: ui_state.is_offroad())
 

openpilot/selfdrive/ui/mici/layouts/settings/network/__init__.py

@@ -1,60 +1,13 @@
 import pyray as rl
 
-from openpilot.cereal import log
 from openpilot.selfdrive.ui.mici.layouts.settings.network.wifi_ui import WifiIcon
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton
-from openpilot.common.hardware import HARDWARE
 from openpilot.system.ui.lib.application import gui_app
-from openpilot.system.ui.lib.cellular_manager import CellularManager
 from openpilot.system.ui.lib.wifi_manager import WifiManager, ConnectStatus, SecurityType, normalize_ssid
 
-NetworkStrength = log.DeviceState.NetworkStrength
-NetworkType = log.DeviceState.NetworkType
-
-
-class EsimNetworkButton(BigButton):
-  def __init__(self, cellular_manager: CellularManager, *, description: str = ""):
-    self._cellular_manager = cellular_manager
-    self._cell_icons = {
-      NetworkStrength.unknown: gui_app.texture("icons_mici/settings/network/cell_strength_none.png", 64, 47),
-      NetworkStrength.poor: gui_app.texture("icons_mici/settings/network/cell_strength_low.png", 64, 47),
-      NetworkStrength.moderate: gui_app.texture("icons_mici/settings/network/cell_strength_medium.png", 64, 47),
-      NetworkStrength.good: gui_app.texture("icons_mici/settings/network/cell_strength_high.png", 64, 47),
-      NetworkStrength.great: gui_app.texture("icons_mici/settings/network/cell_strength_full.png", 64, 47),
-    }
-    super().__init__("esim", "loading...", self._cell_icons[NetworkStrength.unknown], scroll=True, description=description)
-
-  def _update_state(self):
-    super()._update_state()
-    self.set_enabled(self._cellular_manager.is_euicc is not False)
-    text, value, icon = self._compute_state()
-    self.set_text(text)
-    self.set_value(value)
-    self.set_icon(icon)
-
-  def _compute_state(self):
-    cm = self._cellular_manager
-    none_icon = self._cell_icons[NetworkStrength.unknown]
-    ip = cm.modem_state.get("ip_address") or "connecting..."
-    if cm.is_euicc is False:
-      iccid = cm.modem_state.get("iccid") or ""
-      if not iccid:
-        return "sim", "no sim", none_icon
-      return f"sim (...{iccid[-4:]})", ip, self._cell_icon()
-
-    active = cm.active_profile
-    if active is None:
-      return "esim", "loading...", none_icon
-    return active.display_name, ip, self._cell_icon()
-
-  def _cell_icon(self):
-    # read directly from HARDWARE so it reflects modem state even when wifi is the active connection
-    strength = HARDWARE.get_network_strength(NetworkType.cell4G)
-    return self._cell_icons.get(strength, self._cell_icons[NetworkStrength.unknown])
-
 
 class WifiNetworkButton(BigButton):
-  def __init__(self, wifi_manager: WifiManager, *, description: str = ""):
+  def __init__(self, wifi_manager: WifiManager):
     self._wifi_manager = wifi_manager
     self._lock_txt = gui_app.texture("icons_mici/settings/network/new/lock.png", 28, 36)
     self._draw_lock = False
@@ -64,7 +17,7 @@ class WifiNetworkButton(BigButton):
     self._wifi_medium_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_medium.png", 64, 47)
     self._wifi_full_txt = gui_app.texture("icons_mici/settings/network/wifi_strength_full.png", 64, 47)
 
-    super().__init__("wi-fi", "not connected", self._wifi_slash_txt, scroll=True, description=description)
+    super().__init__("wi-fi", "not connected", self._wifi_slash_txt, scroll=True)
 
   def _update_state(self):
     super()._update_state()

openpilot/selfdrive/ui/mici/layouts/settings/network/esim_ui.py

@@ -1,412 +0,0 @@
-import threading
-
-import numpy as np
-import pyray as rl
-from collections.abc import Callable
-from openpilot.cereal import log
-from openpilot.cereal.visionipc import VisionStreamType
-
-from openpilot.common import qrcode
-from openpilot.common.swaglog import cloudlog
-from openpilot.selfdrive.ui.mici.onroad.cabin_camera_dialog import CabinCameraView
-from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.widgets.nav_widget import NavWidget
-
-from openpilot.selfdrive.ui.mici.widgets.button import BigButton, LABEL_COLOR
-from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigInputDialog, BigConfirmationDialog
-from openpilot.common.esim.base import Profile
-from openpilot.common.esim.lpa import parse_lpa_activation_code
-from openpilot.system.ui.lib.application import DEFAULT_TEXT_COLOR, FontWeight, MousePos, TextAlignment, gui_app
-from openpilot.system.ui.lib.cellular_manager import CellularManager
-from openpilot.system.ui.widgets import Widget
-from openpilot.system.ui.widgets.label import UnifiedLabel, gui_label
-from openpilot.system.ui.widgets.scroller import NavRawScrollPanel, NavScroller
-
-
-class ProfileActionButton(Widget):
-  SIZE = 68
-  MARGIN = 10
-  HORIZONTAL_MARGIN = 4
-
-  def __init__(self, callback: Callable, delete: bool = False):
-    super().__init__()
-    self.set_click_callback(callback)
-    self._delete = delete
-    self._trash_txt = gui_app.texture("icons_mici/settings/network/new/trash.png", 25, 30) if delete else None
-
-    self._bg_txt = gui_app.texture("icons_mici/buttons/button_circle.png", self.SIZE, self.SIZE)
-    self._bg_pressed_txt = gui_app.texture("icons_mici/buttons/button_circle_pressed.png", self.SIZE, self.SIZE)
-    self.set_rect(rl.Rectangle(0, 0, self.SIZE + self.HORIZONTAL_MARGIN * 2, self.SIZE + self.MARGIN * 2))
-
-  def _render(self, _):
-    bg_txt = self._bg_pressed_txt if self.is_pressed else self._bg_txt
-    rl.draw_texture_ex(bg_txt, (self._rect.x + (self._rect.width - self._bg_txt.width) / 2,
-                                self._rect.y + (self._rect.height - self._bg_txt.height) / 2), 0, 1.0, rl.WHITE)
-    color = rl.Color(255, 105, 115, 255) if self._delete else DEFAULT_TEXT_COLOR
-    if not self.enabled:
-      color = rl.Color(color.r, color.g, color.b, 90)
-    if self._trash_txt:
-      rl.draw_texture_ex(self._trash_txt, (self._rect.x + (self._rect.width - self._trash_txt.width) / 2,
-                                          self._rect.y + (self._rect.height - self._trash_txt.height) / 2), 0, 1.0, color)
-    else:
-      gui_label(self._rect, "Aa", 30, color=color, alignment=TextAlignment.CENTER)
-
-
-class QRScannerDialog(NavWidget):
-  SCAN_INTERVAL_S = 0.25
-  INVALID_CODE_DURATION_S = 1.0
-
-  def __init__(self, on_qr_detected: Callable[[str], None]):
-    super().__init__()
-    self._on_qr_detected = on_qr_detected
-    self._camera_view = CabinCameraView("camerad", VisionStreamType.VISION_STREAM_CABIN)
-    self._detected = False
-    self._last_scan_time = 0.0
-    self._invalid_code_until = 0.0
-    self._scan_thread: threading.Thread | None = None
-    self._scan_result: str | None = None
-    self.set_rect(rl.Rectangle(0, 0, gui_app.width, gui_app.height))
-
-  def show_event(self):
-    super().show_event()
-    ui_state.params.put_bool("DisableDriverCameraIR", True)
-    ui_state.params.put_bool("IsDriverViewEnabled", True)
-
-  def hide_event(self):
-    super().hide_event()
-    ui_state.params.put_bool("IsDriverViewEnabled", False)
-    ui_state.params.put_bool("DisableDriverCameraIR", False)
-
-  def __del__(self):
-    self._camera_view.close()
-
-  def _update_state(self):
-    super()._update_state()
-
-    now = rl.get_time()
-    if self._detected or not self._camera_view.frame or now < self._invalid_code_until:
-      return
-
-    if self._scan_thread is not None:
-      if self._scan_thread.is_alive():
-        return
-      self._scan_thread = None
-      data = self._scan_result
-      if data is not None:
-        try:
-          parse_lpa_activation_code(data)
-        except ValueError:
-          self._invalid_code_until = now + self.INVALID_CODE_DURATION_S
-          self._last_scan_time = self._invalid_code_until
-        else:
-          self._detected = True
-          self.dismiss(lambda: self._on_qr_detected(data))
-        return
-
-    if now - self._last_scan_time < self.SCAN_INTERVAL_S:
-      return
-    self._last_scan_time = now
-
-    frame = self._camera_view.frame
-    y = np.frombuffer(frame.data, dtype=np.uint8, count=frame.height * frame.stride).reshape(frame.height, frame.stride)
-    gray = y[:, :frame.width].copy()  # the vision buffer is recycled under the scan thread
-    self._scan_thread = threading.Thread(target=self._scan, args=(gray,), daemon=True)
-    self._scan_thread.start()
-
-  def _scan(self, gray: np.ndarray):
-    self._scan_result = qrcode.decode(gray)
-
-  def _render(self, rect):
-    rl.begin_scissor_mode(int(rect.x), int(rect.y), int(rect.width), int(rect.height))
-    self._camera_view._render(rect)
-
-    if not self._camera_view.frame:
-      gui_label(rect, tr("camera starting"), font_size=54, font_weight=FontWeight.BOLD,
-                alignment=TextAlignment.CENTER)
-    else:
-      label_y = rect.y + rect.height * 3 / 4
-      label_rect = rl.Rectangle(rect.x, label_y + (rect.height - label_y) / 2 - 20, rect.width, 40)
-      text = "not an LPA code" if rl.get_time() < self._invalid_code_until else "hold QR code to camera"
-      gui_label(label_rect, text, font_size=32, font_weight=FontWeight.MEDIUM,
-                alignment=TextAlignment.CENTER,
-                color=rl.Color(255, 255, 255, int(255 * 0.9)))
-
-    rl.end_scissor_mode()
-
-
-class InstallingProfileDialog(BigDialog):
-  DOT_STEP = 0.6
-
-  def __init__(self):
-    super().__init__("installing profile", "please wait...")
-    self._show_time = 0.0
-
-  def show_event(self):
-    super().show_event()
-    self._nav_bar._alpha = 0.0
-    self._show_time = rl.get_time()
-
-  def _back_enabled(self) -> bool:
-    return False
-
-  def _render(self, _):
-    t = (rl.get_time() - self._show_time) % (self.DOT_STEP * 2)
-    dots = "." * min(int(t / (self.DOT_STEP / 4)), 3)
-    self._card.set_value(f"please wait{dots}")
-    super()._render(_)
-
-
-class EsimProfileButton(BigButton):
-  SUB_LABEL_DISABLED = rl.Color(255, 255, 255, int(255 * 0.585))
-  CHECK_ICON_COLOR = rl.Color(255, 255, 255, int(255 * 0.9 * 0.65))
-  LABEL_PADDING = 98
-  LABEL_WIDTH = 402 - 98 - 28
-  SUB_LABEL_WIDTH = 402 - BigButton.LABEL_HORIZONTAL_PADDING * 2
-
-  def __init__(self, profile: Profile, cellular_manager: CellularManager, profiles_enabled: Callable[[], bool]):
-    self._cellular_manager = cellular_manager
-    self._profiles_enabled = profiles_enabled
-    super().__init__(profile.display_name, scroll=True)
-
-    self._profile = profile
-
-    self._cell_full_txt = gui_app.texture("icons_mici/settings/network/cell_strength_full.png", 48, 36)
-    self._cell_none_txt = gui_app.texture("icons_mici/settings/network/cell_strength_none.png", 48, 36)
-    self._check_txt = gui_app.texture("icons_mici/setup/driver_monitoring/dm_check.png", 32, 32)
-    self._comma_txt = gui_app.texture("icons_mici/settings/comma_icon.png", 36, 36) if profile.is_comma else None
-
-    self._delete_btn = ProfileActionButton(self._on_delete, delete=True)
-    self._rename_btn = ProfileActionButton(self._on_rename) if not profile.is_comma else None
-    self._delete_btn.set_enabled(lambda: not self._locked and not self._cellular_manager.busy and self._show_delete_btn)
-    if self._rename_btn:
-      self._rename_btn.set_enabled(lambda: not self._locked and not self._cellular_manager.busy)
-    self.set_enabled(lambda: not self._profile.enabled and self._profiles_enabled() and not self._cellular_manager.busy)
-    self.update_profile(profile)
-
-  @property
-  def profile(self) -> Profile:
-    return self._profile
-
-  def update_profile(self, profile: Profile):
-    self._profile = profile
-    active = profile.enabled
-    self.set_text(profile.display_name)
-    self.set_value("active" if active else "switch")
-
-  def _update_state(self):
-    super()._update_state()
-    self._sub_label.set_color(DEFAULT_TEXT_COLOR if self.enabled else self.SUB_LABEL_DISABLED)
-    self._sub_label.set_font_weight(FontWeight.SEMI_BOLD if self.enabled else FontWeight.ROMAN)
-
-  @property
-  def _locked(self) -> bool:
-    return not self._profile.is_comma and not self._profiles_enabled()
-
-  @property
-  def _show_delete_btn(self) -> bool:
-    return not self._profile.enabled and not self._profile.is_comma
-
-  def _on_rename(self):
-    current = self._profile.nickname or ""
-    dlg = BigInputDialog("nickname", default_text=current, confirm_callback=self._on_nickname_entered,
-                         text_validator=lambda text: bool(text.strip()))
-    gui_app.push_widget(dlg)
-
-  def _on_delete(self):
-    icon = gui_app.texture("icons_mici/settings/network/new/trash.png", 54, 64)
-    gui_app.push_widget(BigConfirmationDialog("slide to delete", icon, self._delete_profile, red=True))
-
-  def _delete_profile(self):
-    if not self._locked and not self._cellular_manager.busy and self._show_delete_btn:
-      if ui_state.sm["deviceState"].networkType == log.DeviceState.NetworkType.none:
-        gui_app.push_widget(BigDialog("", tr("Ensure you're connected to the internet and try again.")))
-        return
-      self._cellular_manager.delete_profile(self._profile.iccid)
-
-  def _on_nickname_entered(self, nickname: str):
-    if not self._locked and not self._cellular_manager.busy:
-      self._cellular_manager.nickname_profile(self._profile.iccid, nickname.strip())
-
-  def _handle_mouse_release(self, mouse_pos: MousePos):
-    if self._show_delete_btn and rl.check_collision_point_rec(mouse_pos, self._delete_btn.rect):
-      return
-    if self._rename_btn is not None and rl.check_collision_point_rec(mouse_pos, self._rename_btn.rect):
-      return
-    super()._handle_mouse_release(mouse_pos)
-
-  def _get_label_font_size(self):
-    return 48
-
-  def _draw_content(self, btn_y: float):
-    self._label.set_color(self.SUB_LABEL_DISABLED if self._locked else LABEL_COLOR)
-    label_rect = rl.Rectangle(self._rect.x + self.LABEL_PADDING, btn_y + self.LABEL_VERTICAL_PADDING,
-                              self.LABEL_WIDTH, self._rect.height - self.LABEL_VERTICAL_PADDING * 2)
-    self._label.render(label_rect)
-
-    active = self._profile.enabled
-
-    if self.value:
-      sub_label_x = self._rect.x + self.LABEL_HORIZONTAL_PADDING
-      label_y = btn_y + self._rect.height - self.LABEL_VERTICAL_PADDING
-      action_w = self._rename_btn.rect.width if self._rename_btn is not None else 0
-      action_w += self._delete_btn.rect.width if self._show_delete_btn else 0
-      sub_label_w = self.SUB_LABEL_WIDTH - action_w
-      sub_label_height = self._sub_label.get_content_height(sub_label_w)
-
-      if active:
-        check_y = int(label_y - sub_label_height + (sub_label_height - self._check_txt.height) / 2)
-        rl.draw_texture_ex(self._check_txt, rl.Vector2(sub_label_x, check_y), 0.0, 1.0, self.CHECK_ICON_COLOR)
-        sub_label_x += self._check_txt.width + 14
-
-      sub_label_rect = rl.Rectangle(sub_label_x, label_y - sub_label_height, sub_label_w, sub_label_height)
-      self._sub_label.render(sub_label_rect)
-
-    if self._comma_txt:
-      rl.draw_texture_ex(self._comma_txt, (self._rect.x + 36, btn_y + 38), 0.0, 1.0, rl.WHITE)
-    else:
-      cell_icon = self._cell_full_txt if active else self._cell_none_txt
-      rl.draw_texture_ex(cell_icon, (self._rect.x + 30, btn_y + 38), 0.0, 1.0, rl.WHITE)
-
-    btn_x = self._rect.x + self._rect.width - (ProfileActionButton.MARGIN - ProfileActionButton.HORIZONTAL_MARGIN)
-    btn_bottom = btn_y + self._rect.height
-    if self._show_delete_btn:
-      btn_x -= self._delete_btn.rect.width
-      self._delete_btn.render(rl.Rectangle(
-        btn_x, btn_bottom - self._delete_btn.rect.height,
-        self._delete_btn.rect.width, self._delete_btn.rect.height,
-      ))
-    if self._rename_btn is not None:
-      btn_x -= self._rename_btn.rect.width
-      self._rename_btn.render(rl.Rectangle(
-        btn_x, btn_bottom - self._rename_btn.rect.height,
-        self._rename_btn.rect.width, self._rename_btn.rect.height,
-      ))
-
-  def set_touch_valid_callback(self, touch_callback: Callable[[], bool]) -> None:
-    def action_pressed() -> bool:
-      return self._delete_btn.is_pressed or (self._rename_btn is not None and self._rename_btn.is_pressed)
-    super().set_touch_valid_callback(lambda: touch_callback() and not action_pressed())
-    self._delete_btn.set_touch_valid_callback(touch_callback)
-    if self._rename_btn:
-      self._rename_btn.set_touch_valid_callback(touch_callback)
-
-
-class EsimErrorDialog(NavRawScrollPanel):
-  def __init__(self, error: str):
-    super().__init__()
-    self._title = UnifiedLabel("esim error", font_size=64, font_weight=FontWeight.BOLD)
-    self._error = UnifiedLabel(error, font_size=36, elide=False)
-
-  def _render(self, rect: rl.Rectangle):
-    width = int(rect.width - 80)
-    title_height = self._title.get_content_height(width)
-    error_height = self._error.get_content_height(width)
-    offset = self._scroll_panel.update(rect, title_height + error_height + 100)
-    y = rect.y + 40 + offset
-
-    rl.begin_scissor_mode(int(rect.x), int(rect.y), int(rect.width), int(rect.height))
-    self._title.render(rl.Rectangle(rect.x + 40, y, width, title_height))
-    self._error.render(rl.Rectangle(rect.x + 40, y + title_height + 20, width, error_height))
-    rl.end_scissor_mode()
-
-
-class EsimUI(NavScroller):
-  def __init__(self, cellular_manager: CellularManager, profiles_enabled: Callable[[], bool]):
-    super().__init__()
-
-    self._cellular_manager = cellular_manager
-    self._profiles_enabled = profiles_enabled
-
-    self._add_profile_btn = BigButton("add profile", "scan QR code")
-    self._add_profile_btn.set_click_callback(self._on_add_profile)
-    self._scroller.add_widget(self._add_profile_btn)
-    self._installing_dialog: InstallingProfileDialog | None = None
-
-    self._cellular_manager.on_profiles_updated = self._on_profiles_updated
-    self._cellular_manager.on_operation_error = self._on_error
-
-  def show_event(self):
-    super().show_event()
-    self._update_buttons(re_sort=True)
-    self._cellular_manager.refresh_profiles()
-
-  def _on_profiles_updated(self):
-    if self._installing_dialog:
-      existing = {btn.profile.iccid for btn in self._scroller.items if isinstance(btn, EsimProfileButton)}
-      added = [profile for profile in self._cellular_manager.profiles if profile.iccid not in existing]
-      # Start the normal tap-to-activate flow once the profile list is visible again.
-      self._installing_dialog.dismiss(lambda: self._on_profile_clicked(added[0]) if len(added) == 1 else None)
-      self._installing_dialog = None
-
-    self._update_buttons()
-
-  def _update_buttons(self, re_sort: bool = False):
-    existing = {btn.profile.iccid: btn for btn in self._scroller.items if isinstance(btn, EsimProfileButton)}
-    buttons = []
-    for profile in self._cellular_manager.profiles:
-      btn = existing.get(profile.iccid)
-      if btn is None:
-        btn = EsimProfileButton(profile, self._cellular_manager, self._profiles_enabled)
-        btn.set_click_callback(lambda btn=btn: self._on_profile_clicked(btn.profile))
-        self._scroller.add_widget(btn)
-      else:
-        btn.update_profile(profile)
-      buttons.append(btn)
-
-    if re_sort:
-      self._scroller.items[:] = sorted(buttons, key=lambda b: not b.profile.enabled)
-    else:
-      self._scroller.items[:] = [btn for btn in self._scroller.items if btn in buttons]
-
-    self._scroller.items.append(self._add_profile_btn)
-
-  def _move_profile_to_front(self, iccid: str | None, scroll: bool = False):
-    front_btn_idx = next((i for i, btn in enumerate(self._scroller.items)
-                          if isinstance(btn, EsimProfileButton) and btn.profile.iccid == iccid), None) if iccid else None
-
-    if front_btn_idx is not None and front_btn_idx > 0:
-      self._scroller.move_item(front_btn_idx, 0)
-
-      if scroll:
-        self._scroller.scroll_to(self._scroller.scroll_panel.get_offset(), smooth=True)
-
-  def _update_state(self):
-    super()._update_state()
-
-    self._add_profile_btn.set_enabled(not self._cellular_manager.busy and self._profiles_enabled())
-    active = self._cellular_manager.active_profile
-    self._move_profile_to_front(active.iccid if active else None)
-
-  def _on_add_profile(self):
-    if self._cellular_manager.busy or not self._profiles_enabled():
-      return
-    if ui_state.sm["deviceState"].networkType == log.DeviceState.NetworkType.none:
-      gui_app.push_widget(BigDialog("", tr("Ensure you're connected to the internet and try again.")))
-      return
-    gui_app.push_widget(QRScannerDialog(on_qr_detected=self._on_qr_scanned))
-
-  def _on_qr_scanned(self, lpa_code: str):
-    dlg = BigInputDialog("enter a nickname...", text_validator=lambda text: bool(text.strip()),
-                         confirm_callback=lambda nickname: self._download_profile(lpa_code, nickname))
-    gui_app.push_widget(dlg)
-
-  def _download_profile(self, lpa_code: str, nickname: str):
-    self._installing_dialog = InstallingProfileDialog()
-    gui_app.push_widget(self._installing_dialog)
-    self._cellular_manager.download_profile(lpa_code, nickname.strip())
-
-  def _on_error(self, error: str):
-    cloudlog.error("eSIM error: %s", error)
-    dlg = EsimErrorDialog(error)
-    if self._installing_dialog:
-      self._installing_dialog.dismiss(lambda: gui_app.push_widget(dlg))
-      self._installing_dialog = None
-    else:
-      gui_app.push_widget(dlg)
-
-  def _on_profile_clicked(self, profile: Profile):
-    if self._cellular_manager.busy or not self._profiles_enabled():
-      return
-    self._cellular_manager.switch_profile(profile.iccid)
-    self._move_profile_to_front(profile.iccid, scroll=True)

openpilot/selfdrive/ui/mici/layouts/settings/network/network_layout.py

@@ -1,13 +1,12 @@
-from openpilot.selfdrive.ui.mici.layouts.settings.network import EsimNetworkButton, WifiNetworkButton
-from openpilot.selfdrive.ui.mici.layouts.settings.network.esim_ui import EsimUI
+from openpilot.system.ui.widgets.scroller import NavScroller
+from openpilot.selfdrive.ui.mici.layouts.settings.network import WifiNetworkButton
 from openpilot.selfdrive.ui.mici.layouts.settings.network.wifi_ui import WifiUIMici
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton, BigMultiToggle, BigParamControl, BigToggle
 from openpilot.selfdrive.ui.mici.widgets.dialog import BigInputDialog
 from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.selfdrive.ui.lib.prime_state import PrimeType
 from openpilot.system.ui.lib.application import gui_app
-from openpilot.system.ui.lib.cellular_manager import CellularManager
 from openpilot.system.ui.lib.wifi_manager import WifiManager, Network, MeteredType
-from openpilot.system.ui.widgets.scroller import NavScroller
 
 
 class NetworkLayoutMici(NavScroller):
@@ -29,8 +28,7 @@ class NetworkLayoutMici(NavScroller):
       self._network_metered_btn.set_enabled(False)
       self._wifi_manager.set_tethering_active(checked)
 
-    self._tethering_toggle_btn = BigToggle("enable tethering", "", toggle_callback=tethering_toggle_callback,
-                                           description="Share the device’s internet connection through a Wi-Fi hotspot.")
+    self._tethering_toggle_btn = BigToggle("enable tethering", "", toggle_callback=tethering_toggle_callback)
 
     def tethering_password_callback(password: str):
       if password:
@@ -60,39 +58,26 @@ class NetworkLayoutMici(NavScroller):
 
     # TODO: signal for current network metered type when changing networks, this is wrong until you press it once
     # TODO: disable when not connected
-    self._network_metered_btn = BigMultiToggle("network usage", ["default", "metered", "unmetered"], select_callback=network_metered_callback,
-                                               description="Metered prevents large uploads on this Wi-Fi connection. Default uses the network’s detected " +
-                                                           "setting.")
+    self._network_metered_btn = BigMultiToggle("network usage", ["default", "metered", "unmetered"], select_callback=network_metered_callback)
     self._network_metered_btn.set_enabled(False)
 
     self._wifi_button = WifiNetworkButton(self._wifi_manager)
     self._wifi_button.set_click_callback(lambda: gui_app.push_widget(self._wifi_ui))
 
-    # ******** eSIM ********
-    self._cellular_manager = CellularManager()
-    self._esim_ui = EsimUI(
-      self._cellular_manager,
-      lambda: not ui_state.prime_state.is_full_prime(),
-    )
-    self._esim_button = EsimNetworkButton(self._cellular_manager)
-    self._esim_button.set_click_callback(lambda: gui_app.push_widget(self._esim_ui))
-
     # ******** Advanced settings ********
     # ******** Roaming toggle ********
-    self._roaming_btn = BigParamControl("enable roaming", "GsmRoaming", description="Allow cellular data roaming.")
+    self._roaming_btn = BigParamControl("enable roaming", "GsmRoaming")
 
     # ******** APN settings ********
-    self._apn_btn = BigButton("apn settings", "edit",
-                              description="Set the access point name required by your cellular carrier. Leave blank for automatic configuration.")
+    self._apn_btn = BigButton("apn settings", "edit")
     self._apn_btn.set_click_callback(self._edit_apn)
 
     # ******** Cellular metered toggle ********
-    self._cellular_metered_btn = BigParamControl("cellular metered", "GsmMetered", description="Prevent large uploads over the cellular connection.")
+    self._cellular_metered_btn = BigParamControl("cellular metered", "GsmMetered")
 
     # Main scroller ----------------------------------
     self._scroller.add_widgets([
       self._wifi_button,
-      self._esim_button,
       self._network_metered_btn,
       self._tethering_toggle_btn,
       self._tethering_password_btn,
@@ -106,7 +91,8 @@ class NetworkLayoutMici(NavScroller):
   def _update_state(self):
     super()._update_state()
 
-    show_cell_settings = not ui_state.prime_state.is_full_prime()
+    # If not using prime SIM, show GSM settings and enable IPv4 forwarding
+    show_cell_settings = ui_state.prime_state.get_type() in (PrimeType.NONE, PrimeType.LITE)
     self._wifi_manager.set_ipv4_forward(show_cell_settings)
     self._roaming_btn.set_visible(show_cell_settings)
     self._apn_btn.set_visible(show_cell_settings)
@@ -116,16 +102,14 @@ class NetworkLayoutMici(NavScroller):
     super().show_event()
     self._wifi_manager.set_active(True)
 
-    # Process wifi and esim callbacks while at any point in the nav stack
+    # Process wifi callbacks while at any point in the nav stack
     gui_app.add_nav_stack_tick(self._wifi_manager.process_callbacks)
-    gui_app.add_nav_stack_tick(self._cellular_manager.process_callbacks)
 
   def hide_event(self):
     super().hide_event()
     self._wifi_manager.set_active(False)
 
     gui_app.remove_nav_stack_tick(self._wifi_manager.process_callbacks)
-    gui_app.remove_nav_stack_tick(self._cellular_manager.process_callbacks)
 
   def _edit_apn(self):
     def update_apn(apn: str):

openpilot/selfdrive/ui/mici/layouts/settings/settings.py

@@ -3,7 +3,7 @@ from openpilot.system.ui.widgets.scroller import NavScroller
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton
 from openpilot.selfdrive.ui.mici.layouts.settings.toggles import TogglesLayoutMici
 from openpilot.selfdrive.ui.mici.layouts.settings.network.network_layout import NetworkLayoutMici
-from openpilot.selfdrive.ui.mici.layouts.settings.device import DeviceLayoutMici
+from openpilot.selfdrive.ui.mici.layouts.settings.device import DeviceLayoutMici, PairBigButton
 from openpilot.selfdrive.ui.mici.layouts.settings.developer import DeveloperLayoutMici
 from openpilot.selfdrive.ui.mici.layouts.settings.software import SoftwareLayoutMici
 from openpilot.selfdrive.ui.mici.layouts.settings.firehose import FirehoseLayout
@@ -49,6 +49,7 @@ class SettingsLayout(NavScroller):
       network_btn,
       device_btn,
       software_btn,
+      PairBigButton(),
       firehose_btn,
       developer_btn,
     ])

openpilot/selfdrive/ui/mici/layouts/settings/software.py

@@ -242,8 +242,7 @@ class BranchSelectPage(NavScroller):
 
 class TargetBranchButton(BigButton):
   def __init__(self, check_update_btn: CheckUpdateButton):
-    super().__init__("target branch", ui_state.params.get("UpdaterTargetBranch") or "",
-                     description="Select the software branch to download on the next update check.")
+    super().__init__("target branch", ui_state.params.get("UpdaterTargetBranch") or "")
     self._check_update_btn = check_update_btn
     self.set_click_callback(self._on_click)
     self.set_visible(not ui_state.params.get_bool("IsTestedBranch"))
@@ -277,9 +276,7 @@ class SoftwareLayoutMici(NavScroller):
 
     uninstall_openpilot_btn = EngagedConfirmationButton("uninstall sunnypilot", "uninstall",
                                                         gui_app.texture("icons_mici/settings/device/uninstall.png", 64, 64),
-                                                        uninstall_openpilot_callback, exit_on_confirm=False,
-                                                        description="Remove openpilot from this device.",
-                                                        description_icon=gui_app.texture("icons_mici/setup/factory_reset.png", 64, 64))
+                                                        uninstall_openpilot_callback, exit_on_confirm=False)
 
     check_update_btn = CheckUpdateButton()
     self._scroller.add_widgets([

openpilot/selfdrive/ui/mici/layouts/settings/toggles.py

@@ -41,34 +41,15 @@ class TogglesLayoutMici(NavScroller):
   def __init__(self):
     super().__init__()
 
-    self._personality_toggle = BigMultiParamToggle("driving personality", "LongitudinalPersonality", ["aggressive", "standard", "relaxed"],
-                                                   description="Standard is recommended.\n" +
-                                                               "Aggressive follows closer, with firmer gas and braking.\n" +
-                                                               "Relaxed leaves more space.\n" +
-                                                               "Use the steering wheel distance button on supported cars.")
-    self._experimental_btn = BigToggle("experimental mode", description_icon=gui_app.texture("icons_mici/experimental_mode.png", 64, 64),
-                                       initial_state=ui_state.params.get_bool("ExperimentalMode"), toggle_callback=self._on_experimental_mode,
-                                       description="Let the driving model control gas and brakes.\n" +
-                                                   "Includes stopping for red lights and stop signs.\n" +
-                                                   "Set speed is a maximum, not a target.\n" +
-                                                   "These are alpha features. Expect mistakes.\n" +
-                                                   "The path colors show acceleration and braking.")
+    self._personality_toggle = BigMultiParamToggle("driving personality", "LongitudinalPersonality", ["aggressive", "standard", "relaxed"])
+    self._experimental_btn = BigToggle("experimental mode", initial_state=ui_state.params.get_bool("ExperimentalMode"),
+                                       toggle_callback=self._on_experimental_mode)
     is_metric_toggle = BigParamControl("use metric units", "IsMetric")
-    ldw_toggle = BigParamControl("lane departure warnings", "IsLdwEnabled",
-                                 description="Warn when you drift across a detected lane line.\n" +
-                                             "Only above 31 mph (50 km/h), with no turn signal.")
-    always_on_dm_toggle = BigParamControl("always-on driver monitor", "AlwaysOnDM", description="Monitor the driver even when sunnypilot is not engaged.")
-    record_front = BigParamControl("record & upload cabin camera", "RecordFront",
-                                   description_icon=gui_app.texture("icons_mici/settings/device/cameras.png", 64, 64),
-                                   toggle_callback=restart_needed_callback, description="Upload cabin camera data to help improve driver monitoring.")
-    record_mic = BigParamControl("record & upload mic audio", "RecordAudio", description_icon=gui_app.texture("icons_mici/microphone.png", 64, 64),
-                                 toggle_callback=restart_needed_callback,
-                                 description="Record microphone audio while driving.\n" +
-                                             "Audio is included in dashcam videos in sunnylink.")
-    enable_openpilot = BigParamControl("enable sunnypilot", "OpenpilotEnabledToggle", toggle_callback=restart_needed_callback,
-                                       description="Enable to use sunnypilot driver assistance.\n" +
-                                                   "Disable to use your car's stock driver assistance.")
-
+    ldw_toggle = BigParamControl("lane departure warnings", "IsLdwEnabled")
+    always_on_dm_toggle = BigParamControl("always-on driver monitor", "AlwaysOnDM")
+    record_front = BigParamControl("record & upload cabin camera", "RecordFront", toggle_callback=restart_needed_callback)
+    record_mic = BigParamControl("record & upload mic audio", "RecordAudio", toggle_callback=restart_needed_callback)
+    enable_openpilot = BigParamControl("enable sunnypilot", "OpenpilotEnabledToggle", toggle_callback=restart_needed_callback)
 
     self._scroller.add_widgets([
       self._personality_toggle,

openpilot/selfdrive/ui/mici/widgets/button.py

@@ -29,41 +29,9 @@ class ScrollState(Enum):
   POST_SCROLL = 2
 
 
-class BaseButton(Widget):
-  def __init__(self, description: str, title: str, icon: Union[rl.Texture, None] = None):
+class BigCircleButton(Widget):
+  def __init__(self, icon: rl.Texture, red: bool = False, icon_offset: tuple[int, int] = (0, 0)):
     super().__init__()
-    self._shake_start: float | None = None
-    if description:
-      # Dialogs also use buttons; import lazily to avoid a circular import.
-      from openpilot.selfdrive.ui.mici.widgets.dialog import SettingDescriptionDialog
-      self.set_long_press_callback(lambda: gui_app.push_widget(SettingDescriptionDialog(title, description, icon)))
-    else:
-      self.set_long_press_callback(self.trigger_shake)
-
-  def trigger_shake(self):
-    self._shake_start = rl.get_time()
-
-  @property
-  def _shake_offset(self) -> float:
-    SHAKE_DURATION = 0.5
-    SHAKE_AMPLITUDE = 24.0
-    SHAKE_FREQUENCY = 32.0
-    if self._shake_start is None:
-      return 0.0
-    t = rl.get_time() - self._shake_start
-    if t > SHAKE_DURATION:
-      return 0.0
-    decay = 1.0 - t / SHAKE_DURATION
-    return decay * SHAKE_AMPLITUDE * math.sin(t * SHAKE_FREQUENCY)
-
-  def set_position(self, x: float, y: float) -> None:
-    super().set_position(x + self._shake_offset, y)
-
-class BigCircleButton(BaseButton):
-  def __init__(self, icon: rl.Texture, red: bool = False, icon_offset: tuple[int, int] = (0, 0),
-               *, description: str = "",
-               description_icon: Union[rl.Texture, None] = None, title: str = ""):
-    super().__init__(description, title, description_icon or icon)
     self._red = red
     self._icon_offset = icon_offset
 
@@ -105,9 +73,8 @@ class BigCircleButton(BaseButton):
 
 
 class BigCircleToggle(BigCircleButton):
-  def __init__(self, icon: rl.Texture, toggle_callback: Callable | None = None, icon_offset: tuple[int, int] = (0, 0),
-               *, description: str = "", description_icon: Union[rl.Texture, None] = None, title: str = ""):
-    super().__init__(icon, False, icon_offset=icon_offset, description=description, description_icon=description_icon, title=title)
+  def __init__(self, icon: rl.Texture, toggle_callback: Callable | None = None, icon_offset: tuple[int, int] = (0, 0)):
+    super().__init__(icon, False, icon_offset=icon_offset)
     self._toggle_callback = toggle_callback
 
     # State
@@ -136,16 +103,14 @@ class BigCircleToggle(BigCircleButton):
                        0, 1.0, rl.WHITE)
 
 
-class BigButton(BaseButton):
+class BigButton(Widget):
   LABEL_HORIZONTAL_PADDING = 40
   LABEL_VERTICAL_PADDING = 23  # visually matches 30 in figma
 
   """A lightweight stand-in for the Qt BigButton, drawn & updated each frame."""
 
-  def __init__(self, text: str, value: str = "", icon: Union[rl.Texture, None] = None, scroll: bool = False,
-               *, description: str = "",
-               description_icon: Union[rl.Texture, None] = None):
-    super().__init__(description, text, description_icon or icon or None)
+  def __init__(self, text: str, value: str = "", icon: Union[rl.Texture, None] = None, scroll: bool = False):
+    super().__init__()
     self.set_rect(rl.Rectangle(0, 0, 402, 180))
     self.text = text
     self.value = value
@@ -154,6 +119,7 @@ class BigButton(BaseButton):
 
     self._scale_filter = BounceFilter(1.0, 0.1, 1 / gui_app.target_fps)
     self._click_delay = 0.075
+    self._shake_start: float | None = None
     self._grow_animation_until: float | None = None
 
     self._rotate_icon_t: float | None = None
@@ -221,9 +187,28 @@ class BigButton(BaseButton):
   def get_text(self):
     return self.text
 
+  def trigger_shake(self):
+    self._shake_start = rl.get_time()
+
   def trigger_grow_animation(self, duration: float = 0.65):
     self._grow_animation_until = rl.get_time() + duration
 
+  @property
+  def _shake_offset(self) -> float:
+    SHAKE_DURATION = 0.5
+    SHAKE_AMPLITUDE = 24.0
+    SHAKE_FREQUENCY = 32.0
+    if self._shake_start is None:
+      return 0.0
+    t = rl.get_time() - self._shake_start
+    if t > SHAKE_DURATION:
+      return 0.0
+    decay = 1.0 - t / SHAKE_DURATION
+    return decay * SHAKE_AMPLITUDE * math.sin(t * SHAKE_FREQUENCY)
+
+  def set_position(self, x: float, y: float) -> None:
+    super().set_position(x + self._shake_offset, y)
+
   def _handle_background(self) -> tuple[rl.Texture, float, float, float]:
     if self._grow_animation_until is not None:
       if rl.get_time() >= self._grow_animation_until:
@@ -287,10 +272,8 @@ class BigButton(BaseButton):
 
 
 class BigToggle(BigButton):
-  def __init__(self, text: str, value: str = "", initial_state: bool = False, toggle_callback: Callable | None = None,
-               *, description: str = "",
-               description_icon: Union[rl.Texture, None] = None):
-    super().__init__(text, value, "", description=description, description_icon=description_icon)
+  def __init__(self, text: str, value: str = "", initial_state: bool = False, toggle_callback: Callable | None = None):
+    super().__init__(text, value, "")
     self._checked = initial_state
     self._toggle_callback = toggle_callback
 
@@ -325,8 +308,8 @@ class BigToggle(BigButton):
 
 class BigMultiToggle(BigToggle):
   def __init__(self, text: str, options: list[str], toggle_callback: Callable | None = None,
-               select_callback: Callable | None = None, *, description: str = "", description_icon: Union[rl.Texture, None] = None):
-    super().__init__(text, "", toggle_callback=toggle_callback, description=description, description_icon=description_icon)
+               select_callback: Callable | None = None):
+    super().__init__(text, "", toggle_callback=toggle_callback)
     assert len(options) > 0
     self._options = options
     self._select_callback = select_callback
@@ -391,9 +374,9 @@ class GreyBigButton(BigButton):
 
 class BigMultiParamToggle(BigMultiToggle):
   def __init__(self, text: str, param: str, options: list[str], toggle_callback: Callable | None = None,
-               select_callback: Callable | None = None, *, description: str = "", description_icon: Union[rl.Texture, None] = None):
+               select_callback: Callable | None = None):
     assert Params is not None
-    super().__init__(text, options, toggle_callback, select_callback, description=description, description_icon=description_icon)
+    super().__init__(text, options, toggle_callback, select_callback)
     self._param = param
 
     self._params = Params()
@@ -409,10 +392,9 @@ class BigMultiParamToggle(BigMultiToggle):
 
 
 class BigParamControl(BigToggle):
-  def __init__(self, text: str, param: str, toggle_callback: Callable | None = None, *, description: str = "",
-               description_icon: Union[rl.Texture, None] = None):
+  def __init__(self, text: str, param: str, toggle_callback: Callable | None = None):
     assert Params is not None
-    super().__init__(text, "", toggle_callback=toggle_callback, description=description, description_icon=description_icon)
+    super().__init__(text, "", toggle_callback=toggle_callback)
     self.param = param
     self.params = Params()
     self.set_checked(self.params.get_bool(self.param, False))
@@ -428,9 +410,9 @@ class BigParamControl(BigToggle):
 # TODO: param control base class
 class BigCircleParamControl(BigCircleToggle):
   def __init__(self, icon: rl.Texture, param: str, toggle_callback: Callable | None = None,
-               icon_offset: tuple[int, int] = (0, 0), *, description: str = "", description_icon: Union[rl.Texture, None] = None, title: str = ""):
+               icon_offset: tuple[int, int] = (0, 0)):
     assert Params is not None
-    super().__init__(icon, toggle_callback, icon_offset=icon_offset, description=description, description_icon=description_icon, title=title)
+    super().__init__(icon, toggle_callback, icon_offset=icon_offset)
     self._param = param
     self.params = Params()
     self.set_checked(self.params.get_bool(self._param, False))

openpilot/selfdrive/ui/mici/widgets/dialog.py

@@ -1,11 +1,9 @@
 import abc
 import math
-import re
 import pyray as rl
 from typing import Union
 from collections.abc import Callable
 from openpilot.system.ui.widgets.nav_widget import NavWidget
-from openpilot.system.ui.widgets.scroller import NavScroller
 from openpilot.system.ui.widgets.label import UnifiedLabel
 from openpilot.system.ui.widgets.mici_keyboard import MiciKeyboard
 from openpilot.system.ui.lib.text_measure import measure_text_cached
@@ -39,31 +37,6 @@ class BigDialog(BigDialogBase):
     ))
 
 
-class SettingDescriptionDialog(NavScroller):
-  def __init__(self, title: str, description: str, icon: Union[rl.Texture, None] = None):
-    super().__init__()
-    cards = [GreyBigButton(title, "scroll for details", icon or gui_app.texture("icons_mici/setup/green_info.png", 64, 64))]
-    # Explicit lines are authored cards; otherwise prefer sentence boundaries.
-    paragraphs = description.splitlines() if "\n" in description else re.split(r"(?<=[.!?])\s+", description.strip())
-    # Measure each card so longer text still fits with the actual font and padding.
-    for sentence in paragraphs:
-      card = GreyBigButton("", "")
-      words: list[str] = []
-      for word in sentence.split():
-        card.set_value(" ".join([*words, word]))
-        height = card._sub_label.get_content_height(card._subtitle_width_hint())
-        if words and height > card.rect.height - 2 * card.LABEL_VERTICAL_PADDING:
-          card.set_value(" ".join(words))
-          cards.append(card)
-          card = GreyBigButton("", "")
-          words = []
-        words.append(word)
-      if words:
-        card.set_value(" ".join(words))
-        cards.append(card)
-    self._scroller.add_widgets(cards)
-
-
 class BigConfirmationDialog(BigDialogBase):
   def __init__(self, title: str, icon: rl.Texture, confirm_callback: Callable[[], None],
                exit_on_confirm: bool = True, red: bool = False):
@@ -103,15 +76,14 @@ class BigInputDialog(BigDialogBase):
                default_text: str = "",
                minimum_length: int = 1,
                confirm_callback: Callable[[str], None] | None = None,
-               auto_return_to_letters: str = "",
-               text_validator: Callable[[str], bool] | None = None):
+               auto_return_to_letters: str = ""):
     super().__init__()
     self._hint_label = UnifiedLabel(hint, font_size=35, text_color=rl.Color(255, 255, 255, int(255 * 0.35)),
                                     font_weight=FontWeight.MEDIUM)
     self._keyboard = MiciKeyboard(auto_return_to_letters=auto_return_to_letters)
     self._keyboard.set_text(default_text)
     self._keyboard.set_enabled(lambda: self.enabled and not self.is_dismissing)  # for nav stack + NavWidget
-    self._text_valid = lambda text: len(text) >= minimum_length and (text_validator is None or text_validator(text))
+    self._minimum_length = minimum_length
 
     self._backspace_held_time: float | None = None
 
@@ -128,8 +100,7 @@ class BigInputDialog(BigDialogBase):
 
     def confirm_callback_wrapper():
       text = self._keyboard.text()
-      if self._text_valid(text):
-        self.dismiss((lambda: confirm_callback(text)) if confirm_callback else None)
+      self.dismiss((lambda: confirm_callback(text)) if confirm_callback else None)
     self._confirm_callback = confirm_callback_wrapper
 
   def _update_state(self):
@@ -214,7 +185,7 @@ class BigInputDialog(BigDialogBase):
                                                self._rect.width - (text_field_rect.x + text_field_rect.width), self._top_left_button_rect.height)
 
     # draw enter button
-    self._enter_img_alpha.update(255 if self._text_valid(text) else 0)
+    self._enter_img_alpha.update(255 if len(text) >= self._minimum_length else 0)
     color = rl.Color(255, 255, 255, int(self._enter_img_alpha.x))
     rl.draw_texture_ex(self._enter_img, rl.Vector2(self._rect.x + PADDING / 2, self._rect.y), 0.0, 1.0, color)
     color = rl.Color(255, 255, 255, 255 - int(self._enter_img_alpha.x))

openpilot/selfdrive/ui/sunnypilot/layouts/settings/models.py

@@ -4,6 +4,7 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
+import os
 import re
 import time
 import pyray as rl
@@ -12,8 +13,7 @@ from openpilot.cereal import custom
 from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_selected_bundle, resolve_bundle_by_ref
 from openpilot.common.constants import CV
 from openpilot.selfdrive.ui.ui_state import device, ui_state
-from openpilot.selfdrive.ui.sunnypilot.model_info import (big_model_state, bundles_for_source, carrying_model, default_model_name,
-                                                           model_cache_size_mb, queued_name, refresh_in_progress, refresh_model_list)
+from openpilot.selfdrive.ui.sunnypilot.model_info import big_model_state, bundles_for_source, carrying_model, default_model_name, queued_name
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.widgets import DialogResult, Widget
@@ -21,6 +21,7 @@ from openpilot.system.ui.widgets.confirm_dialog import alert_dialog, ConfirmDial
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets.toggle import ON_COLOR
 
+from openpilot.sunnypilot.models.runners.constants import CUSTOM_MODEL_PATH
 from openpilot.system.ui.sunnypilot.lib.styles import style
 from openpilot.system.ui.sunnypilot.lib.utils import NoElideButtonAction, ScrollingButtonAction
 from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP, toggle_item_sp, option_item_sp
@@ -39,9 +40,6 @@ class ModelsLayout(Widget):
     self._selection_source = None
     self._downloading = False
     self._verifying = False
-    self._clearing = False
-    self._refreshing = False
-    self._refresh_start: float | None = None
     self._last_note = None
     self.last_cache_calc_time = 0
 
@@ -69,14 +67,15 @@ class ModelsLayout(Widget):
 
     self.download_item = download_status_item(lambda: tr("Download") if self._downloading else tr("Model Status"))
 
-    self.refresh_item = button_item(tr("Refresh Model List"),
-                                    lambda: tr("FETCHING...") if self._refreshing else tr("REFRESH"), "",
-                                    self._refresh_models)
+    self.refresh_item = button_item(tr("Refresh Model List"), tr("REFRESH"), "",
+                                    lambda: (ui_state.params.put("ModelManager_LastSyncTime", 0),
+                                             ui_state.params.put("ModelManager_LastSyncTime_Chestnut", 0),
+                                             gui_app.push_widget(alert_dialog(tr("Fetching Latest Models")))))
 
     self.clear_cache_item = ListItemSP(
       title=tr("Clear Model Cache"),
       description="",
-      action_item=NoElideButtonAction(lambda: tr("CLEARING...") if self._clearing else tr("CLEAR")),
+      action_item=NoElideButtonAction(tr("CLEAR")),
       callback=self._clear_cache
     )
 
@@ -116,38 +115,39 @@ class ModelsLayout(Widget):
     if lagd_toggle:
       desc += f"<br>{tr('Live Steer Delay:')} {ui_state.sm['lateralDelay'].lateralDelay:.3f} s"
     elif ui_state.CP is not None:
-      sw = float(ui_state.params.get("LagdToggleDelay", return_default=True))
+      sw = float(ui_state.params.get("LagdToggleDelay", "0.2"))
       cp = ui_state.CP.steerActuatorDelay
       desc += f"<br>{tr('Actuator Delay:')} {cp:.2f} s + {tr('Software Delay:')} {sw:.2f} s = {tr('Total Delay:')} {cp + sw:.2f} s"
     self.lagd_toggle.set_description(desc)
 
   @staticmethod
   def calculate_cache_size():
-    return model_cache_size_mb()
+    cache_size = 0.0
+    if os.path.exists(CUSTOM_MODEL_PATH):
+      for file in os.listdir(CUSTOM_MODEL_PATH):
+        try:
+          cache_size += os.path.getsize(os.path.join(CUSTOM_MODEL_PATH, file))
+        except OSError:
+          continue
+    return cache_size / (1024**2)
 
   def _clear_cache(self):
     def _callback(response):
       if response == DialogResult.CONFIRM:
         ui_state.params.put_bool("ModelManager_ClearCache", True)
+        self.clear_cache_item.action_item.set_value(f"{self.calculate_cache_size():.2f} MB")
 
     dialog = ConfirmDialog(tr("This will delete ALL downloaded models from the cache except the currently active model. Are you sure?"),
                            tr("Clear Cache"), callback=_callback)
     gui_app.push_widget(dialog)
 
-  def _refresh_models(self):
-    refresh_model_list()
-    self._refresh_start = time.monotonic()
-
   def _handle_bundle_download_progress(self):
     self.cancel_download_item.set_visible(False)
     self._downloading = False
     self._verifying = False
     self.download_item.set_visible(True)
 
-    self._clearing = ui_state.params.get_bool("ModelManager_ClearCache")
-    if self._clearing:
-      self.last_cache_calc_time = 0.0  # refresh the size as soon as clearing finishes
-    elif (current_time := time.monotonic()) - self.last_cache_calc_time > 0.5:
+    if (current_time := time.monotonic()) - self.last_cache_calc_time > 0.5:
       self.last_cache_calc_time = current_time
       self.clear_cache_item.action_item.set_value(f"{self.calculate_cache_size():.2f} MB")
 
@@ -345,13 +345,6 @@ class ModelsLayout(Widget):
     self.big_model_item.action_item.set_enabled(offroad)
     self.small_model_item.set_description("" if offroad else tr("Only available when vehicle is off, or always offroad mode is on"))
 
-    # manager is offroad-only, so an onroad clear would never be serviced
-    self.clear_cache_item.action_item.set_enabled(offroad and not self._downloading and not self._clearing)
-
-    # manager is offroad-only, so a refresh queued onroad would never be serviced
-    self._refreshing = refresh_in_progress(self._refresh_start)
-    self.refresh_item.action_item.set_enabled(offroad and not self._downloading and not self._refreshing)
-
   def _render(self, rect):
     self._scroller.render(rect)
 

openpilot/selfdrive/ui/sunnypilot/layouts/settings/sunnylink.py

@@ -5,22 +5,42 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 import pyray as rl
+from functools import partial
 from openpilot.cereal import custom
+from openpilot.common.version import sunnylink_consent_version
 from openpilot.selfdrive.ui.sunnypilot.layouts.onboarding import SunnylinkConsentPage
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.sunnypilot.sunnylink.athena.local_discovery import latest_discovered_app
+from openpilot.sunnypilot.sunnylink.athena.local_pairing import (
+  LocalApp,
+  arm_pairing,
+  clear_pairing_request,
+  get_local_apps,
+  local_app_display_name,
+  pairing_requested,
+  read_pairing_code,
+  remove_local_app,
+)
 from openpilot.system.ui.lib.application import gui_app, FontWeight, TextAlignment, TextAlignmentVertical
 from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.sunnypilot.widgets.list_view import button_item_sp
-from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.lib.wrap_text import wrap_text
+from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP, button_item_sp, toggle_item_sp
 from openpilot.system.ui.sunnypilot.widgets.sunnylink_pairing_dialog import SunnylinkPairingDialog
 from openpilot.system.ui.widgets import Widget, DialogResult
-from openpilot.system.ui.widgets.button import ButtonStyle, Button
+from openpilot.system.ui.widgets.button import ButtonStyle, Button, IconButton
 from openpilot.system.ui.widgets.confirm_dialog import alert_dialog, ConfirmDialog
 from openpilot.system.ui.widgets.label import UnifiedLabel
 from openpilot.system.ui.widgets.list_view import dual_button_item
+from openpilot.system.ui.widgets.network import NavButton
 from openpilot.system.ui.widgets.scroller_tici import Scroller, LineSeparator
-from openpilot.common.version import sunnylink_consent_version
+
+MAX_LOCAL_APPS = 4
+
+# Read-only value colors used by the local-mode rows.
+_LOCAL_DISCOVERED_COLOR = rl.Color(170, 170, 170, 255)  # grey: no app in sight
+_LOCAL_ACTIVE_COLOR = rl.Color(0, 255, 0, 255)          # green: discovered / pairing code
 
 
 class SunnylinkHeader(Widget):
@@ -192,6 +212,15 @@ class SunnylinkLayout(Widget):
     self._backup_btn.set_button_style(ButtonStyle.NORMAL)
     self._restore_btn.set_button_style(ButtonStyle.PRIMARY)
 
+    self._mobile_app_btn = button_item_sp(
+      title=tr("Sunnylink Local Connections"),
+      button_text=tr("CONFIGURE"),
+      description=tr("Manage the mobile app(s) connected over Wi-Fi: pair a new app ") +
+                  tr("or unpair existing ones."),
+      callback=self._open_local_apps,
+    )
+    self._mobile_app_btn.set_visible(lambda: self._sunnylink_enabled)
+
     items = [
       SunnylinkHeader(),
       LineSeparator(),
@@ -202,9 +231,11 @@ class SunnylinkLayout(Widget):
       LineSeparator(),
       self._pair_btn,
       LineSeparator(),
+      self._mobile_app_btn,
+      LineSeparator(),
       self._sunnylink_uploader_toggle,
       LineSeparator(),
-      self._sunnylink_backup_restore_buttons
+      self._sunnylink_backup_restore_buttons,
     ]
     return items
 
@@ -317,6 +348,8 @@ class SunnylinkLayout(Widget):
       gui_app.push_widget(sl_terms_dlg)
     else:
       ui_state.params.put_bool("SunnylinkEnabled", state)
+      if not state:
+        clear_pairing_request()
       self._update_description(state)
 
   def _update_description(self, state: bool):
@@ -352,6 +385,9 @@ class SunnylinkLayout(Widget):
     self._pair_btn.action_item.set_text(pair_btn_text)
     self._pair_btn.action_item.set_enabled(self._sunnylink_enabled)
 
+  def _open_local_apps(self):
+    gui_app.push_widget(SunnylinkLocalAppLayout())
+
   def _render(self, rect):
     self._scroller.render(rect)
 
@@ -364,3 +400,157 @@ class SunnylinkLayout(Widget):
   def hide_event(self):
     super().hide_event()
     ui_state.sunnylink_state.set_settings_open(False)
+
+
+class SunnylinkLocalAppLayout(Widget):
+
+  def __init__(self):
+    super().__init__()
+    self._local_apps_cache: list[LocalApp] = []
+
+    self._back_button = NavButton(tr("Back"))
+    self._back_button.set_click_callback(gui_app.pop_widget)
+
+    self._pair_app_btn = button_item_sp(
+      title=tr("Pair App"),
+      button_text=tr("PAIR"),
+      description=tr("Open a 5-minute pairing window and show the code to ") +
+                  tr("type into the app. Closing the dialog cancels pairing."),
+      callback=self._show_pairing_code_dialog,
+    )
+
+    self._local_app_rows: list[ListItemSP] = []
+    self._local_app_seps: list[LineSeparator] = []
+    for i in range(MAX_LOCAL_APPS):
+      row = button_item_sp(
+        title=lambda i=i: self._local_app_title(i),
+        button_text=tr("UNPAIR"),
+        description=lambda i=i: self._local_app_endpoint(i),
+        callback=partial(self._unpair_local_app, i),
+      )
+      sep = LineSeparator()
+      row.set_visible(lambda i=i: self._local_row_visible(i))
+      sep.set_visible(lambda i=i: self._local_row_visible(i))
+      self._local_app_rows.append(row)
+      self._local_app_seps.append(sep)
+
+    items = [self._pair_app_btn, LineSeparator()]
+    for row, sep in zip(self._local_app_rows, self._local_app_seps, strict=True):
+      items.extend((row, sep))
+    self._scroller = Scroller(items, line_separator=False, spacing=0)
+
+  def _local_row_visible(self, i: int) -> bool:
+    return i < len(self._local_apps_cache)
+
+  def _local_app_title(self, i: int) -> str:
+    if i >= len(self._local_apps_cache):
+      return ""
+    return local_app_display_name(self._local_apps_cache[i])
+
+  def _local_app_endpoint(self, i: int) -> str:
+    if i >= len(self._local_apps_cache):
+      return ""
+    return self._local_apps_cache[i].endpoint
+
+  def _show_pairing_code_dialog(self):
+    gui_app.push_widget(SunnylinkLocalPairingDialog())
+
+  def _unpair_local_app(self, index: int):
+    apps = self._local_apps_cache
+    if index >= len(apps):
+      return
+    app = apps[index]
+    name = local_app_display_name(app)
+
+    def on_confirm(_dialog_result: int):
+      remove_local_app(app.app_id)
+
+    dialog = ConfirmDialog(
+      text=tr("Unpair") + f" {name}? " + tr("You will need the pairing code again to reconnect it."),
+      confirm_text=tr("Unpair"),
+      callback=on_confirm,
+    )
+    gui_app.push_widget(dialog)
+
+  def _update_state(self):
+    super()._update_state()
+    self._local_apps_cache = get_local_apps()
+
+  def _render(self, rect):
+    self._back_button.set_position(self._rect.x, self._rect.y + 20)
+    self._back_button.render()
+    content_rect = rl.Rectangle(rect.x, rect.y + self._back_button.rect.height + 40,
+                                rect.width, rect.height - self._back_button.rect.height - 40)
+    self._scroller.render(content_rect)
+
+  def show_event(self):
+    super().show_event()
+    self._scroller.show_event()
+
+  def hide_event(self):
+    super().hide_event()
+    self._scroller.hide_event()
+
+
+class SunnylinkLocalPairingDialog(Widget):
+
+  def __init__(self):
+    super().__init__()
+    self._apps_before = len(get_local_apps())
+    arm_pairing()
+    self._close_btn = IconButton(gui_app.texture("icons/close.png", 80, 80))
+    self._close_btn.set_click_callback(self._cancel)
+
+  def _cancel(self):
+    clear_pairing_request()
+    gui_app.pop_widget()
+
+  def _update_state(self):
+    if len(get_local_apps()) > self._apps_before:
+      gui_app.pop_widget()  # paired — window already cleared
+    elif not pairing_requested():
+      gui_app.pop_widget()  # window expired
+
+  def _render(self, rect) -> int:
+    rl.clear_background(rl.Color(224, 224, 224, 255))
+
+    margin = 70
+    content_rect = rl.Rectangle(rect.x + margin, rect.y + margin,
+                                rect.width - 2 * margin, rect.height - 2 * margin)
+    y = content_rect.y
+
+    close_size = 80
+    pad = 20
+    close_rect = rl.Rectangle(content_rect.x - pad, y - pad, close_size + pad * 2, close_size + pad * 2)
+    self._close_btn.render(close_rect)
+    y += close_size + 40
+
+    title_font = gui_app.font(FontWeight.NORMAL)
+    title_wrapped = wrap_text(title_font, tr("Pair with mobile app"), 75, int(content_rect.width))
+    rl.draw_text_ex(title_font, "\n".join(title_wrapped), rl.Vector2(content_rect.x, y), 75, 0.0, rl.BLACK)
+    y += len(title_wrapped) * 75 + 40
+
+    code = read_pairing_code() or "—"
+    code_font = gui_app.font(FontWeight.BOLD)
+    code_size = measure_text_cached(code_font, code, 110)
+    rl.draw_text_ex(code_font, code, rl.Vector2(content_rect.x + (content_rect.width - code_size.x) / 2, y),
+                    110, 0.0, rl.BLACK)
+    y += 170
+
+    hint_font = gui_app.font(FontWeight.NORMAL)
+    hint_wrapped = wrap_text(hint_font, tr("Enter this code in the sunnylink app on your phone."), 45,
+                             int(content_rect.width))
+    rl.draw_text_ex(hint_font, "\n".join(hint_wrapped), rl.Vector2(content_rect.x, y), 45, 0.0, rl.BLACK)
+    y += len(hint_wrapped) * 45 + 30
+
+    discovered = latest_discovered_app()
+    if discovered is not None:
+      endpoint, age = discovered
+      status = endpoint if age < 2 else f"{endpoint} ({age}s)"
+      color = _LOCAL_ACTIVE_COLOR
+    else:
+      status = tr("Waiting for the app…")
+      color = _LOCAL_DISCOVERED_COLOR
+    status_font = gui_app.font(FontWeight.NORMAL)
+    rl.draw_text_ex(status_font, status, rl.Vector2(content_rect.x, y), 40, 0.0, color)
+    return -1

openpilot/selfdrive/ui/sunnypilot/layouts/settings/vehicle/platform_selector.py

@@ -92,7 +92,7 @@ class PlatformSelector(Button):
 
   def _on_platform_selected(self, dialog, res):
     if res == DialogResult.CONFIRM and dialog.selection_ref:
-      offroad_msg = tr("This setting will take effect immediately.") if ui_state.is_offroad() else \
+      offroad_msg = tr("This setting will take effect immediately.") if ui_state.is_offroad else \
                     tr("This setting will take effect once the device enters offroad state.")
 
       callback = partial(self._confirm_platform, dialog.selection_ref)

openpilot/selfdrive/ui/sunnypilot/mici/layouts/models.py

@@ -4,18 +4,15 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
-import time
-
 import pyray as rl
 
 from openpilot.cereal import custom
-from openpilot.selfdrive.ui.mici.widgets.dialog import BigConfirmationDialog, BigDialog
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog
 from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_selected_bundle
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton
 from openpilot.selfdrive.ui.ui_state import ui_state, device
 from openpilot.selfdrive.ui.sunnypilot.model_info import (active_source, big_model_state, bundles_for_source, carrying_model,
-                                                           default_model_name, model_cache_size_mb, model_info, queued_name,
-                                                           refresh_in_progress, refresh_model_list)
+                                                           default_model_name, model_info, queued_name)
 from openpilot.system.ui.lib.application import FontWeight, gui_app
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets import Widget
@@ -84,18 +81,10 @@ class ModelsLayoutMici(NavScroller):
     self.select_model_btn = BigButton(tr("select model"))
     self.select_model_btn.set_click_callback(self._show_folders)
 
-    self.refresh_btn = BigButton(tr("refresh models"))
-    self.refresh_btn.set_click_callback(self._refresh_models)
-    self._refresh_start: float | None = None
-
     self.cancel_download_btn = BigButton(tr("cancel download"))
     self.cancel_download_btn.set_click_callback(lambda: ui_state.params.remove("ModelManager_DownloadRef"))
 
-    self.clear_cache_btn = BigButton(tr("clear cache"), value=f"{model_cache_size_mb():.1f} MB")
-    self.clear_cache_btn.set_click_callback(self._confirm_clear_cache)
-    self._cache_size_time = 0.0
-
-    self.main_items = [self.current_model_info, self.select_model_btn, self.cancel_download_btn, self.refresh_btn, self.clear_cache_btn]
+    self.main_items = [self.current_model_info, self.select_model_btn, self.cancel_download_btn]
     self._scroller.add_widgets(self.main_items)
 
   @property
@@ -173,15 +162,6 @@ class ModelsLayoutMici(NavScroller):
     ui_state.params.remove(ACTIVE_BUNDLE_KEYS[source])
     self._pop_to_main()
 
-  def _confirm_clear_cache(self):
-    icon = gui_app.texture("icons_mici/settings/network/new/trash.png", 54, 64)
-    gui_app.push_widget(BigConfirmationDialog(f"{tr('slide to')}\n{tr('clear cache')}", icon,
-                                              lambda: ui_state.params.put_bool("ModelManager_ClearCache", True), red=True))
-
-  def _refresh_models(self):
-    refresh_model_list()
-    self._refresh_start = time.monotonic()
-
   def _select_folder(self, folder_name):
     source = self._selection_source
     if source is None:  # folders are only reachable after picking a hardware
@@ -225,21 +205,6 @@ class ModelsLayoutMici(NavScroller):
       device.set_override_interactive_timeout(None)
     self._was_downloading = is_downloading
 
-    # manager is offroad-only, so an onroad clear would never be serviced
-    clearing = ui_state.params.get_bool("ModelManager_ClearCache")
-    self.clear_cache_btn.set_enabled(ui_state.is_offroad() and not is_downloading and not clearing)
-    if clearing:
-      self.clear_cache_btn.set_value(tr("clearing..."))
-      self._cache_size_time = 0.0  # refresh the size as soon as clearing finishes
-    elif (now := time.monotonic()) - self._cache_size_time > 0.5:
-      self._cache_size_time = now
-      self.clear_cache_btn.set_value(f"{model_cache_size_mb():.1f} MB")
-
-    # manager is offroad-only, so a refresh queued onroad would never be serviced
-    refreshing = refresh_in_progress(self._refresh_start)
-    self.refresh_btn.set_enabled(ui_state.is_offroad() and not is_downloading and not refreshing)
-    self.refresh_btn.set_value(tr("fetching...") if refreshing else "")
-
     self.current_model_info.current_model_header.set_text(tr("active model"))
     active_text, info_header, info_text = _model_info()
     self.current_model_info.current_model_text.set_text(active_text)

openpilot/selfdrive/ui/sunnypilot/mici/layouts/sunnylink.py

@@ -5,21 +5,34 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 import pyray as rl
-
+from functools import partial
 
 from openpilot.cereal import custom
+from openpilot.common.version import sunnylink_consent_version, sunnylink_consent_declined
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton, BigToggle
-from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigConfirmationDialog
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigConfirmationDialog, BigDialogBase
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.onboarding import SunnylinkConsentPage
 from openpilot.selfdrive.ui.sunnypilot.mici.widgets.sunnylink_pairing_dialog import SunnylinkPairingDialog
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.sunnypilot.sunnylink.athena.local_discovery import latest_discovered_app
+from openpilot.sunnypilot.sunnylink.athena.local_pairing import (
+  LocalApp,
+  arm_pairing,
+  clear_pairing_request,
+  get_local_apps,
+  local_app_display_name,
+  pairing_requested,
+  read_pairing_code,
+  remove_local_app,
+)
 from openpilot.system.ui.lib.application import gui_app, MousePos, FontWeight
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.label import UnifiedLabel
 from openpilot.system.ui.widgets.scroller import NavScroller
-from openpilot.common.version import sunnylink_consent_version, sunnylink_consent_declined
+
+MAX_LOCAL_APPS = 4
 
 class SunnylinkInfo(Widget):
   def __init__(self):
@@ -73,11 +86,15 @@ class SunnylinkLayoutMici(NavScroller):
     self._sunnylink_uploader_toggle = BigToggle(text=tr("sunnylink uploader"), initial_state=False,
                                                 toggle_callback=self._sunnylink_uploader_callback)
 
+    self._mobile_app_btn = BigButton(tr("sunnylink local"), "")
+    self._mobile_app_btn.set_click_callback(lambda: gui_app.push_widget(LocalAppsPanelMici()))
+
     self._scroller.add_widgets([
       self._sunnylink_info,
       self._sunnylink_toggle,
       self._sunnylink_sponsor_button,
       self._sunnylink_pair_button,
+      self._mobile_app_btn,
       self._backup_btn,
       self._restore_btn,
       self._sunnylink_uploader_toggle
@@ -110,6 +127,7 @@ class SunnylinkLayoutMici(NavScroller):
       self._sunnylink_pair_button.set_text(tr("paired"))
     else:
       self._sunnylink_pair_button.set_text(tr("pair"))
+    self._mobile_app_btn.set_visible(self._sunnylink_enabled)
 
   def show_event(self):
     super().show_event()
@@ -140,6 +158,8 @@ class SunnylinkLayoutMici(NavScroller):
       gui_app.push_widget(sl_terms_dlg)
     else:
       ui_state.params.put_bool("SunnylinkEnabled", state)
+      if not state:
+        clear_pairing_request()
 
     ui_state.update_params()
 
@@ -252,3 +272,108 @@ class SunnylinkPairBigButton(BigButton):
       dlg = SunnylinkPairingDialog(sponsor_pairing=False)
     if dlg:
       gui_app.push_widget(dlg)
+
+
+class LocalAppsPanelMici(NavScroller):
+
+  def __init__(self):
+    super().__init__()
+    self._local_apps_cache: list[LocalApp] = []
+
+    self._pair_app_btn = BigButton(tr("pair app"), "")
+    self._pair_app_btn.set_click_callback(lambda: gui_app.push_widget(LocalPairingCodeDialogMici()))
+
+    self._local_app_btns: list[BigButton] = []
+    for i in range(MAX_LOCAL_APPS):
+      btn = BigButton("", "")
+      btn.set_click_callback(partial(self._confirm_unpair_local_app, i))
+      self._local_app_btns.append(btn)
+
+    self._scroller.add_widgets([self._pair_app_btn, *self._local_app_btns])
+
+  def _update_state(self):
+    super()._update_state()
+    self._local_apps_cache = get_local_apps()
+    for i, btn in enumerate(self._local_app_btns):
+      btn.set_visible(i < len(self._local_apps_cache))
+      if i < len(self._local_apps_cache):
+        app = self._local_apps_cache[i]
+        btn.set_text(local_app_display_name(app))
+        btn.set_value(app.endpoint)
+
+  def _confirm_unpair_local_app(self, index: int):
+    apps = self._local_apps_cache
+    if index >= len(apps):
+      return
+    app = apps[index]
+
+    def unpair():
+      remove_local_app(app.app_id)
+
+    icon = gui_app.texture("icons_mici/settings/device/update.png", 64, 64)
+    dlg = BigConfirmationDialog(
+      tr("slide to unpair"),
+      icon,
+      confirm_callback=unpair,
+      red=True,
+    )
+    gui_app.push_widget(dlg)
+
+
+class LocalPairingCodeDialogMici(BigDialogBase):
+
+  def __init__(self):
+    super().__init__()
+    self._apps_before = len(get_local_apps())
+    arm_pairing()
+    self.set_back_callback(clear_pairing_request)
+
+    header_color = rl.Color(255, 255, 255, int(255 * 0.9))
+    subheader_color = rl.Color(255, 255, 255, int(255 * 0.9 * 0.65))
+    self._title = UnifiedLabel(tr("pair with mobile app"), font_size=48, font_weight=FontWeight.BOLD,
+                               text_color=header_color, line_height=0.8)
+    self._code_label = UnifiedLabel("", font_size=110, font_weight=FontWeight.DISPLAY,
+                                    text_color=rl.Color(0, 255, 0, 255))
+    self._hint = UnifiedLabel(tr("enter this code in the sunnylink app"), font_size=32,
+                              text_color=subheader_color, line_height=0.9)
+    self._status = UnifiedLabel("", font_size=28,
+                                text_color=rl.Color(255, 255, 255, int(255 * 0.45)), line_height=0.9)
+
+  def _update_state(self):
+    super()._update_state()
+    if self.is_dismissing:
+      return
+    if len(get_local_apps()) > self._apps_before:
+      self.dismiss()  # paired — window already cleared
+    elif not pairing_requested():
+      self.dismiss()  # window expired
+
+  def _render(self, _):
+    self._code_label.set_text(read_pairing_code() or "—")
+
+    discovered = latest_discovered_app()
+    if discovered is not None:
+      endpoint, age = discovered
+      self._status.set_text(endpoint if age < 2 else f"{endpoint} ({age}s)")
+      self._status.set_text_color(rl.Color(0, 255, 0, 255))
+    else:
+      self._status.set_text(tr("waiting for the app…"))
+      self._status.set_text_color(rl.Color(255, 255, 255, int(255 * 0.45)))
+
+    x = self._rect.x + 20
+    width = int(self._rect.width - 40)
+    self._title.set_max_width(width)
+    self._title.set_position(x, self._rect.y + 40)
+    self._title.render()
+
+    self._code_label.set_max_width(width)
+    self._code_label.set_position(x, self._rect.y + 130)
+    self._code_label.render()
+
+    self._hint.set_max_width(width)
+    self._hint.set_position(x, self._rect.y + 290)
+    self._hint.render()
+
+    self._status.set_max_width(width)
+    self._status.set_position(x, self._rect.y + 360)
+    self._status.render()

openpilot/selfdrive/ui/sunnypilot/model_info.py

@@ -4,28 +4,12 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
-import contextlib
-import os
-import time
-
-from openpilot.common.hardware.hw import Paths
 from openpilot.selfdrive.ui.ui_state import ui_state, ChestnutState
 from openpilot.sunnypilot.models.fetcher import get_cached_bundles
 from openpilot.sunnypilot.models.helpers import get_active_source, get_selected_bundle, resolve_bundle_by_ref
 from openpilot.sunnypilot.models.model_name import DEFAULT_BIG_MODEL, DEFAULT_MODEL
 
 
-def model_cache_size_mb() -> float:
-  """Bytes on disk under the model cache directory, in MB."""
-  model_root = Paths.model_root()
-  total = 0
-  if os.path.isdir(model_root):
-    for name in os.listdir(model_root):
-      with contextlib.suppress(OSError):
-        total += os.path.getsize(os.path.join(model_root, name))
-  return total / (1024 ** 2)
-
-
 def active_source() -> str:
   return get_active_source(chestnut=ui_state.chestnut_present,
                            chestnut_active=ui_state.chestnut_active, chestnut_loading=ui_state.chestnut_loading,
@@ -99,22 +83,3 @@ def model_info() -> tuple[str, str, str]:
   active_name = active_bundle.displayName if active_bundle else default_model_name(source)
   other_name = other_bundle.displayName if other_bundle else default_model_name(other)
   return source, active_name, other_name
-
-
-# mirrors the manager's ModelCache keys; the manager restamps them on a successful fetch
-MODEL_SYNC_KEYS = ("ModelManager_LastSyncTime", "ModelManager_LastSyncTime_Chestnut")
-MODEL_SYNC_TIMEOUT = 20.0
-
-
-def refresh_model_list() -> None:
-  # zeroing the sync keys makes the manager refetch each manifest on its next tick
-  for key in MODEL_SYNC_KEYS:
-    ui_state.params.put(key, 0)
-
-
-def refresh_in_progress(started_at: float | None) -> bool:
-  """Whether a user refresh is still outstanding. A failed fetch never restamps the
-  sync keys, so the spinner is bounded by MODEL_SYNC_TIMEOUT rather than sticking."""
-  if started_at is None or time.monotonic() - started_at > MODEL_SYNC_TIMEOUT:
-    return False
-  return not all(ui_state.params.get(key) for key in MODEL_SYNC_KEYS)

openpilot/selfdrive/ui/translations/auto_translate.sh

@@ -4,7 +4,7 @@ set -euo pipefail
 DIR="$(cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd)"
 ROOT="$DIR/../../../"
 
-cd "$DIR"
+cd $DIR
 ./update_translations.py
 
 command -v codex >/dev/null || {

openpilot/sunnypilot/mapd/mapd_installer.py

@@ -20,6 +20,7 @@ from openpilot.common.hardware.hw import Paths
 from openpilot.common.spinner import Spinner
 from openpilot.common.version import is_prebuilt
 from openpilot.sunnypilot.mapd import MAPD_PATH, MAPD_BIN_DIR
+import openpilot.system.sentry as sentry
 
 VERSION = "v1.12.0"
 URL = f"https://github.com/pfeiferj/openpilot-mapd/releases/download/{VERSION}/mapd"
@@ -135,7 +136,9 @@ class MapdInstallManager:
                              f"Boot will continue in {5 - i}s...")
         time.sleep(1)
 
+      sentry.init(sentry.SentryProject.SELFDRIVE)
       traceback.print_exc()
+      sentry.capture_exception()
 
 
 if __name__ == "__main__":

openpilot/sunnypilot/modeld_v2/camera_offset_helper.py

@@ -15,19 +15,11 @@ class CameraOffsetHelper:
     self.actual_camera_offset = 0.0
 
   @staticmethod
-  def get_v_horizon(intrinsics, rpy_calib):
+  def apply_camera_offset(model_transform, intrinsics, height, offset_param):
     cy = intrinsics[1, 2]
-    if len(rpy_calib) == 3 and np.isfinite(rpy_calib).all():
-      fy = intrinsics[1, 1]
-      pitch = rpy_calib[1]
-      return float(cy - fy * np.tan(pitch))
-    return float(cy)
-
-  @staticmethod
-  def apply_camera_offset(model_transform, height, offset_param, v_horizon):
     shear = np.eye(3, dtype=np.float32)
     shear[0, 1] = offset_param / height
-    shear[0, 2] = -offset_param / height * v_horizon
+    shear[0, 2] = -offset_param / height * cy
     model_transform = (shear @ model_transform).astype(np.float32)
     return model_transform
 
@@ -38,13 +30,10 @@ class CameraOffsetHelper:
     self.actual_camera_offset = (0.9 * self.actual_camera_offset) + (0.1 * self.camera_offset)
     dc = DEVICE_CAMERAS[(str(sm['deviceState'].deviceType), str(sm['narrowRoadCameraState'].sensor))]
     height = sm["extrinsicsCalibration"].height[0] if sm['extrinsicsCalibration'].height else 1.22
-    rpy_calib = sm['extrinsicsCalibration'].rpyCalib
 
     intrinsics_main = dc.wide_road.intrinsics if main_wide_camera else dc.narrow_road.intrinsics
-    v_horizon_main = self.get_v_horizon(intrinsics_main, rpy_calib)
-    model_transform_main = self.apply_camera_offset(model_transform_main, height, self.actual_camera_offset, v_horizon_main)
+    model_transform_main = self.apply_camera_offset(model_transform_main, intrinsics_main, height, self.actual_camera_offset)
 
     intrinsics_extra = dc.wide_road.intrinsics
-    v_horizon_extra = self.get_v_horizon(intrinsics_extra, rpy_calib)
-    model_transform_extra = self.apply_camera_offset(model_transform_extra, height, self.actual_camera_offset, v_horizon_extra)
+    model_transform_extra = self.apply_camera_offset(model_transform_extra, intrinsics_extra, height, self.actual_camera_offset)
     return model_transform_main, model_transform_extra

openpilot/sunnypilot/modeld_v2/compile_modeld.py

@@ -7,84 +7,41 @@ See the LICENSE.md file in the root directory for more details.
 """
 
 import argparse
-import codecs
-import gc
 import math
-import multiprocessing as mp
 import os
-import pickle
 import tempfile
 import time
 from functools import partial
-from typing import Any
-
+from openpilot.selfdrive.modeld.helpers import dump_oob, load_oob
 import numpy as np
+os.environ['GMMU'] = '0'
 
-from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, patch_fetch_fw, read_parts, write_bundle
-from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame, record_kernel_linear, serialize_jit
-import openpilot.sunnypilot.modeld_v2.stock_dependencies as stock
-from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+def _patch_tinygrad_fetch_fw():
+  import hashlib
+  import pathlib
+  import zstandard
+  from tinygrad import helpers
+  _orig_fetch_fw = helpers.fetch_fw
+  def fetch_fw(path, name, sha256):
+    p = pathlib.Path(f"/lib/firmware/{path}/{name}.zst")
+    if p.is_file():
+      blob = zstandard.ZstdDecompressor().stream_reader(p.read_bytes()).read()
+      if hashlib.sha256(blob).hexdigest() == sha256:
+        return blob
+    return _orig_fetch_fw(path, name, sha256)
+  helpers.fetch_fw = fetch_fw
+_patch_tinygrad_fetch_fw()
 
+import openpilot.selfdrive.modeld.compile_modeld as stock
 from tinygrad import dtypes
 from tinygrad.device import Device
 from tinygrad.engine.jit import TinyJit
-from tinygrad.helpers import Context
-from tinygrad.nn.onnx import OnnxRunner, OnnxPBParser
 from tinygrad.tensor import Tensor
 
-os.environ['GMMU'] = '0'
-
-patch_fetch_fw()
-
 MODEL_TYPES = ('vision_policy', 'supercombo', 'vision_multi_policy')
 WARP_INPUTS = ['tfm', 'big_tfm']
 POLICY_INPUTS = ['img_q', 'big_img_q', 'feat_q', 'desire_q', 'packed_npy_inputs']
-
-class MetadataOnnxPBParser(OnnxPBParser):
-  def _parse_ModelProto(self) -> dict:
-    obj: dict[str, Any] = {"graph": {"input": [], "output": []}, "metadata_props": []}
-    self.opset_imports = {}
-    for fid, wire_type in self._parse_message(self.reader.len):
-      match fid:
-        case 7:
-          obj["graph"] = self._parse_GraphProto()
-        case 14:
-          obj["metadata_props"].append(self._parse_StringStringEntryProto())
-        case _:
-          self.reader.skip_field(wire_type)
-    return obj
-
-def get_name_and_shape(value_info: dict[str, Any]) -> tuple[str, tuple[int, ...]]:
-  shape = tuple(int(dim) if isinstance(dim, int) else 0 for dim in value_info["parsed_type"].shape)
-  name = value_info["name"]
-  return name, shape
-
-def get_metadata_value_by_name(model: dict[str, Any], name: str) -> str | Any:
-  for prop in model["metadata_props"]:
-    if prop["key"] == name:
-      return prop["value"]
-  return None
-
-def make_metadata_dict(model_path):
-  with Context(DEV='CPU'):
-    model = MetadataOnnxPBParser(model_path).parse()
-    output_slices_raw = get_metadata_value_by_name(model, 'output_slices')
-    assert output_slices_raw is not None, 'output_slices not found in metadata'
-
-    output_slices = pickle.loads(codecs.decode(output_slices_raw.encode(), "base64"))
-    if 'hidden_state' not in output_slices:
-      output_slices['hidden_state'] = slice(0, 512)
-
-    meta_dict = {
-      'model_checkpoint': get_metadata_value_by_name(model, 'model_checkpoint'),
-      'output_slices': output_slices,
-      'input_shapes': dict(get_name_and_shape(x) for x in model["graph"]["input"]),
-      'output_shapes': dict(get_name_and_shape(x) for x in model["graph"]["output"]),
-    }
-    del model
-    gc.collect()
-    return meta_dict
-
+nv12_copy_size = stock.nv12_copy_size
 
 def _detect_desire_key(shapes: dict) -> str | None:
   return next((key for key in shapes if key.startswith('desire')), None)
@@ -122,10 +79,6 @@ def get_policy_npy_shapes(input_shapes: dict, is_supercombo: bool = False) -> tu
   return shapes, sizes
 
 
-def host_view(tensor: Tensor) -> np.ndarray: # QCOM -> CPU round trip of tfm takes 5ms longer than host memory view
-  return np.frombuffer(tensor._buffer()._host_mv(), dtype=np.float32).reshape(tensor.shape)
-
-
 def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = Device.DEFAULT,
                             is_supercombo: bool = False) -> tuple[dict, dict]:
   road_key, _ = _detect_vision_keys(input_shapes)
@@ -161,7 +114,7 @@ def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = D
     'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
     'desire_q': Tensor(np.zeros((frame_skip * desire_shape[1], desire_shape[0], desire_shape[2]),
                   dtype=np.float32), device=device).contiguous().realize(),
-    'packed_npy_inputs': Tensor(packed_npy_inputs, device=device).realize(),
+    'packed_npy_inputs': Tensor(packed_npy_inputs, device='NPY').realize(),
   }
 
   if features_buffer:
@@ -170,14 +123,9 @@ def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = D
     queues['feat_q'] = Tensor(np.zeros((feat_q_len, features_buffer[0], feat_dim),
                        dtype=np.float32), device=device).contiguous().realize()
 
-  for key in ('tfm', 'big_tfm'):
-    if key not in npy_arrays:
-      npy_arrays[key] = np.eye(3, dtype=np.float32)
-    queues[key] = Tensor(npy_arrays[key], device=device).realize()
+  queues.update({key: Tensor(value, device='NPY').realize() for key, value in npy_arrays.items() if key in ('tfm', 'big_tfm')})
 
-  packed = host_view(queues['packed_npy_inputs'])
-  npy_arrays |= {k: v.reshape(s) for (k, s), v in zip(shapes.items(), np.split(packed, split_indices) if sizes else [], strict=True)}
-  return queues, npy_arrays | {k: host_view(queues[k]) for k in ('tfm', 'big_tfm')}
+  return queues, npy_arrays
 
 
 def make_split_input_queues(vision_input_shapes: dict, policy_input_shapes: dict,
@@ -199,8 +147,8 @@ def make_warp_queues(device=Device.DEFAULT):
     'tfm': np.zeros((3, 3), dtype=np.float32),
     'big_tfm': np.zeros((3, 3), dtype=np.float32),
   }
-  queues = {k: Tensor(v, device=device).realize() for k, v in npy.items()}
-  return queues, {k: host_view(v) for k, v in queues.items()}
+  queues = {k: Tensor(v, device='NPY').realize() for k, v in npy.items()}
+  return queues, npy
 
 
 def make_run_policy(vision_runner, policy_runners: list, features_slice: slice, frame_skip: int, input_shapes: dict):
@@ -216,7 +164,8 @@ def make_run_policy(vision_runner, policy_runners: list, features_slice: slice,
   is_supercombo = vision_runner is None
   npy_shapes, npy_sizes = get_policy_npy_shapes(input_shapes, is_supercombo=is_supercombo)
 
-  def run_policy(warped, img_q, big_img_q, feat_q, desire_q=None, packed_npy_inputs=None, **kwargs):
+  def run_policy(warped, img_q, big_img_q, feat_q, packed_npy_inputs, **kwargs):
+    desire_q = kwargs['desire_q']
     packed_npy_inputs_dev = packed_npy_inputs.to(Device.DEFAULT)
     warped_dev = warped.to(Device.DEFAULT)
     Tensor.realize(packed_npy_inputs_dev, warped_dev)
@@ -260,86 +209,51 @@ def make_run_policy(vision_runner, policy_runners: list, features_slice: slice,
   return run_policy
 
 
-class _CheckFrameRecorder:
-  def __init__(self, jit):
-    self.jit, self.frame = jit, None
+def compile_jit(jit, input_keys, make_queues, make_random_inputs=None, benchmark_runs: int = 1):
+  SEED = 42
+  def random_inputs_run(fn, seed, n_runs, test_val=None, test_buffers=None, expect_match=True):
+    queues_res = make_queues(Device.DEFAULT)
+    input_queues, npy = queues_res[0], queues_res[1]
+    frame_views = queues_res[2] if len(queues_res) > 2 else {}
+    rng = np.random.default_rng(seed)
+    Tensor.manual_seed(seed)
 
-  def __call__(self, *args, **kwargs):
-    if self.frame is not None or args or self.jit.cnt < 2:
-      return self.jit(*args, **kwargs)
-    self.frame, result = capture_frame(self.jit, kwargs, None)
-    return result
+    for i in range(n_runs):
+      for v in npy.values():
+        v[:] = rng.standard_normal(v.shape).astype(v.dtype)
+      for v in frame_views.values():
+        v[:] = rng.integers(0, 256, size=v.shape, dtype=np.uint8)
+      Device.default.synchronize()
+      random_inputs = make_random_inputs(rng=rng) if make_random_inputs is not None else {}
+      st = time.perf_counter()
+      outs = fn(**{k: input_queues[k] for k in input_keys if k in input_queues}, **random_inputs)
+      mt = time.perf_counter()
+      Device.default.synchronize()
+      et = time.perf_counter()
+      print(f"  [{i+1}/{n_runs}] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")
 
+      if i == 0:
+        val = [np.copy(v.numpy()) for v in (outs if isinstance(outs, tuple) else [outs])] if outs is not None else []
+        buffers = [np.copy(v.numpy().copy()) for v in input_queues.values()]
 
-def compile_jit(jit_or_fn, input_keys_or_make_inputs, make_queues=None, make_random_inputs=None,
-                benchmark_runs: int = 1, clear_refs=None):
-  if callable(input_keys_or_make_inputs) and make_queues is None:
-    fn = jit_or_fn
-    make_inputs = input_keys_or_make_inputs
-    jit = TinyJit(fn, prune=True)
-
-    def run_eval(f, seed, count):
-      args, kwargs = make_inputs(seed)
-      result = None
-      for i in range(count):
-        Device.default.synchronize()
-        st = time.perf_counter()
-        f(*args, **kwargs)
-        Device.default.synchronize()
-        print(f"  [{i+1}/{count}] {(time.perf_counter()-st)*1e3:.2f} ms")
-        if i == 0:
-          result = [t.numpy().copy() for t in kwargs['output_buffers'].values()]
-      return result
-  else:
-    jit = jit_or_fn
-    input_keys = input_keys_or_make_inputs
-    assert make_queues is not None
-    queues_maker = make_queues
-
-    def run_eval(f, seed, count):
-      queues_res = queues_maker(Device.DEFAULT)
-      input_queues, npy = queues_res[0], queues_res[1]
-      frame_views = queues_res[2] if len(queues_res) > 2 else {}
-      rng = np.random.default_rng(seed)
-      Tensor.manual_seed(seed)
-
-      for i in range(count):
-        for v in npy.values():
-          v[:] = rng.standard_normal(v.shape).astype(v.dtype)
-        for v in frame_views.values():
-          v[:] = rng.integers(0, 256, size=v.shape, dtype=np.uint8)
-        Device.default.synchronize()
-        random_inputs = make_random_inputs() if make_random_inputs is not None else {}
-        st = time.perf_counter()
-        outs = f(**{k: input_queues[k] for k in input_keys if k in input_queues}, **random_inputs)
-        mt = time.perf_counter()
-        Device.default.synchronize()
-        et = time.perf_counter()
-        print(f"  [{i+1}/{count}] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")
-
-        if i == 0:
-          val = [np.copy(v.numpy()) for v in (outs if isinstance(outs, tuple) else [outs])] if outs is not None else []
-      return val
+    if test_val is not None:
+      match = all(np.array_equal(a, b) for a, b in zip(val, test_val, strict=True))
+      assert match == expect_match, f"outputs {'differ from' if expect_match else 'match'} baseline (seed={seed})"
+    if test_buffers is not None:
+      match = all(np.array_equal(a, b) for a, b in zip(buffers, test_buffers, strict=True))
+      assert match == expect_match, f"buffers {'differ from' if expect_match else 'match'} baseline (seed={seed})"
+    return val, buffers
 
   print('capture + replay')
-  gc.collect()
-  recorder = _CheckFrameRecorder(jit)
-  with record_kernel_linear() as recorded:
-    test_val = run_eval(recorder, 42, 3)
-  assert len(recorded) == 1, f"expected one captured kernel list, got {len(recorded)}"
-  part = serialize_jit(jit, recorded[0], recorder.frame)
-  print(f'plain artifact round trip ({benchmark_runs} runs per seed)')
-  if clear_refs:
-    clear_refs()
-  gc.collect()
-  loaded_jit = PlainJit(part[0], memoryview(part[1]))
-
-  for seed in (42, 43):
-    reference = test_val if seed == 42 else run_eval(jit_or_fn, seed, 1)
-    actual = run_eval(loaded_jit, seed, benchmark_runs)
-    for ref, val in zip(reference, actual, strict=True):
-      np.testing.assert_array_equal(ref, val)
-  return part
+  test_val, test_buffers = random_inputs_run(jit, SEED, 3)
+  print(f'pickle round trip ({benchmark_runs} runs per seed)')
+  with tempfile.TemporaryFile(dir=".") as f:
+    dump_oob(jit, f)
+    f.seek(0)
+    loaded_jit = load_oob(f)
+  random_inputs_run(loaded_jit, SEED, benchmark_runs, test_val, test_buffers, expect_match=True)
+  random_inputs_run(loaded_jit, SEED+1, benchmark_runs, test_val, test_buffers, expect_match=False)
+  return jit
 
 
 def _parse_size(size_str: str) -> tuple[int, int]:
@@ -347,6 +261,19 @@ def _parse_size(size_str: str) -> tuple[int, int]:
   return int(width), int(height)
 
 
+def read_file_chunked_to_disk(path):
+  if not path:
+    return None
+  import atexit
+  import shutil
+  from openpilot.common.file_chunker import open_file_chunked
+  tmp_path = f'{path}.unchunked'
+  with open(tmp_path, 'wb') as f, open_file_chunked(path) as src:
+    shutil.copyfileobj(src, f)
+  atexit.register(lambda: os.path.exists(tmp_path) and os.remove(tmp_path))
+  return tmp_path
+
+
 def _load_policy_runners(args: argparse.Namespace) -> tuple[list, list]:
   runners, keys = [], []
   for name, onnx_arg in [('policy', args.policy_onnx), ('off_policy', args.off_policy_onnx), ('on_policy', args.on_policy_onnx)]:
@@ -356,20 +283,6 @@ def _load_policy_runners(args: argparse.Namespace) -> tuple[list, list]:
   return runners, keys
 
 
-def _compile_warp_resolution_worker(cam_w, cam_h, model_w, model_h, benchmark_runs, result_path):
-  nv12 = stock.NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
-  WARP_DEV = os.getenv('WARP_DEV', Device.DEFAULT)
-  make_random_warp_inputs = partial(make_random_images, keys=['frame', 'big_frame'], shape=nv12.size, device=WARP_DEV)
-  warp = TinyJit(stock.make_warp(nv12, model_w, model_h), prune=True)
-
-  def cleanup_warp():
-    nonlocal warp
-    warp = None
-  compiled_jit = compile_jit(warp, WARP_INPUTS, make_warp_queues, make_random_inputs=make_random_warp_inputs,
-                            benchmark_runs=benchmark_runs, clear_refs=cleanup_warp)
-  write_bundle(result_path, {(cam_w, cam_h): compiled_jit}, {'device': Device.DEFAULT})
-
-
 if __name__ == "__main__":
   if 'USB' in os.getenv('DEV', '') or os.getenv('CHESTNUT'):
     from openpilot.system.hardware.chestnut.flash import link_up
@@ -380,6 +293,11 @@ if __name__ == "__main__":
     else:
       raise RuntimeError("Chestnut not ready, skipping big model build")
 
+  from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+  from openpilot.selfdrive.modeld.get_model_metadata import make_metadata_dict
+  from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+  from tinygrad.nn.onnx import OnnxRunner
+
   parser = argparse.ArgumentParser(description="Compile combined JIT pkl for sunnypilot modeld_v2")
   parser.add_argument('--model-type', choices=MODEL_TYPES, required=True)
   parser.add_argument('--model-size', type=_parse_size, required=True, help='model input WxH')
@@ -398,47 +316,36 @@ if __name__ == "__main__":
   model_w, model_h = args.model_size
   output_data = {}
 
-  is_unified_supercombo = False
+  args.vision_onnx = read_file_chunked_to_disk(args.vision_onnx)
+  args.policy_onnx = read_file_chunked_to_disk(args.policy_onnx)
+  args.off_policy_onnx = read_file_chunked_to_disk(args.off_policy_onnx)
+  args.on_policy_onnx = read_file_chunked_to_disk(args.on_policy_onnx)
+  args.supercombo_onnx = read_file_chunked_to_disk(args.supercombo_onnx)
+
   if args.model_type == 'supercombo':
     assert args.supercombo_onnx
     model_metadata = make_metadata_dict(args.supercombo_onnx)
-    derived_frame_skip = args.frame_skip or derive_frame_skip({}, model_metadata['input_shapes'])
-    if derived_frame_skip != 1 and os.getenv('CHESTNUT'):
-      is_unified_supercombo = True
-
-  if is_unified_supercombo:
     output_data['metadata'] = {'model': model_metadata, **model_metadata}
     output_data['input_devices'] = {'model': Device.DEFAULT}
+    output_data['run_model'] = {}
+    derived_frame_skip = args.frame_skip or derive_frame_skip({}, model_metadata['input_shapes'])
     model_runner = OnnxRunner(args.supercombo_onnx)
-    features_slice = model_metadata['output_slices']['hidden_state']
-    run_policy = make_run_policy(None, [model_runner], features_slice, derived_frame_skip, model_metadata['input_shapes'])
-    for cam_w, cam_h in set(args.camera_resolutions):
-      print(f"Compiling unified model JIT for {cam_w}x{cam_h}")
+    run_policy = stock.make_run_policy(model_runner, model_metadata, derived_frame_skip)
+    for cam_w, cam_h in args.camera_resolutions:
+      print(f"Compiling unified run_model JIT for {cam_w}x{cam_h}...")
       nv12 = stock.NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
       frame_copy_size = stock.nv12_copy_size(nv12.stride, nv12.y_height, nv12.uv_height)
       make_model_queues = partial(stock.make_input_queues, model_metadata['input_shapes'], derived_frame_skip,
                                   frame_copy_size=frame_copy_size)
       warp = stock.make_warp(nv12, model_w, model_h)
       run_model_jit = TinyJit(stock.make_run_model(warp, run_policy, model_metadata, frame_copy_size), prune=True)
-      write_bundle(part_path := f"{args.output}.{cam_w}x{cam_h}", {(cam_w, cam_h): compile_jit(run_model_jit, stock.MODELD_INPUTS, make_model_queues,
-                                                                                               benchmark_runs=args.benchmark_runs)})
-      output_data[(cam_w, cam_h)] = read_parts(part_path)[0][(cam_w, cam_h)]
-      os.remove(part_path)
-      gc.collect()
-    del model_runner, run_policy
-    gc.collect()
-    output_data['metadata']['warp_dev'] = Device.DEFAULT
+      output_data['run_model'][(cam_w, cam_h)] = compile_jit(run_model_jit, stock.MODELD_INPUTS, make_model_queues, benchmark_runs=args.benchmark_runs)
   else:
     vision_runner = OnnxRunner(args.vision_onnx) if args.vision_onnx else None
-
     if args.model_type == 'vision_policy':
       assert vision_runner and args.policy_onnx
       policy_runners = [OnnxRunner(args.policy_onnx)]
       output_data['metadata'] = {'vision': make_metadata_dict(args.vision_onnx), 'policy': make_metadata_dict(args.policy_onnx)}
-    elif args.model_type == 'supercombo':
-      assert args.supercombo_onnx
-      policy_runners = [OnnxRunner(args.supercombo_onnx)]
-      output_data['metadata'] = {'model': make_metadata_dict(args.supercombo_onnx)}
     elif args.model_type == 'vision_multi_policy':
       assert vision_runner
       policy_runners, policy_names = _load_policy_runners(args)
@@ -452,51 +359,33 @@ if __name__ == "__main__":
     vision_meta = output_data['metadata'].get('vision', {})
 
     derived_frame_skip = args.frame_skip or derive_frame_skip(vision_meta.get('input_shapes', {}), first_policy_meta.get('input_shapes', {}))
-    all_shapes = {
-      key: value for meta in output_data['metadata'].values()
-      if isinstance(meta, dict) and 'input_shapes' in meta for key, value in meta['input_shapes'].items()
-    }
-    feat_meta = output_data['metadata'].get('vision') or output_data['metadata'].get('model') or output_data['metadata'].get('policy')
-    assert isinstance(feat_meta, dict)
+    all_shapes = {key: value for meta in output_data['metadata'].values() for key, value in meta['input_shapes'].items()}
+    feat_meta = output_data['metadata'].get('vision') or output_data['metadata'].get('policy')
+    assert feat_meta is not None
     features_slice = feat_meta['output_slices']['hidden_state']
-    is_supercombo = vision_runner is None
 
     print(f"Compiling run_policy JIT (model_size={model_w}x{model_h}, frame_skip={derived_frame_skip})...")
     run_policy_func = make_run_policy(vision_runner, policy_runners, features_slice, derived_frame_skip, all_shapes)
     run_policy_jit = TinyJit(run_policy_func, prune=True)
-    make_policy_queues = partial(generate_queues_and_npy, all_shapes, derived_frame_skip, is_supercombo=is_supercombo)
-    WARP_DEV = os.getenv('WARP_DEV', Device.DEFAULT)
-    make_random_model_inputs = partial(make_random_images, keys=['warped'], shape=(2, 6, model_h // 2, model_w // 2), device=WARP_DEV)
+    make_policy_queues = partial(generate_queues_and_npy, all_shapes, derived_frame_skip, is_supercombo=False)
+    make_random_model_inputs = partial(make_random_images, keys=['warped'], shape=(2, 6, model_h // 2, model_w // 2), device=Device.DEFAULT)
+    output_data['run_policy'] = compile_jit(run_policy_jit, POLICY_INPUTS, make_policy_queues, make_random_inputs=make_random_model_inputs)
 
-    def cleanup_policy():
-      global run_policy_jit, run_policy_func, vision_runner, policy_runners
-      run_policy_jit, run_policy_func, vision_runner, policy_runners = None, None, None, None
+    for cam_w, cam_h in args.camera_resolutions:
+      print(f"Compiling warp JIT for {cam_w}x{cam_h}...")
+      nv12 = stock.NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
+      frame_copy_size = stock.nv12_copy_size(nv12.stride, nv12.y_height, nv12.uv_height)
+      make_random_warp_inputs = partial(make_random_images, keys=['frame', 'big_frame'], shape=frame_copy_size, device=Device.DEFAULT)
+      warp = TinyJit(stock.make_warp(nv12, model_w, model_h), prune=True)
+      output_data[(cam_w, cam_h)] = compile_jit(warp, WARP_INPUTS, make_warp_queues, make_random_inputs=make_random_warp_inputs)
 
-    output_data['run_policy'] = compile_jit(run_policy_jit, POLICY_INPUTS, make_policy_queues,
-                                            make_random_inputs=make_random_model_inputs, benchmark_runs=args.benchmark_runs, clear_refs=cleanup_policy)
-
-    ctx = mp.get_context('spawn')
-    output_data['input_devices'] = {}
-    tmp_files = []
-    for cam_w, cam_h in set(args.camera_resolutions):
-      print(f"Compiling warp JIT for {cam_w}x{cam_h}")
-      tmp_res = tempfile.NamedTemporaryFile(delete=False, suffix=".pkl", dir=".")
-      tmp_res.close()
-
-      p = ctx.Process(target=_compile_warp_resolution_worker, args=(cam_w, cam_h, model_w, model_h, args.benchmark_runs, tmp_res.name))
-      p.start()
-      p.join()
-      if p.exitcode != 0:
-        raise RuntimeError(f"Warp compilation worker failed for {cam_w}x{cam_h}")
-
-      tmp_files.append((cam_w, cam_h, tmp_res.name))
-    for cam_w, cam_h, tmp_name in tmp_files:
-      warp_parts, warp_extras = read_parts(tmp_name)
-      output_data[(cam_w, cam_h)] = warp_parts[(cam_w, cam_h)]
-      output_data['input_devices']['warp'] = warp_extras['device']
-      os.remove(tmp_name)
     output_data['metadata']['warp_dev'] = Device.DEFAULT
 
-  parts = {key: output_data.pop(key) for key in [key for key, value in output_data.items() if isinstance(value, tuple)]}
-  write_bundle(args.output, parts, output_data)
-  print(f"Saved model to {args.output} ({os.path.getsize(args.output) / 1e6:.2f} MB, {len(parts)} JITs)")
+  with open(args.output, "wb") as file:
+    dump_oob(output_data, file)
+
+  pkl_size = os.path.getsize(args.output)
+  print(f"Saved combined JIT to {args.output} ({pkl_size / 1e6:.2f} MB)")
+  chunk_targets = get_chunk_targets(args.output, pkl_size)
+  chunk_file(args.output, chunk_targets)
+  print(f"Chunked into {len(chunk_targets) - 1} file(s)")

openpilot/sunnypilot/modeld_v2/compile_modeld_v2.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import os
-import sys
-
-import numpy as np
-
-from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, write_bundle
-from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame, record_kernel_linear, serialize_jit
-
-
-def initialize_check_inputs(arrays: dict):
-  rng = np.random.default_rng(7)
-  for value in arrays.values():
-    value[...] = rng.standard_normal(value.shape) if value.dtype.kind == "f" else rng.integers(0, 2 if value.dtype == np.bool_ else 16, value.shape)
-
-
-if __name__ == "__main__":
-  sys.path.insert(0, os.environ.get("TINYGRAD_PATH", "tinygrad_repo"))
-  from examples.openpilot.compile_onnx import onnx_metadata
-  from examples.openpilot.helpers import allocate_inputs, benchmark
-  from tinygrad import Device, Tensor, TinyJit
-  from tinygrad.dtype import _to_np_dtype
-  from tinygrad.nn.onnx import OnnxRunner
-
-  parser = argparse.ArgumentParser(description="Compile a native-architecture ONNX model into a plain tinygrad artifact")
-  parser.add_argument('onnx')
-  parser.add_argument('output')
-  parser.add_argument('--device-input', action='append', default=[])
-  parser.add_argument('--benchmark-runs', type=int, default=20)
-  args = parser.parse_args()
-
-  runner, (properties, output_shapes) = OnnxRunner(args.onnx), onnx_metadata(args.onnx)
-  device_inputs = runner.graph_inputs.keys() if '*' in args.device_input else args.device_input
-  metadata = {'metadata': properties} | {f'{kind}_shapes': {name: tuple(d if isinstance(d, int) else 0 for d in shape) for name, shape in shapes.items()}
-                                         for kind, shapes in [('input', {name: spec.shape for name, spec in runner.graph_inputs.items()}),
-                                                              ('output', output_shapes)]}
-  input_specs = {name: (tuple(s if isinstance(s, int) else 1 for s in spec.shape), np.dtype(_to_np_dtype(spec.dtype)).str,
-                        Device.DEFAULT if name in device_inputs else 'NPY') for name, spec in runner.graph_inputs.items()}
-
-  def model(inputs):
-    return {name: value.contiguous() for name, value in runner({name: value.to(Device.DEFAULT) for name, value in inputs.items()}).items()}
-  output_specs = {name: (value.shape, np.dtype(_to_np_dtype(value.dtype)).name, Device.DEFAULT) for name, value in model(allocate_inputs(input_specs)).items()}
-
-  @TinyJit(prune=True)
-  def jit(output_buffers, **inputs):
-    Tensor.realize(*(output_buffers[name].assign(value) for name, value in model(inputs).items()))
-
-  check_inputs = allocate_inputs(input_specs, initialize_check_inputs) | {'output_buffers': allocate_inputs(output_specs)}
-  with record_kernel_linear() as recorded:
-    for i in range(2 + args.benchmark_runs):
-      benchmark(jit, cb=lambda t, i=i: print(f"  [{i + 1}/{2 + args.benchmark_runs}] {t * 1e3:.2f} ms"), **check_inputs)
-  assert len(recorded) == 1, f"expected one captured kernel list, got {len(recorded)}"
-
-  frame, _ = capture_frame(jit, check_inputs, 'output_buffers')
-  part = serialize_jit(jit, recorded[0], frame)
-  PlainJit(part[0], memoryview(part[1]))
-  write_bundle(args.output, {'run': part}, {'metadata': metadata, 'input_specs': input_specs, 'output_specs': output_specs})
-  print(f"Saved model to {args.output} ({os.path.getsize(args.output) / 1e6:.2f} MB, {len(part[0]['calls'])} kernels)")

openpilot/sunnypilot/modeld_v2/compile_warp.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import argparse
-import numpy as np
-
-from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, write_bundle
-from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame, record_kernel_linear, serialize_jit
-
-
-def main():
-  parser = argparse.ArgumentParser(description="Compile the two-frame yuv420 camera warp into a plain tinygrad artifact")
-  parser.add_argument("--frame", required=True, help="width,height,stride,y_height,uv_height,buffer_size")
-  parser.add_argument("--warp-to", required=True, help="model input WxH")
-  parser.add_argument("--output", required=True)
-  args = parser.parse_args()
-
-  from examples.openpilot.compile_warp import make_frame_prepare, parse_frame, parse_size
-  from tinygrad import Device, Tensor, TinyJit
-  frame = parse_frame(args.frame)
-  warp = make_frame_prepare(frame, *parse_size(args.warp_to))
-  run = TinyJit(lambda input_frame, M_inv: Tensor.stack(*(warp(input_frame[i], M_inv[i]) for i in range(2))), prune=True)
-  rng = np.random.default_rng(42)
-  inputs = {"input_frame": Tensor(rng.integers(0, 256, (2, frame.size), dtype=np.uint8), device=Device.DEFAULT).realize(),
-            "M_inv": Tensor((rng.standard_normal((2, 3, 3)) * 8).astype(np.float32), device=Device.DEFAULT).realize()}
-  with record_kernel_linear() as recorded:
-    run(**inputs)
-    run(**inputs)
-    check, _ = capture_frame(run, inputs)
-  assert len(recorded) == 1, f"expected one captured kernel list, got {len(recorded)}"
-  part = serialize_jit(run, recorded[0], check)
-  PlainJit(*part)
-  specs = {"input_frame": ((2, frame.size), "|u1", Device.DEFAULT), "M_inv": ((2, 3, 3), "<f4", Device.DEFAULT)}
-  write_bundle(args.output, {"run": part}, {"input_specs": specs, "metadata": {}})
-  print(f"Saved warp to {args.output} ({len(part[0]['calls'])} kernels)")
-
-
-if __name__ == "__main__":
-  main()

openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py

@@ -1,214 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import argparse
-import dataclasses
-import itertools
-import mmap
-import re
-import struct
-import tempfile
-import numpy as np
-
-from openpilot.sunnypilot.modeld_v2.helpers import ALIGNMENT, Blob, PlainJit, flatten, patch_fetch_fw, write_bundle
-from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame
-
-
-def _root(u):
-  from tinygrad.uop.ops import Ops
-  while u.op in (Ops.AFTER, Ops.BITCAST, Ops.SHRINK, Ops.INDEX):
-    u = u.src[0]
-  return u
-
-
-def _view(u) -> tuple[int, int | None]:
-  from tinygrad.uop.ops import Ops
-  start, size = 0, None
-  while u.op in (Ops.AFTER, Ops.BITCAST, Ops.SHRINK):
-    if u.op is Ops.SHRINK:
-      start, size = start + u.src[1].arg, u.src[2].arg if size is None else size
-    u = u.src[0]
-  return start, size
-
-
-def _address(v):
-  from tinygrad.uop.ops import Ops
-  add = 0
-  while v.op is not Ops.GETADDR:
-    add += v.src[1].arg if v.op is Ops.ADD else 0
-    v = v.src[0]
-  start, size = _view(v.src[0])
-  return _root(v.src[0]), add + start, size
-
-
-def _patched(buf, topo) -> tuple[bytearray, dict]:
-  from tinygrad.uop.ops import Ops
-  blob, rows = bytearray(buf.max_numel() * buf.dtype.itemsize), {}
-  for u in topo:
-    if u.op is not Ops.STORE or _root(u.src[0]) is not buf:
-      continue
-    if (value := u.src[1]).op is Ops.BINARY or value.src[0].op is Ops.BINARY:
-      data = (value if value.op is Ops.BINARY else value.src[0]).arg
-      blob[:len(data)] = data
-    else:
-      view, offsets = u.src[0].src
-      rows |= {_view(view)[0] + o.arg * view.dtype.itemsize: w for o, w in zip(offsets.src, value.src, strict=True)}
-  return blob, rows
-
-
-def _evaluate(u, env):
-  from tinygrad.uop.ops import GroupOp, Ops, exec_alu
-  if u.op in (Ops.AFTER, Ops.CAST, Ops.BITCAST):
-    return _evaluate(u.src[0], env)
-  if u.op is Ops.CONST:
-    return u.arg
-  if u.op in (Ops.PARAM, Ops.RANGE):
-    return env.get(u.arg.slot if u.op is Ops.PARAM else u)
-  if u.op is Ops.LOAD:
-    table, index = _root(u.src[0].src[0]), _evaluate(u.src[0].src[1], env)
-    return struct.unpack_from(u.dtype.fmt, table.arg, index * u.dtype.itemsize)[0] if table.op is Ops.BINARY and index is not None else None
-  if u.op in GroupOp.ALU and None not in (values := [_evaluate(x, env) for x in u.src]):
-    return exec_alu(u.op, u.dtype, values, False)
-  return None
-
-
-def _input_pokes(submit, kernargs) -> dict[int, tuple[int, int]]:
-  from tinygrad.uop.ops import Ops
-  outer = dict(enumerate(submit.src[1:]))
-  kernargs_params = {i for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]) is kernargs}
-  inputs = {i: _root(a.src[0]).arg.slot for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]).op is Ops.PARAM}
-  pokes = {}
-  for call in (u for u in submit.src[0].src[0].toposort() if u.op is Ops.CALL and len(u.src) > 3):
-    _, address, value, *_ = call.src[1:]
-    used = list({x.arg.slot for x in value.toposort() if x.op is Ops.PARAM} & inputs.keys())
-    if len(used) != 1 or not kernargs_params & {x.arg.slot for x in address.toposort() if x.op is Ops.PARAM}:
-      continue
-    ranges = list(dict.fromkeys(x for x in (*address.toposort(), *value.toposort()) if x.op is Ops.RANGE))
-    for trip in itertools.product(*[range(int(r.vmax) + 1) for r in ranges]):
-      env = dict.fromkeys(outer, 0) | dict(zip(ranges, trip, strict=True))
-      if (offset := _evaluate(address, env)) % 8 == 0:
-        pokes[offset] = (inputs[used[0]], _evaluate(value, env))
-  return pokes
-
-
-def _elf(image: bytes, rodata: int) -> bytes:
-  names, offset, data, headers = b"\0.text\0.rodata\0.shstrtab\0", 64, b"", []
-  for name, kind, address, content in [(0, 0, 0, b""), (1, 1, ALIGNMENT, image[:rodata]), (7, 1, ALIGNMENT + rodata, image[rodata:]), (15, 3, 0, names)]:
-    headers.append(struct.pack("<IIQQQQIIQQ", name, kind, 2 if kind == 1 else 0, address, offset, len(content), 0, 0, 1, 0))
-    data, offset = data + content, offset + len(content)
-  return b"\x7fELF\x02\x01\x01" + bytes(9) + struct.pack("<HHIQQQIHHHHHH", 1, 0xe0, 1, 0, 0, offset, 0, 64, 0, 0, 64, 4, 3) + data + b"".join(headers)
-
-
-def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
-  import tinygrad.runtime.autogen.am.pm4_nv as pm4
-  import tinygrad.runtime.autogen.amd_gpu as amd_gpu
-  from tinygrad.dtype import dtypes
-  from tinygrad.engine.jit import _prepare_jit_inputs
-  from tinygrad.helpers import unwrap
-  from tinygrad.uop.ops import Ops
-  submit = jit.captured._linear.src[0].without_after
-  kernels, topo = submit.arg.aux.kernels, list(jit.captured._linear.toposort(enter_calls=True))
-  allocs = {str(u.tag): u for u in topo if u.op is Ops.ALLOC and u.tag is not None}
-  (commands, patched), kernargs = _patched(allocs["cmdbuf_compute_0"], topo), allocs["kernargs_compute_0"]
-  argument_words, pokes = _patched(kernargs, topo)[1], _input_pokes(submit, kernargs)
-  sh = {name: getattr(amd_gpu, f"reg{name}") + amd_gpu.GC_BASE__INST0_SEG0 - pm4.PACKET3_SET_SH_REG_START
-        for name in ("COMPUTE_PGM_LO", "COMPUTE_USER_DATA_0", "COMPUTE_NUM_THREAD_X")} if hasattr(amd_gpu, "regCOMPUTE_PGM_LO") else \
-       {"COMPUTE_PGM_LO": 0x20c, "COMPUTE_USER_DATA_0": 0x240, "COMPUTE_NUM_THREAD_X": 0x207}
-
-  dispatches, registers, offset = [], {}, 0
-  while offset < len(commands):
-    word = lambda o: patched.get(o, struct.unpack_from("<I", commands, o)[0])  # noqa: E731
-    if not isinstance(header := word(offset), int) or header >> 30 != 3:
-      offset += 4
-      continue
-    count, opcode = ((header >> 16) & 0x3fff) + 1, (header >> 8) & 0xff
-    body = [word(offset + 4 + 4 * i) for i in range(count)]
-    if opcode == pm4.PACKET3_SET_SH_REG:
-      registers |= {body[0] + i: v for i, v in enumerate(body[1:])}
-    elif opcode == pm4.PACKET3_DISPATCH_DIRECT:
-      local = [registers[sh["COMPUTE_NUM_THREAD_X"] + i] for i in range(3)]
-      dispatches.append((registers[sh["COMPUTE_PGM_LO"]], registers[sh["COMPUTE_USER_DATA_0"]], local, body[:3]))
-    offset += 4 + 4 * count
-  assert len(dispatches) == len(kernels), f"decoded {len(dispatches)} dispatches, the JIT has {len(kernels)} kernels"
-
-  sink = tempfile.TemporaryFile(dir=".")
-  blob, buffers, programs = Blob(sink), {}, {}
-  u8 = repr(dtypes.uint8)
-
-  def store(array) -> dict:
-    array = np.ascontiguousarray(array)
-    return {"data": blob.add(array.tobytes()), "dtype": array.dtype.str, "shape": list(array.shape)}
-
-  calls, written, needs_init = [], set(), set()
-  for (program, arguments, local, grid), kernel in zip(dispatches, kernels, strict=True):
-    image_alloc, entry, _ = _address(program)
-    if image_alloc not in programs:
-      image = bytes(_patched(image_alloc, topo)[0])
-      rodata = next(r for r in range(0, len(image) - 24, 64) if r + struct.unpack_from("<q", image, r + 16)[0] == entry)
-      programs[image_alloc] = blob.add(_elf(image, rodata))
-    start, size = _view(arguments.src[0])
-    args = []
-    for slot in range(start, start + unwrap(size), 8):
-      if slot in pokes:
-        assert pokes[slot][1] == 0, "the plain format passes whole inputs, this kernel takes a view into one"
-        args.append({"input": pokes[slot][0]})
-      elif slot in argument_words:
-        base, at, nbytes = _address(argument_words[slot])
-        args.append({"buffer": buffers.setdefault(base, len(buffers)), "offset": at, "nbytes": nbytes or base.arg.buffer.nbytes, "dtype": u8})
-    outs, ins = kernel[6]
-    calls.append({"kind": "program", "name": re.sub(r"\x1b\[[0-9;]*m", "", kernel[1]), "lib": programs[image_alloc], "target": dataclasses.asdict(target),
-                  "signature": [[f"data{i}", i, u8, [a.get("nbytes", 1)]] for i, a in enumerate(args)], "global_size": grid, "local_size": local,
-                  "globals": list(range(len(args))), "outs": list(outs), "ins": list(ins), "args": args})
-    needs_init |= {args[i]["buffer"] for i in ins if "buffer" in args[i] and args[i]["buffer"] not in written}
-    written |= {args[i]["buffer"] for i in outs if "buffer" in args[i]}
-
-  names = list(jit.captured.expected_names)
-  inputs = [{"slot": slot, "name": names[slot] if slot < len(names) else None, "dtype": repr(u.dtype), "numel": int(u.max_numel()), "device": u.device}
-            for slot, u in enumerate(_prepare_jit_inputs((), kwargs)[0])]
-  header = {"input_names": names, "calls": calls, "returns": {"kind": "NoneType", "tensors": []}, "inputs": inputs,
-            "buffers": [{"nbytes": b.arg.buffer.nbytes, "device": b.arg.buffer.device, "dtype": u8}
-                        | ({"init": blob.add(b.arg.buffer.ensure_allocated().as_memoryview())} if i in needs_init else {}) for b, i in buffers.items()],
-            "check": {"inputs": [[path, store(array), device] for path, array, device in frame["inputs"]],
-                      "outputs": [store(array) for array in frame["outputs"]], "output_container": frame["output_container"]}}
-  with sink:
-    sink.flush()
-    return header, memoryview(mmap.mmap(sink.fileno(), 0, access=mmap.ACCESS_READ))
-
-
-def main():
-  parser = argparse.ArgumentParser(description="Convert commaai's precompiled chestnut driving model into a plain tinygrad artifact")
-  parser.add_argument("pkl", help="big_driving_tinygrad.pkl")
-  parser.add_argument("output")
-  args = parser.parse_args()
-
-  patch_fetch_fw()
-  from examples.openpilot.helpers import allocate_inputs, load_pickle
-  from tinygrad import Device, Tensor
-  from tinygrad.engine.realize import lower_and_compile
-  artifact = load_pickle(args.pkl, out_of_band=True)
-  artifact["run"].captured._linear = lower_and_compile(artifact["run"].captured._linear)
-  rng = np.random.default_rng(7)
-
-  def initialize(arrays: dict):
-    for value in arrays.values():
-      value[...] = rng.standard_normal(value.shape) if value.dtype.kind == "f" else rng.integers(0, 2 if value.dtype == np.bool_ else 16, value.shape)
-  kwargs = allocate_inputs(artifact["input_specs"], initialize) | {"output_buffers": allocate_inputs(artifact["output_specs"])}
-  frame, _ = capture_frame(artifact["run"], kwargs, "output_buffers")
-  part = convert(artifact["run"], kwargs, frame, Device[Device.DEFAULT].renderer.target)
-
-  plain = PlainJit(*part)  # replays the frame, within tolerance
-  replay = {path[0]: Tensor(array, device=device).realize() for path, array, device in frame["inputs"] if len(path) == 1}
-  replay["output_buffers"] = {path[1]: Tensor(array, device=device).realize() for path, array, device in frame["inputs"] if len(path) == 2}
-  flatten(plain(**replay))
-  for index, (got, expected) in enumerate(zip([t.numpy() for t in replay["output_buffers"].values()], frame["outputs"], strict=True)):
-    assert np.array_equal(got, expected), f"output {index} of the plain artifact differs from the pickle"
-  write_bundle(args.output, {"run": part}, {key: artifact[key] for key in ("metadata", "input_specs", "output_specs")})
-  print(f"converted {len(part[0]['calls'])} kernels, bit-exact with the pickle: {args.output}")
-
-
-if __name__ == "__main__":
-  main()

openpilot/sunnypilot/modeld_v2/frame_fusion.py

@@ -1,69 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import bisect
-import itertools
-import math
-from functools import partial
-
-from openpilot.common.basedir import BASEDIR
-from openpilot.sunnypilot.modeld_v2.helpers import _dtype, read_parts
-
-
-def pack_layout(shapes: dict[str, tuple], frame_size: int) -> tuple[dict[str, int], int]:
-  offsets, offset = {}, 0
-  for name, shape in ({"tfm": (2, 3, 3)} | shapes).items():
-    offsets[name], offset = offset, offset + -(-math.prod(shape) * 4 // 128) * 128
-  return offsets | {"frames": offset}, offset + 2 * frame_size
-
-
-class _Blobs:  # the model's and the warp's blobs as one address space, for a part whose ranges span both files
-  def __init__(self, *blobs):
-    self.blobs, self.starts = blobs, list(itertools.accumulate([0] + [len(blob) for blob in blobs[:-1]]))
-
-  def __getitem__(self, span: slice):
-    index = bisect.bisect_right(self.starts, span.start) - 1
-    return self.blobs[index][span.start - self.starts[index]:span.stop - self.starts[index]]
-
-
-def fused_with_warp(cam_w: int, cam_h: int, chestnut: bool):  # load_model's extend: a native model runs upload, warp and model as one submit
-  return partial(frame_part, f"{BASEDIR}/openpilot/sunnypilot/modeld_v2/models/{'big_' if chestnut else ''}driving_warp_{cam_w}x{cam_h}_tinygrad.pkl")
-
-
-def frame_part(warp_path: str, parts: dict, extras: dict) -> dict:
-  if "input_specs" not in extras:  # a legacy model warps in its own parts
-    return {}
-  (model, model_blob), (warp, warp_blob) = parts["run"], read_parts(warp_path)[0]["run"]
-  states = sorted(name for name in extras["input_specs"] if f"next_{name}" in extras["metadata"]["output_shapes"])
-  host = {name: shape for name, (shape, _, _) in extras["input_specs"].items() if name not in states and name != "new_img"}
-  frame_size = next(s["numel"] for s in warp["inputs"] if s["name"] == "input_frame") // 2
-  offsets, packed = pack_layout(host, frame_size)
-  shift, upload, u8 = len(model_blob), len(model["buffers"]) + len(warp["buffers"]), repr(_dtype("dtypes.uint8"))
-
-  def view(name: str, nbytes: int, dtype: str) -> dict:
-    return {"buffer": upload, "offset": offsets[name], "nbytes": nbytes, "dtype": dtype}
-  outputs = sorted(s["slot"] for s in model["inputs"] if s["name"] is None)
-  names = sorted(["host", *states])
-  slots = {s["slot"]: names.index(s["name"]) for s in model["inputs"] if s["name"] in states} | \
-          {slot: len(names) + i for i, slot in enumerate(outputs)}
-  returned = warp["returns"]["tensors"][0]
-  model_inputs = {s["slot"]: {"input": slots[s["slot"]]} if s["slot"] in slots else
-                  {k: v for k, v in returned.items() if k != "shape"} | {"buffer": returned["buffer"] + len(model["buffers"])} if s["name"] == "new_img" else
-                  view(s["name"], s["numel"] * _dtype(s["dtype"]).itemsize, s["dtype"]) for s in model["inputs"]}
-  warp_inputs = {s["slot"]: view("frames" if s["name"] == "input_frame" else "tfm", s["numel"] * _dtype(s["dtype"]).itemsize, s["dtype"])
-                 for s in warp["inputs"]}
-
-  def remap(calls: list, inputs: dict, buffers: int, lib: int) -> list:
-    return [call | ({"lib": [call["lib"][0] + lib, call["lib"][1] + lib]} if "lib" in call else {}) |
-            {"args": [dict(inputs[a["input"]]) if "input" in a else a | {"buffer": a["buffer"] + buffers} for a in call["args"]]} for call in calls]
-  header = {"input_names": names, "returns": {"kind": "NoneType", "tensors": []}, "check": None,
-            "inputs": [{"slot": names.index("host"), "name": "host", "dtype": u8, "numel": packed, "device": "NPY"}] +
-                      [s | {"slot": slots[s["slot"]]} for s in model["inputs"] if s["slot"] in slots],
-            "buffers": model["buffers"] + [b | ({"init": [b["init"][0] + shift, b["init"][1] + shift]} if "init" in b else {}) for b in warp["buffers"]] +
-                       [{"nbytes": packed, "device": model["inputs"][0]["device"], "dtype": u8}],
-            "calls": [{"kind": "copy", "args": [{"buffer": upload, "offset": 0, "nbytes": packed, "dtype": u8}, {"input": names.index("host")}]}] +
-                     remap(warp["calls"], warp_inputs, len(model["buffers"]), shift) + remap(model["calls"], model_inputs, 0, 0)}
-  return {"run": (header, _Blobs(model_blob, warp_blob))}  # replaces the model's run: one set of buffers, no separate warp

openpilot/sunnypilot/modeld_v2/get_model_metadata.py

@@ -1,8 +1,13 @@
-from typing import Any
+#!/usr/bin/env python3
+import sys
+import pathlib
 import codecs
 import pickle
+from typing import Any
+
 from tinygrad.nn.onnx import OnnxPBParser
 
+
 class MetadataOnnxPBParser(OnnxPBParser):
   def _parse_ModelProto(self) -> dict:
     obj: dict[str, Any] = {"graph": {"input": [], "output": []}, "metadata_props": []}
@@ -16,33 +21,35 @@ class MetadataOnnxPBParser(OnnxPBParser):
           self.reader.skip_field(wire_type)
     return obj
 
-def _get_name_and_shape(value_info: dict[str, Any]) -> tuple[str, tuple[int, ...]]:
-  shape = tuple(int(dim) if isinstance(dim, int) else 1 for dim in value_info["parsed_type"].shape)
-  return value_info["name"], shape
 
-def _get_metadata_value_by_name(model: dict[str, Any], name: str) -> str | None:
+def get_name_and_shape(value_info: dict[str, Any]) -> tuple[str, tuple[int, ...]]:
+  shape = tuple(int(dim) if isinstance(dim, int) else 0 for dim in value_info["parsed_type"].shape)
+  name = value_info["name"]
+  return name, shape
+
+
+def get_metadata_value_by_name(model: dict[str, Any], name: str) -> str | Any:
   for prop in model["metadata_props"]:
     if prop["key"] == name:
       return prop["value"]
   return None
 
-def make_metadata_dict(onnx_path):
-  model = MetadataOnnxPBParser(onnx_path).parse()
-  output_slices_raw = _get_metadata_value_by_name(model, 'output_slices')
 
-  if output_slices_raw:
-    output_slices = pickle.loads(codecs.decode(output_slices_raw.encode(), "base64"))
-  else:
-    output_slices = {}
+if __name__ == "__main__":
+  model_path = pathlib.Path(sys.argv[1])
+  model = MetadataOnnxPBParser(model_path).parse()
+  output_slices = get_metadata_value_by_name(model, 'output_slices')
+  assert output_slices is not None, 'output_slices not found in metadata'
 
-  input_shapes = dict(_get_name_and_shape(x) for x in model["graph"]["input"])
-  metadata = {prop["key"]: prop["value"] for prop in model["metadata_props"]}
-
-  if 'hidden_state' not in output_slices:
-    output_slices['hidden_state'] = slice(0, 512)
-
-  return {
-    'input_shapes': input_shapes,
-    'output_slices': output_slices,
-    'metadata_props': metadata
+  metadata = {
+    'model_checkpoint': get_metadata_value_by_name(model, 'model_checkpoint'),
+    'output_slices': pickle.loads(codecs.decode(output_slices.encode(), "base64")),
+    'input_shapes': dict(get_name_and_shape(x) for x in model["graph"]["input"]),
+    'output_shapes': dict(get_name_and_shape(x) for x in model["graph"]["output"]),
   }
+
+  metadata_path = model_path.parent / (model_path.stem + '_metadata.pkl')
+  with open(metadata_path, 'wb') as f:
+    pickle.dump(metadata, f)
+
+  print(f'saved metadata to {metadata_path}')

openpilot/sunnypilot/modeld_v2/helpers.py

@@ -1,331 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import bisect
-import builtins
-import contextlib
-import dataclasses
-import functools
-import hashlib
-import io
-import itertools
-import json
-import math
-import mmap
-import os
-import pickle
-import struct
-
-MAGIC = b"SPTGPLN1"
-ALIGNMENT = 256
-METADATA_TYPES = ("slice", "tuple", "list", "dict", "set", "frozenset", "complex")
-RUNTIME_ENVIRONMENT = ("GMMU", "AMD_AQL", "AMD_DISABLE_SDMA", "GRAPH_ONE_KERNEL")
-
-
-def _patch_system_flock_acquire():
-  try:
-    from tinygrad.runtime.support.system import System
-    original_flock_acquire = System.flock_acquire
-    acquired_locks: dict[str, int] = {}
-
-    def flock_acquire(name: str) -> int:
-      if name in acquired_locks:
-        return acquired_locks[name]
-      lock_file_descriptor = original_flock_acquire(name)
-      acquired_locks[name] = lock_file_descriptor
-      return lock_file_descriptor
-    System.flock_acquire = flock_acquire
-  except (ImportError, AttributeError):
-    pass
-_patch_system_flock_acquire()
-
-
-def patch_fetch_fw() -> None:
-  try:
-    import zstandard
-  except ImportError:
-    return
-  zstandard.decompress = lambda data, *_: zstandard.ZstdDecompressor().stream_reader(data).read()  # ty: ignore[invalid-assignment]
-
-
-class ArtifactMismatch(RuntimeError):
-  pass
-
-
-class Blob:
-  def __init__(self, sink=None):
-    self.chunks: list = []
-    self.locations: dict[bytes, list[int]] = {}
-    self.size, self.write = 0, sink.write if sink else self.chunks.append
-
-  def add(self, data) -> list[int]:
-    if (key := hashlib.blake2b(data, digest_size=16).digest()) not in self.locations:
-      start = self.size + -self.size % ALIGNMENT
-      self.write(bytes(start - self.size)), self.write(data)
-      self.locations[key], self.size = [start, start + memoryview(data).nbytes], start + memoryview(data).nbytes
-    return self.locations[key]
-
-
-class _MetadataUnpickler(pickle.Unpickler):
-  def find_class(self, module, name):
-    if module == "builtins" and name in METADATA_TYPES:
-      return getattr(builtins, name)
-    raise pickle.UnpicklingError(f"{module}.{name} is not allowed in model metadata")
-
-
-def flatten(value) -> list:
-  if isinstance(value, (tuple, list)):
-    return [tensor for item in value for tensor in flatten(item)]
-  return [] if value is None else [value]
-
-
-def _relocate(value, part_blob: memoryview, blob: Blob):
-  if isinstance(value, dict):
-    return {k: blob.add(part_blob[slice(*v)]) if k in ("lib", "init", "data") else _relocate(v, part_blob, blob) for k, v in value.items()}
-  return [_relocate(v, part_blob, blob) for v in value] if isinstance(value, list) else value
-
-
-def write_bundle(path: str, parts: dict, extras: dict | None = None):
-  blob = Blob()
-  headers = {key: _relocate(part_header, memoryview(part_blob), blob) for key, (part_header, part_blob) in parts.items()}
-  extras_location = blob.add(pickle.dumps(extras or {}, protocol=4))
-  entries = [{"key": list(key) if isinstance(key, tuple) else key, "blob": [0, blob.size], "header": header} for key, header in headers.items()]
-  header = json.dumps({"parts": entries, "extras": extras_location}).encode()
-  with open(path, "wb") as file:
-    file.write(MAGIC + struct.pack("<Q", len(header)) + header + bytes(-(len(MAGIC) + 8 + len(header)) % ALIGNMENT))
-    file.writelines(blob.chunks)
-
-
-def read_parts(path: str) -> tuple[dict, dict]:
-  with open(path, "rb") as file:
-    data = memoryview(mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_COPY))
-  if bytes(data[:len(MAGIC)]) != MAGIC:
-    raise ValueError(f"{path} is not a plain tinygrad model, recompile it with compile_modeld.py")
-  start = len(MAGIC) + 8 + struct.unpack_from("<Q", data, len(MAGIC))[0]
-  header, blob = json.loads(bytes(data[len(MAGIC) + 8:start])), data[start + -start % ALIGNMENT:]
-  parts = {tuple(e["key"]) if isinstance(e["key"], list) else e["key"]: (e["header"], blob[slice(*e["blob"])]) for e in header["parts"]}
-  return parts, _MetadataUnpickler(io.BytesIO(bytes(blob[slice(*header["extras"])]))).load()
-
-
-def _extended(path: str, extend) -> tuple[dict, dict, str]:
-  parts, extras = read_parts(path)
-  added = extend(parts, extras) if extend else {}
-  return parts | added, extras, _parts_digest(added) if added else ""
-
-
-def load_model(path: str, device_map: dict | None = None, verify: bool = True, cache: bool = True, extend=None) -> dict:
-  parts, extras, extra = _extended(path, extend)
-  if cache and (cached := _read_cache(path, parts, device_map, extra)) is not None:
-    return extras | cached
-  shared: dict = {}
-  jits = {key: PlainJit(header, blob, device_map, verify, shared) for key, (header, blob) in parts.items()}
-  if cache:
-    _write_cache(path, jits, device_map, extra)
-  return extras | jits
-
-
-@functools.cache
-def tinygrad_identity() -> str:
-  import tinygrad
-  root, digest = os.path.dirname(tinygrad.__file__), hashlib.sha256()
-  for directory, _, files in sorted(os.walk(root)):
-    for name in sorted(file for file in files if file.endswith(".py")):
-      with open(path := os.path.join(directory, name), "rb") as file:
-        digest.update(f"{os.path.relpath(path, root)}:".encode() + file.read())
-  return digest.hexdigest()
-
-
-def _parts_digest(parts: dict) -> str:
-  digest = hashlib.sha256()
-  for _, (header, blob) in sorted(parts.items(), key=lambda item: repr(item[0])):
-    digest.update(json.dumps(header, sort_keys=True).encode())
-    for call in header["calls"]:
-      if call["kind"] == "program":
-        digest.update(blob[slice(*call["lib"])])
-  return digest.hexdigest()
-
-
-def _cache_key(path: str, device_map: dict | None, extra: str = "") -> bytes:
-  stat = os.stat(path)
-  return json.dumps({"format": MAGIC.decode(), "tinygrad": tinygrad_identity(), "size": stat.st_size, "mtime_ns": stat.st_mtime_ns,
-                     "extra": extra, "device_map": sorted((device_map or {}).items()),
-                     "env": [os.environ.get(name, "") for name in RUNTIME_ENVIRONMENT]}).encode()
-
-
-def _cache_header_matches(file, path: str, device_map: dict | None, extra: str = "") -> bool:
-  return file.read(struct.unpack("<Q", file.read(8))[0]) == _cache_key(path, device_map, extra)
-
-
-def cache_is_fresh(path: str, device_map: dict | None = None) -> bool: # entry point for warmup proc
-  try:
-    with open(f"{path}.cache", "rb") as file:
-      return _cache_header_matches(file, path, device_map)
-  except (OSError, struct.error):
-    return False
-
-
-def _read_cache(path: str, parts: dict, device_map: dict | None, extra: str = "") -> dict | None:
-  try:
-    with open(f"{path}.cache", "rb") as file:
-      if not _cache_header_matches(file, path, device_map, extra):
-        return None
-      shared: dict = {}
-      buffers = {repr(key): _allocate_buffers(header, blob, device_map, shared) for key, (header, blob) in parts.items()}
-      return type("_Unpickler", (pickle.Unpickler,), {"persistent_load": lambda self, pid: buffers[pid[0]][pid[1]]})(file).load()
-  except Exception:
-    return None
-
-
-def _write_cache(path: str, jits: dict, device_map: dict | None, extra: str = "") -> None:
-  from tinygrad.device import Buffer
-  owners = {id(buffer): (repr(key), index) for key, jit in jits.items() for index, buffer in enumerate(jit.buffers)}
-
-  class _Pickler(pickle.Pickler):
-    def persistent_id(self, obj):
-      return owners.get(id(obj)) if isinstance(obj, Buffer) else None
-
-  key, tmp_path = _cache_key(path, device_map, extra), f"{path}.cache.{os.getpid()}.tmp"
-  with contextlib.suppress(Exception):
-    with open(tmp_path, "wb") as file:
-      file.write(struct.pack("<Q", len(key)) + key)
-      _Pickler(file, protocol=5).dump({name: _Jit(jit.captured, jit.input_names, jit.buffers) for name, jit in jits.items()})
-    os.replace(tmp_path, f"{path}.cache")
-
-
-# Everything below this comment block calls tinygrad internals, so after a tinygrad bump this
-# is the only code to update, and models are not recompiled. How to do this when discountchubbs is not available:
-#   1. run modeld_v2/tests/test_plain_artifact.py on the new tinygrad and fix each failing call against the new API: Buffer,
-#      UOp.from_buffer/param (ParamArg), ProgramInfo, Target, KernelInfo, compile_linear, CapturedJit and
-#      _prepare_jit_inputs in tinygrad/engine/jit.py
-#   2. load a real model with verify=True: ArtifactMismatch means the rebuilt graph still differs from the one that was compiled
-# The boot cache is keyed on the tinygrad source, so it rebuilds itself. Only a change in how the device runs kernel binaries needs a recompile.
-# Honestly, I would just have your clanker try it because you likely have zero idea what you are looking at lol..
-
-def _dtype(text: str):
-  from tinygrad.dtype import dtypes
-  return eval(text, {"__builtins__": {}}, {"dtypes": dtypes})
-
-
-def _device(recorded: str, device_map: dict | None) -> str:
-  from tinygrad import Device
-  device_map = device_map or {}
-  return Device.canonicalize(device_map.get(recorded, device_map.get(recorded.split(":", 1)[0], recorded)))
-
-
-def _upload(buffer, data: memoryview, chunk: int = 16 << 20) -> None:
-  from tinygrad.device import Buffer
-  source, chunk = Buffer("NPY", len(data), opaque=memoryview(bytearray(data)) if data.readonly else data), min(chunk, len(data))
-  for offset in sorted({*range(0, len(data) - chunk, chunk), len(data) - chunk}):
-    buffer.view(chunk, offset).ensure_allocated().copy_from(source.view(chunk, offset).ensure_allocated())
-
-
-def _allocate_buffers(header: dict, blob: memoryview, device_map: dict | None, shared: dict) -> list:
-  import numpy as np
-  from tinygrad.device import Buffer
-  written = {call["args"][i]["buffer"] for call in header["calls"] for i in (call["outs"] if call["kind"] == "program" else (0,))
-             if "buffer" in call["args"][i]}
-  entries = [(_device(entry["device"], device_map), blob[slice(*entry["init"])] if "init" in entry else None, entry) for entry in header["buffers"]]
-  keys = [(device, entry["dtype"], np.frombuffer(data, np.uint8).ctypes.data, len(data)) if data and index not in written else object()
-          for index, (device, data, entry) in enumerate(entries)]
-  for device in {key[0] for key in keys if isinstance(key, tuple) and key not in shared}:
-    if shared.setdefault(("mapped", device), Buffer(device, 1).ensure_allocated().get_storage().host is not None):
-      continue
-    spans = [(entry["init"], entry["nbytes"], key) for (_, _, entry), key in zip(entries, keys, strict=True)
-             if isinstance(key, tuple) and key[0] == device and key not in shared]
-    files = getattr(blob, "starts", [0])  # a part read from several files (frame_fusion's) is uploaded a block per file
-    for _, group in itertools.groupby(sorted(spans, key=lambda span: span[0][0]), key=lambda span: bisect.bisect_right(files, span[0][0])):
-      group = list(group)
-      start, end = min(span[0] for span, _, _ in group), max(span[1] for span, _, _ in group)
-      _upload(block := Buffer(device, end - start).ensure_allocated(), blob[start:end])
-      shared |= {key: block.view(nbytes, span[0] - start).ensure_allocated() for span, nbytes, key in group}
-  buffers = []
-  for (device, data, entry), key in zip(entries, keys, strict=True):
-    if key not in shared:
-      shared[key] = Buffer(device, entry["nbytes"], initial_value=pickle.PickleBuffer(data) if data else None).ensure_allocated()
-    buffers.append(shared[key])
-  return buffers
-
-
-def _program_uop(call: dict, lib: bytes):
-  from tinygrad.helpers import Target
-  from tinygrad.uop.ops import KernelInfo, Ops, ProgramInfo, UOp
-  parameters = []
-  for name, compact_slot, dtype, shape in call["signature"]:
-    parameter = UOp.param(call["globals"][compact_slot], _dtype(dtype), math.prod(shape))
-    image = (shape[0], shape[1]) if len(shape) == 3 and shape[2] == 4 else None
-    parameters.append(parameter.replace(arg=dataclasses.replace(parameter.arg, name=name, image=image)))
-  info = ProgramInfo(global_size=tuple(call["global_size"]), local_size=tuple(call["local_size"]), vars=(), globals=tuple(call["globals"]),
-                     outs=tuple(call["outs"]), ins=tuple(call["ins"]), target=Target(**call["target"]))
-  return UOp(Ops.PROGRAM, src=(UOp(Ops.SINK, arg=KernelInfo(name=call["name"])), UOp(Ops.LINEAR, src=tuple(parameters)),
-                               UOp(Ops.SOURCE, arg=""), UOp(Ops.BINARY, arg=lib)), arg=info)
-
-
-class _Jit:
-  def __init__(self, captured, input_names: list, buffers: list):
-    self.captured, self.input_names, self.buffers = captured, input_names, buffers
-
-  def __call__(self, *args, **kwargs):
-    import tinygrad.engine.jit as jit
-    input_uops, var_vals, names, _ = jit._prepare_jit_inputs(args, kwargs)
-    if names != self.input_names:
-      raise ValueError(f"expected inputs {self.input_names}, got {names}")
-    return self.captured(input_uops, var_vals)
-
-
-class PlainJit(_Jit):
-  def __init__(self, header: dict, blob: memoryview, device_map: dict | None = None, verify: bool = True, shared: dict | None = None):
-    import numpy as np
-    import tinygrad.engine.jit as jit
-    from tinygrad import Tensor
-    from tinygrad.device import Buffer
-    from tinygrad.dtype import dtypes
-    from tinygrad.uop.ops import Ops, UOp
-
-    inputs = {spec["slot"]: spec for spec in header["inputs"]}
-    buffers = _allocate_buffers(header, blob, device_map, {} if shared is None else shared)
-    bases = [UOp.from_buffer(buffer, _dtype(entry["dtype"])) for buffer, entry in zip(buffers, header["buffers"], strict=True)]
-
-    def argument(described: dict):
-      if "input" in described:
-        spec = inputs[described["input"]]
-        return UOp.param(described["input"], _dtype(spec["dtype"]), spec["numel"], _device(spec["device"], device_map))
-      base, dtype, offset, nbytes = bases[described["buffer"]], _dtype(described["dtype"]), described["offset"], described["nbytes"]
-      if offset == 0 and nbytes == header["buffers"][described["buffer"]]["nbytes"] and dtype == base.dtype:
-        return base
-      return (base if base.dtype.itemsize == 1 else base.bitcast(dtypes.uint8)).shrink(((offset, offset + nbytes),)).bitcast(dtype)
-
-    calls = []
-    for call in header["calls"]:
-      arguments = [argument(described) for described in call["args"]]
-      if call["kind"] == "program":
-        calls.append(_program_uop(call, bytes(blob[slice(*call["lib"])])).call(*arguments))
-      else:
-        calls.append(arguments[0].store_call(arguments[1]))
-    # stand-ins for JIT inputs: copy staging to GPU is decided from the input buffers, the real ones bind per call
-    stand_ins = {slot: UOp.from_buffer(Buffer(_device(spec["device"], device_map), spec["numel"] * _dtype(spec["dtype"]).itemsize).ensure_allocated(),
-                                       _dtype(spec["dtype"])) for slot, spec in inputs.items()}
-    input_uops = tuple(stand_ins.get(slot, next(iter(stand_ins.values()), None)) for slot in range(max(stand_ins, default=-1) + 1))
-    linear = jit.compile_linear(UOp(Ops.LINEAR, src=tuple(calls)), beam=0, input_uops=input_uops, cache=False)
-
-    returned = [Tensor(argument(t)).reshape(tuple(t["shape"])) for t in header["returns"]["tensors"]]
-    ret = {"NoneType": None, "Tensor": returned[0] if returned else None, "tuple": tuple(returned), "list": returned}[header["returns"]["kind"]]
-    super().__init__(jit.CapturedJit(ret, linear, header["input_names"], []), header["input_names"], buffers)
-
-    if not verify or not (check := header.get("check")):
-      return
-    def array(stored):
-      return np.frombuffer(blob[slice(*stored["data"])], dtype=np.dtype(stored["dtype"])).reshape(stored["shape"]).copy()
-    kwargs: dict = {}
-    for path, stored, device in check["inputs"]:
-      tensor = Tensor(array(stored), device=_device(device, device_map)).realize()
-      kwargs[path[0]] = tensor if len(path) == 1 else {**kwargs.get(path[0], {}), path[1]: tensor}
-    result = self(**kwargs)
-    outputs = kwargs[check["output_container"]].values() if check["output_container"] else flatten(result)
-    for index, (got, stored) in enumerate(zip([t.numpy() for t in outputs], check["outputs"], strict=True)):
-      expected = array(stored)
-      if got.shape != expected.shape or not np.allclose(got, expected, rtol=1e-3, atol=1e-3, equal_nan=True):
-        raise ArtifactMismatch(f"output {index} differs from the compile-time reference frame; recompile the model")

openpilot/sunnypilot/modeld_v2/model_adapters.py

@@ -1,209 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import codecs
-import math
-from pathlib import Path
-import pickle
-import numpy as np
-
-from openpilot.common.basedir import BASEDIR
-from openpilot.sunnypilot.modeld_v2.frame_fusion import pack_layout
-from openpilot.sunnypilot.modeld_v2.helpers import load_model
-from openpilot.sunnypilot.modeld_v2.compile_modeld import (POLICY_INPUTS, derive_frame_skip,
-                                                           make_split_input_queues, make_supercombo_input_queues)
-from openpilot.sunnypilot.modeld_v2.stock_dependencies import make_input_queues as stock_make_input_queues, nv12_copy_size
-from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
-from tinygrad.device import Buffer
-from tinygrad.dtype import DType
-from tinygrad.tensor import Tensor
-from tinygrad.uop.ops import UOp
-
-
-def input_view(buffer: Buffer, shape: tuple[int, ...], dtype: DType, offset: int) -> Tensor:
-  view = buffer.view(math.prod(shape) * dtype.itemsize, offset).ensure_allocated()
-  return Tensor(UOp.from_buffer(view, dtype)).reshape(shape)
-
-
-class BaseModelAdapter:
-  def __init__(self, jits, cam_w, cam_h, model_device, queue_device, warp_device, chestnut=False):
-    self.jits = jits
-    self.DEV = model_device
-    self.QUEUE_DEV = queue_device
-    self.WARP_DEV = warp_device
-    self.chestnut = chestnut
-    self.cam_w = cam_w
-    self.cam_h = cam_h
-    self._combined_model_type = 'supercombo'
-    self._policy_slices_list = []
-    self._has_on_policy = False
-    self.policy_output_slices = {}
-    self._policy_keys = []
-    self.full_frames = {}
-    self._blob_cache = {}
-    self.nv12_info = get_nv12_info(cam_w, cam_h)
-    self.is_native = False
-
-  def _init_common(self):
-    self._desire_key = next((key for key in getattr(self, 'numpy_inputs', {}) if key.startswith('desire')), 'desire')
-    self._road_key = next((key for key in getattr(self, '_vision_input_names', []) if 'big' not in key), 'img')
-    self._wide_key = next((key for key in getattr(self, '_vision_input_names', []) if 'big' in key), 'big_img')
-    self.frame_buf_params = dict.fromkeys(getattr(self, '_vision_input_names', ['img', 'big_img']), self.nv12_info)
-
-  def get_dummy_inputs(self):
-    dummy_size = getattr(self, 'warp_frame_size', self.frame_copy_size if self.is_native else self.frame_buf_params[self._road_key][3])
-    dummy_frames = {k: np.zeros(dummy_size, dtype=np.uint8) for k in self._vision_input_names}
-    transforms = {k: np.eye(3, dtype=np.float32) for k in [self._road_key, self._wide_key] if k}
-    dummy_inputs = {k: np.zeros(v.shape, dtype=v.dtype) for k, v in self.numpy_inputs.items() if k not in ['tfm', 'big_tfm', 'prev_feat']}
-    return dummy_frames, transforms, dummy_inputs
-
-  def _load_warp(self):
-    if (self.cam_w, self.cam_h) in self.jits:
-      self.warp_frame_size = self.nv12_info[3]
-      return self.jits[(self.cam_w, self.cam_h)]
-
-    warp_name = f'{"big_" if self.chestnut else ""}driving_warp_{self.cam_w}x{self.cam_h}_tinygrad.pkl'
-    warp = load_model(str(Path(BASEDIR) / "openpilot/sunnypilot/modeld_v2/models" / warp_name), cache=False)
-    self.warp_frame_size = warp['input_specs']['input_frame'][0][1]
-    return warp['run']
-
-
-class LegacyModelAdapter(BaseModelAdapter):
-  def __init__(self, *args, **kwargs):
-    super().__init__(*args, **kwargs)
-
-    metadata = self.jits['metadata']
-    self.frame_copy_size = nv12_copy_size(*self.nv12_info[:3])
-
-    if self.chestnut:
-      self.WARP_DEV = self.DEV
-
-    if 'model' in metadata:
-      model_metadata = metadata.get('model', metadata)
-      self.input_shapes = model_metadata['input_shapes']
-      self.vision_output_slices = model_metadata['output_slices']
-      self._vision_input_names = [key for key in self.input_shapes if 'img' in key]
-      self.frame_skip = derive_frame_skip({}, self.input_shapes)
-      if self.chestnut:
-        self.input_queues, self.numpy_inputs, self.frame_slots = stock_make_input_queues(
-          self.input_shapes, self.frame_skip, device=self.QUEUE_DEV, frame_copy_size=self.frame_copy_size)
-      else:
-        self.input_queues, self.numpy_inputs = make_supercombo_input_queues(self.input_shapes, self.frame_skip, device=self.QUEUE_DEV)
-      self.run_policy = self.jits['run_policy'] if 'run_policy' in self.jits else self.jits[(self.cam_w, self.cam_h)]
-    else:
-      self.run_policy = self.jits['run_policy']
-      vision_metadata = metadata['vision']
-      policy_keys = [k for k in metadata if k not in ('vision', 'warp_dev')]
-      self._combined_model_type = 'split' if policy_keys == ['policy'] else 'multi_policy'
-      self.vision_output_slices = vision_metadata['output_slices']
-      self._policy_keys = policy_keys
-      self._policy_slices_list = [metadata[k]['output_slices'] for k in policy_keys]
-      self.policy_output_slices = self._policy_slices_list[0]
-      self._has_on_policy = any('on' in k.lower() for k in policy_keys)
-      self._vision_input_names = [key for key in vision_metadata['input_shapes'] if 'img' in key]
-      first_policy_meta = metadata[policy_keys[0]]
-      self.frame_skip = derive_frame_skip(vision_metadata['input_shapes'], first_policy_meta['input_shapes'])
-      self.input_queues, self.numpy_inputs = make_split_input_queues(vision_metadata['input_shapes'], first_policy_meta['input_shapes'],
-                                                                     self.frame_skip, device=self.QUEUE_DEV)
-
-    self.run_warp = self._load_warp()
-    self._init_common()
-    if not self.chestnut:
-      yuv_size = self.frame_buf_params[self._road_key][3]
-      frame_tensor = Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.WARP_DEV).contiguous().realize()
-      big_frame_tensor = Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.WARP_DEV).contiguous().realize()
-      self.run_warp(**{k: self.input_queues[k] for k in ('tfm', 'big_tfm')},
-                    frame=frame_tensor, big_frame=big_frame_tensor)
-
-  def copy_frames(self, bufs):
-    if self.chestnut:
-      for key in self._vision_input_names:
-        if key in bufs:
-          data = bufs[key].data if hasattr(bufs[key], 'data') else bufs[key]
-          np.copyto(self.frame_slots[key], np.frombuffer(data, dtype=np.uint8, count=self.frame_copy_size))
-    else:
-      for key in bufs.keys():
-        data = bufs[key].data if hasattr(bufs[key], 'data') else bufs[key]
-        ptr = np.frombuffer(data, dtype=np.uint8).ctypes.data
-        yuv_size = self.frame_buf_params[key][3]
-        cache_key = (key, ptr)
-        if cache_key not in self._blob_cache:
-          self._blob_cache[cache_key] = Tensor.from_blob(ptr, (yuv_size,), dtype='uint8', device=self.WARP_DEV)
-        self.full_frames[key] = self._blob_cache[cache_key]
-
-  def reset_warmup_buffers(self):
-    for v in self.numpy_inputs.values():
-      v[:] = 0
-    if not self.chestnut:
-      self.full_frames.clear()
-      self._blob_cache.clear()
-
-  def run(self):
-    if self.chestnut:
-      return self.run_policy(**{k: self.input_queues[k] for k in POLICY_INPUTS if k in self.input_queues})
-
-    warped = self.run_warp(**{k: self.input_queues[k] for k in ('tfm', 'big_tfm')},
-                           frame=self.full_frames[self._road_key], big_frame=self.full_frames[self._wide_key])
-    return self.run_policy(**{k: self.input_queues[k] for k in POLICY_INPUTS if k in self.input_queues}, warped=warped)
-
-
-class NativeTinygradAdapter(BaseModelAdapter):
-  def __init__(self, *args, **kwargs):
-    super().__init__(*args, **kwargs)
-    self.is_native = True
-    self.input_specs = self.jits['input_specs']
-
-    self.model_device = self.input_specs['new_img'][2]
-    self.input_shapes = {name: (shape, np.dtype(dtype)) for name, (shape, dtype, _) in self.input_specs.items()}
-    self.state_pairs = {name: f'next_{name}' for name in self.input_shapes if f'next_{name}' in self.jits['metadata']['output_shapes']}
-
-    stride, y_height, uv_height, _ = get_nv12_info(self.cam_w, self.cam_h)
-    self.frame_copy_size = stride * (y_height + uv_height)
-
-    self.input_shapes_orig = self.jits['metadata']['input_shapes']
-    self._vision_input_names = [k for k in self.input_shapes_orig if 'img' in k]
-    self.vision_output_slices = pickle.loads(codecs.decode(self.jits['metadata']['metadata']['output_slices'].encode(), 'base64'))
-
-    self.warp_frame_size = self.frame_copy_size
-    self._init_common()
-    self.run_model = self.jits['run']
-
-    self.input_queues = {name: Tensor(np.zeros(shape, dtype=dtype), device=self.model_device).realize()
-                         for name, (shape, dtype) in self.input_shapes.items() if name in self.state_pairs}
-    shapes = {name: shape for name, (shape, _) in self.input_shapes.items() if name not in self.state_pairs and name != 'new_img'}
-    offsets, packed = pack_layout(shapes, self.warp_frame_size)
-    self.packed_input = np.zeros(packed, dtype=np.uint8)
-    self.host = Tensor(self.packed_input, device='NPY')
-    self.numpy_inputs = {name: np.ndarray(shape, dtype=np.float32, buffer=self.packed_input, offset=offsets[name])
-                         for name, shape in ({'tfm': (2, 3, 3)} | shapes).items()}
-    self.frames = self.packed_input[offsets['frames']:].reshape(2, self.warp_frame_size)
-
-    self.outputs = {name: Tensor(np.zeros(shape, dtype=dtype), device=device).realize() for name, (shape, dtype, device) in self.jits['output_specs'].items()}
-    for name, next_name in self.state_pairs.items():
-      state = self.input_queues[name]
-      self.outputs[next_name] = input_view(state._buffer(), state.shape, state.dtype, 0)
-
-  def copy_frames(self, bufs):
-    for i, key in enumerate(self._vision_input_names):
-      if key in bufs:
-        data = bufs[key].data if hasattr(bufs[key], 'data') else bufs[key]
-        np.copyto(self.frames[i], np.frombuffer(data, dtype=np.uint8, count=self.warp_frame_size))
-
-  def reset_warmup_buffers(self) -> None:
-    self.packed_input[:] = 0
-    for key in self.state_pairs:
-      self.input_queues[key].assign(0).realize()
-
-  def run(self):
-    self.run_model(host=self.host, **self.input_queues, output_buffers=self.outputs)
-    return self.outputs['outputs']
-
-
-def get_model_adapter(jits, cam_w, cam_h, model_device, queue_device, warp_device, chestnut=False):
-  if 'input_specs' in jits:
-    return NativeTinygradAdapter(jits, cam_w, cam_h, model_device, queue_device, warp_device, chestnut=chestnut)
-  else:
-    return LegacyModelAdapter(jits, cam_w, cam_h, model_device, queue_device, warp_device, chestnut=chestnut)

openpilot/sunnypilot/modeld_v2/modeld.py

@@ -13,10 +13,11 @@ import numpy as np
 import threading
 import time
 from setproctitle import setproctitle
+from tinygrad.tensor import Tensor
 
 import openpilot.cereal.messaging as messaging
 from openpilot.common.hardware import COMMA_HARDWARE
-from openpilot.selfdrive.modeld.helpers import chestnut_present
+from openpilot.selfdrive.modeld.helpers import chestnut_present, load_oob
 from openpilot.cereal import log
 from opendbc.car.structs import car
 from openpilot.cereal.services import SERVICE_LIST
@@ -24,26 +25,33 @@ from openpilot.cereal.messaging import PubMaster, SubMaster
 from openpilot.cereal.visionipc import VisionStreamType
 from msgq.visionipc import VisionIpcClient, VisionBuf
 from opendbc.car.car_helpers import get_demo_car_params
+from openpilot.common.file_chunker import open_file_chunked
 from openpilot.common.swaglog import cloudlog
 from openpilot.common.params import Params
 from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.common.realtime import config_realtime_process, DT_MDL
 from openpilot.common.transformations.camera import DEVICE_CAMERAS
 from openpilot.common.transformations.model import get_warp_matrix
+from openpilot.system import sentry
+from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.selfdrive.controls.lib.drive_helpers import get_accel_from_plan, smooth_value
-from openpilot.selfdrive.modeld.modeld import ChestnutGpuState
+from openpilot.selfdrive.modeld.modeld import ChestnutState
 
+from openpilot.selfdrive.modeld.compile_modeld import (
+  MODELD_INPUTS,
+  make_input_queues as make_stock_input_queues,
+)
 from openpilot.sunnypilot.modeld_v2.fill_model_msg import fill_model_msg, fill_pose_msg, PublishState, get_curvature_from_output
 from openpilot.sunnypilot.modeld_v2.parse_model_outputs import Parser
 from openpilot.sunnypilot.modeld_v2.constants import ModelConstants, Plan
 from openpilot.sunnypilot.modeld_v2.meta_helper import load_meta_constants
 from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
+from openpilot.sunnypilot.modeld_v2.compile_modeld import (derive_frame_skip, make_split_input_queues,
+                                                           make_supercombo_input_queues, nv12_copy_size,
+                                                           WARP_INPUTS, POLICY_INPUTS)
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
-from openpilot.sunnypilot.modeld_v2.helpers import load_model
-from openpilot.sunnypilot.modeld_v2.frame_fusion import fused_with_warp
-from openpilot.sunnypilot.modeld_v2.model_adapters import get_model_adapter
 from openpilot.sunnypilot.models.helpers import get_active_bundle
 from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
 
@@ -52,7 +60,8 @@ BIG_MODEL_TIMEOUT = 60
 
 
 def _pkl_exists(path):
-  return os.path.exists(path)
+  from openpilot.common.file_chunker import get_manifest_path
+  return os.path.exists(path) or os.path.exists(get_manifest_path(path))
 
 
 def _find_driving_pkl(bundle):
@@ -107,25 +116,58 @@ class ModelState(ModelStateBase):
 
   def _init_combined(self, pkl_path, cam_w, cam_h, bundle):
     cloudlog.warning(f"loading combined pkl: {pkl_path}")
-    jits = load_model(pkl_path, extend=fused_with_warp(cam_w, cam_h, self.chestnut))
+    jits = load_oob(open_file_chunked(pkl_path))
 
     metadata = jits['metadata']
     self.WARP_DEV = metadata.get('warp_dev', 'QCOM') if COMMA_HARDWARE else 'CPU'
     self.DEV = ('AMD' if self.chestnut else 'QCOM') if COMMA_HARDWARE else 'CPU'
     self.QUEUE_DEV = self.DEV
-    self.adapter = get_model_adapter(jits, cam_w, cam_h, self.DEV, self.QUEUE_DEV, self.WARP_DEV, self.chestnut)
-    self.vision_output_slices = self.adapter.vision_output_slices
-    self.policy_output_slices = self.adapter.policy_output_slices
-    self._policy_slices_list = self.adapter._policy_slices_list
-    self._combined_model_type = self.adapter._combined_model_type
-    self._vision_input_names = self.adapter._vision_input_names
-    self.numpy_inputs = self.adapter.numpy_inputs
-    self._policy_keys = self.adapter._policy_keys
-    self._has_on_policy = self.adapter._has_on_policy
-    self._desire_key = self.adapter._desire_key
-    self._road_key = self.adapter._road_key
-    self._wide_key = self.adapter._wide_key
-    self.frame_buf_params = self.adapter.frame_buf_params
+    self.is_run_model = 'run_model' in jits
+
+    nv12_info = get_nv12_info(cam_w, cam_h)
+    self.frame_copy_size = nv12_copy_size(*nv12_info[:3])
+    self.full_frames: dict = {}
+    self._blob_cache: dict = {}
+    self.frame_buffers: dict = {}
+
+    if self.is_run_model or 'model' in metadata:
+      model_metadata = metadata.get('model', metadata)
+      self.input_shapes = model_metadata['input_shapes']
+      self.vision_output_slices = model_metadata['output_slices']
+      self.policy_output_slices = {}
+      self._policy_slices_list = []
+      self._combined_model_type = 'supercombo'
+      self._vision_input_names = [key for key in self.input_shapes if 'img' in key]
+      self.frame_skip = derive_frame_skip({}, self.input_shapes)
+      if self.is_run_model:
+        self.input_queues, self.numpy_inputs, self.frame_buffers = make_stock_input_queues(
+          self.input_shapes, self.frame_skip, device=self.DEV, frame_copy_size=self.frame_copy_size)
+        self.frame_views, self.npy = self.frame_buffers, self.numpy_inputs
+        self.run_model, self.run_policy, self.warp = jits['run_model'][(cam_w, cam_h)], None, None
+      else:
+        self.input_queues, self.numpy_inputs = make_supercombo_input_queues(self.input_shapes, self.frame_skip, device=self.QUEUE_DEV)
+        self.run_model, self.run_policy, self.warp = None, jits['run_policy'], jits[(cam_w, cam_h)]
+    else:
+      self.run_model, self.run_policy, self.warp = None, jits['run_policy'], jits[(cam_w, cam_h)]
+      vision_metadata = metadata['vision']
+      policy_keys = [k for k in metadata if k not in ('vision', 'warp_dev')]
+      self._combined_model_type = 'split' if policy_keys == ['policy'] else 'multi_policy'
+      self.vision_output_slices = vision_metadata['output_slices']
+      self._policy_keys = policy_keys
+      self._policy_slices_list = [metadata[k]['output_slices'] for k in policy_keys]
+      self.policy_output_slices = self._policy_slices_list[0]
+      self._has_on_policy = any('on' in k.lower() for k in policy_keys)
+      self._vision_input_names = [key for key in vision_metadata['input_shapes'] if 'img' in key]
+      first_policy_meta = metadata[policy_keys[0]]
+      frame_skip = derive_frame_skip(vision_metadata['input_shapes'], first_policy_meta['input_shapes'])
+      self.input_queues, self.numpy_inputs = make_split_input_queues(vision_metadata['input_shapes'],
+                                                                     first_policy_meta['input_shapes'],
+                                                                     frame_skip, device=self.QUEUE_DEV)
+
+    self._desire_key = next(key for key in self.numpy_inputs if key.startswith('desire'))
+    self._road_key = next(key for key in self._vision_input_names if 'big' not in key)
+    self._wide_key = next(key for key in self._vision_input_names if 'big' in key)
+    self.frame_buf_params = dict.fromkeys(self._vision_input_names, nv12_info)
 
     is_20hz = bundle.is20hz if bundle else self._combined_model_type in ('split', 'multi_policy')
     if is_20hz:
@@ -137,10 +179,26 @@ class ModelState(ModelStateBase):
     self.parser = Parser()
     self.prev_desire = np.zeros(self.constants.DESIRE_LEN, dtype=np.float32)
 
+    if self.warp is not None:
+      self.full_frames = {k: Tensor(np.zeros(nv12_info[3], dtype=np.uint8), device=self.WARP_DEV).contiguous().realize() for k in self._vision_input_names}
+      self.warp(**{k: self.input_queues[k] for k in WARP_INPUTS}, frame=self.full_frames[self._road_key], big_frame=self.full_frames[self._wide_key])
+
   def warmup(self) -> None:
-    dummy_frames, transforms, dummy_inputs = self.adapter.get_dummy_inputs()
+    dummy_size = self.frame_copy_size if self.is_run_model else self.frame_buf_params[self._road_key][3]
+    dummy_frames = {k: np.zeros(dummy_size, dtype=np.uint8) for k in self._vision_input_names}
+    transforms = {k: np.eye(3, dtype=np.float32) for k in [self._road_key, self._wide_key] if k}
+    dummy_inputs = {k: np.zeros(v.shape, dtype=v.dtype) for k, v in self.numpy_inputs.items() if k not in ['tfm', 'big_tfm', 'prev_feat']}
     self.run(dummy_frames, transforms, dummy_inputs)
-    self.adapter.reset_warmup_buffers()
+    if self.is_run_model:
+      self.input_queues, self.numpy_inputs, self.frame_buffers = make_stock_input_queues(
+        self.input_shapes, self.frame_skip, device=self.DEV, frame_copy_size=self.frame_copy_size)
+      self.frame_views = self.frame_buffers
+      self.npy = self.numpy_inputs
+    else:
+      for v in self.numpy_inputs.values():
+        v[:] = 0
+      self.full_frames.clear()
+      self._blob_cache.clear()
     self.prev_desire[:] = 0
 
   @property
@@ -158,27 +216,37 @@ class ModelState(ModelStateBase):
   def run(self, bufs: dict[str, VisionBuf], transforms: dict[str, np.ndarray],
           inputs: dict[str, np.ndarray],
           after_enqueue: Callable[[], None] | None = None) -> dict[str, np.ndarray] | None:
-    self.adapter.copy_frames(bufs)
+    if self.is_run_model:
+      for key, buf in bufs.items():
+        data = buf.data if hasattr(buf, 'data') else buf
+        np.copyto(self.frame_buffers[key], np.frombuffer(data, dtype=np.uint8, count=self.frame_copy_size))
+    else:
+      for key, buf in bufs.items():
+        ptr = np.frombuffer(buf.data, dtype=np.uint8).ctypes.data
+        cache_key = (key, ptr)
+        if cache_key not in self._blob_cache:
+          self._blob_cache[cache_key] = Tensor.from_blob(ptr, (self.frame_buf_params[key][3],), dtype='uint8', device=self.WARP_DEV)
+        self.full_frames[key] = self._blob_cache[cache_key]
 
     desire_key = self.desire_key
     inputs[desire_key][0] = 0
-    (self.numpy_inputs[desire_key].flat if self.adapter.is_native else self.numpy_inputs[desire_key])[:] = \
-      np.where(inputs[desire_key] - self.prev_desire > .99, inputs[desire_key], 0)
+    self.numpy_inputs[desire_key][:] = np.where(inputs[desire_key] - self.prev_desire > .99, inputs[desire_key], 0)
     self.prev_desire[:] = inputs[desire_key]
 
     for key in ('traffic_convention', 'lateral_control_params', 'action_t'):
       if key in self.numpy_inputs and key in inputs:
         self.numpy_inputs[key][:] = inputs[key]
 
-    if self.adapter.is_native:
-      for i, key in enumerate(self._vision_input_names):
-        if key in transforms:
-          self.numpy_inputs['tfm'][i] = transforms[key].reshape(3, 3)
-    else:
-      self.numpy_inputs['tfm'][:, :] = transforms[self._road_key].reshape(3, 3)
-      self.numpy_inputs['big_tfm'][:, :] = transforms[self._wide_key].reshape(3, 3)
+    self.numpy_inputs['tfm'][:, :] = transforms[self._road_key].reshape(3, 3)
+    self.numpy_inputs['big_tfm'][:, :] = transforms[self._wide_key].reshape(3, 3)
 
-    raw_outputs = self.adapter.run()
+    if self.run_model is not None:
+      outs, = self.run_model(**{k: self.input_queues[k] for k in MODELD_INPUTS})
+      raw_outputs = outs
+    else:
+      assert self.warp is not None and self.run_policy is not None
+      warped = self.warp(**{k: self.input_queues[k] for k in WARP_INPUTS}, frame=self.full_frames[self._road_key], big_frame=self.full_frames[self._wide_key])
+      raw_outputs = self.run_policy(**{k: self.input_queues[k] for k in POLICY_INPUTS if k in self.input_queues}, warped=warped)
 
     if after_enqueue is not None:
       after_enqueue()
@@ -190,25 +258,24 @@ class ModelState(ModelStateBase):
       sliced = {k: model_output[np.newaxis, v] for k, v in self.vision_output_slices.items()}
       outputs = self.parser.parse_outputs(sliced)
       if 'prev_feat' in self.numpy_inputs and 'hidden_state' in self.vision_output_slices:
-        (self.numpy_inputs['prev_feat'].flat if self.adapter.is_native else self.numpy_inputs['prev_feat'])[:] = \
-          model_output[self.vision_output_slices['hidden_state']]
+        self.numpy_inputs['prev_feat'][:] = model_output[self.vision_output_slices['hidden_state']]
     else:
       vision_output = raw_outputs[0].numpy().flatten()
       vision_sliced = {k: vision_output[np.newaxis, v] for k, v in self.vision_output_slices.items()}
       outputs = self.parser.parse_vision_outputs(vision_sliced)
 
       if 'prev_feat' in self.numpy_inputs and 'hidden_state' in self.vision_output_slices:
-        (self.numpy_inputs['prev_feat'].flat if self.adapter.is_native else self.numpy_inputs['prev_feat'])[:] = \
-          vision_output[self.vision_output_slices['hidden_state']]
+        self.numpy_inputs['prev_feat'][:] = vision_output[self.vision_output_slices['hidden_state']]
 
       for i, policy_slices in enumerate(self._policy_slices_list):
         policy_output = raw_outputs[i + 1].numpy().flatten()
         policy_sliced = {k: policy_output[np.newaxis, v] for k, v in policy_slices.items()}
         parsed = self.parser.parse_policy_outputs(policy_sliced)
-        if 'off' in self._policy_keys[i] and self._has_on_policy:
-          for key in ('plan', 'planplus', 'action'):
-            if any(key in self._policy_slices_list[j] for j, k in enumerate(self._policy_keys) if 'on' in k.lower()):
-              parsed.pop(key, None)
+        if ('off' in self._policy_keys[i]
+          and self._has_on_policy
+          and any('plan' in self._policy_slices_list[j] for j, k in enumerate(self._policy_keys) if 'on' in k.lower())):
+
+          parsed.pop('plan', None)
 
         outputs.update(parsed)
 
@@ -251,14 +318,14 @@ class ModelState(ModelStateBase):
 def main(demo=False):
   cloudlog.warning("modeld init")
 
+  sentry.set_tag("daemon", PROCESS_NAME)
   cloudlog.bind(daemon=PROCESS_NAME)
   setproctitle(PROCESS_NAME)
   config_realtime_process(7, 54)
 
   CHESTNUT = chestnut_present()
   if CHESTNUT:
-    from tinygrad.runtime.ops_amd import AMDDevice
-    AMDDevice.wait_timeout_ms = 3000
+    os.environ['HCQDEV_WAIT_TIMEOUT_MS'] = '3000'
 
   params = Params()
   params.put_bool("ChestnutLoading", CHESTNUT)
@@ -305,7 +372,11 @@ def main(demo=False):
     loader.start()
     loader.join(BIG_MODEL_TIMEOUT)
     model = big_model
+    if model is None:
+      params.put_bool("ChestnutModelError", True)
     params.put_bool("ChestnutActive", model is not None)
+    if model is not None:
+      params.remove("ChestnutModelError")
 
   small_model = ModelState(cam_w=vipc_client_main.width, cam_h=vipc_client_main.height, chestnut=False) if model is None or CHESTNUT else None
   if model is None:
@@ -315,12 +386,12 @@ def main(demo=False):
   cloudlog.warning(f"models loaded in {time.monotonic() - st:.1f}s, modeld starting")
 
   # messaging
-  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutGpuState"] if CHESTNUT else [])
+  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutState"] if CHESTNUT else [])
   pm = PubMaster(pub_socks)
   sm = SubMaster(["deviceState", "carState", "narrowRoadCameraState", "extrinsicsCalibration", "driverMonitoringState", "carControl", "lateralDelay"])
 
   publish_state = PublishState()
-  chestnut_state = ChestnutGpuState(pm, model.chestnut) if CHESTNUT else None
+  chestnut_state = ChestnutState(pm, model.chestnut) if CHESTNUT else None
 
   # setup filter to track dropped frames
   frame_dropped_filter = FirstOrderFilter(0., 10., 1. / model.constants.MODEL_FREQ)
@@ -442,12 +513,13 @@ def main(demo=False):
     mt1 = time.perf_counter()
     try:
       send_chestnut = (chestnut_state is not None and
-                       run_count % round(model.constants.MODEL_FREQ / SERVICE_LIST['chestnutGpuState'].frequency) == 0)
+                       run_count % round(model.constants.MODEL_FREQ / SERVICE_LIST['chestnutState'].frequency) == 0)
       model_output = model.run(bufs, transforms, inputs, chestnut_state.send if send_chestnut else None)
     except Exception:
       if not params.get_bool("ChestnutActive"):
         raise
-      cloudlog.exception("big model failed, fall back to small")
+      cloudlog.exception("chestnut failed, falling back to small")
+      params.put_bool("ChestnutModelError", True)
       params.put_bool("ChestnutActive", False)
       assert small_model is not None
       model = small_model
@@ -479,7 +551,6 @@ def main(demo=False):
       DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob, left_edge, right_edge)
       modelv2_send.modelV2.meta.laneChangeState = DH.lane_change_state
       modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
-      mdv2sp_send.valid = modelv2_send.valid
       mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction
       drivingdata_send.drivingModelData.meta.laneChangeState = DH.lane_change_state
       drivingdata_send.drivingModelData.meta.laneChangeDirection = DH.lane_change_direction
@@ -501,5 +572,5 @@ if __name__ == "__main__":
   except KeyboardInterrupt:
     cloudlog.warning(f"child {PROCESS_NAME} got SIGINT")
   except Exception:
-    cloudlog.exception("modeld exception")
+    sentry.capture_exception()
     raise

openpilot/sunnypilot/modeld_v2/models/big_driving_warp_1344x760_tinygrad.pkl

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

openpilot/sunnypilot/modeld_v2/models/big_driving_warp_1928x1208_tinygrad.pkl

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