sunnydrived

models: add a refresh models button to mici, gate and show progress on both panels

Adds the refresh-models tile to the mici models panel (it was missing there),
factoring the sync-key trigger + in-progress check into refresh_model_list()
and refresh_in_progress() shared with the big UI.

On both UIs the refresh button is now gated on offroad + not-downloading +
not-refreshing (the manager runs offroad-only and its per-tick manifest fetch
sits above a blocking download loop, so a refresh queued in either state would
stick), and shows progress while the manager refetches: mici shows "fetching..."
on the tile, the big UI flips its button from REFRESH to "FETCHING..." to match
its FETCHING.../SELECT/CLEAR label style (as in the OSM panel), replacing the
old fire-and-forget popup.


Claude-Session: https://claude.ai/code/session_01EGMnVnSk5inGTrd7kuDVG9

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: James Vecellio-Grant <159560811+Discountchubbs@users.noreply.github.com>

.github/release-drafter.yml

@@ -1,43 +0,0 @@
-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,6 +20,11 @@ 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:
@@ -34,7 +39,6 @@ jobs:
       - name: Checkout sunnypilot repo
         uses: actions/checkout@v4
         with:
-          repository: sunnypilot/sunnypilot
           path: sunnypilot
           submodules: recursive
 
@@ -47,10 +51,10 @@ jobs:
           echo "tinygrad_ref=$ref" >> $GITHUB_OUTPUT
           echo "tinygrad_ref is $ref"
 
-      - name: Checkout docs repo (sunnypilot-models, gh-pages)
+      - name: Checkout docs repo (gh-pages)
         uses: actions/checkout@v4
         with:
-          repository: sunnypilot/sunnypilot-models
+          repository: ${{ inputs.docs_repo }}
           ref: gh-pages
           path: docs
           ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}
@@ -118,6 +122,7 @@ 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
@@ -162,6 +167,7 @@ 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-single-tinygrad-model.yaml

@@ -39,6 +39,11 @@ 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
@@ -107,6 +112,11 @@ 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
@@ -136,7 +146,7 @@ jobs:
       - name: Checkout docs repo
         uses: actions/checkout@v4
         with:
-          repository: sunnypilot/sunnypilot-models
+          repository: ${{ inputs.docs_repo }}
           ref: gh-pages
           path: docs
           ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}

.github/workflows/release-drafter.yml

@@ -1,28 +0,0 @@
-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/test-discourse.yaml.yml

@@ -1,78 +0,0 @@
-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

@@ -0,0 +1,79 @@
+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 Chunks in Parallel
+        run: |
+          mkdir -p /tmp/model_chunks
+          echo '${{ toJson(matrix.artifact.chunks) }}' > chunks.json
+
+          BASE_URL="${{ matrix.artifact.download_uri.url }}"
+          export BASE_DIR=$(dirname "$BASE_URL")
+
+          python3 -c '
+          import json, os
+          with open("chunks.json") as f:
+            chunks = json.load(f)
+          manifest_path = f"/tmp/model_chunks/${{ matrix.artifact.file_name }}.chunkmanifest"
+          with open(manifest_path, "w") as f:
+            f.write(str(len(chunks)))
+          base_dir = os.environ["BASE_DIR"]
+          with open("/tmp/curl_config.txt", "w") as f:
+            for c in chunks:
+              fn = c["file_name"]
+              f.write(f"url = \"{base_dir}/{fn}\"\noutput = \"/tmp/model_chunks/{fn}\"\n")
+          '
+          curl -Z --parallel-immediate --parallel-max 16 -s -S -f -L -K /tmp/curl_config.txt
+
+      - name: Run Model Compatibility Test
+        env:
+          MODEL_BASE_NAME: ${{ matrix.artifact.file_name }}
+          MODEL_CHUNK_DIR: "/tmp/model_chunks"
+          PYTHONPATH: ".:./tinygrad_repo"
+        run: |
+          python3 -m pytest openpilot/sunnypilot/modeld_v2/tests/test_models.py

openpilot/common/params_keys.h

@@ -162,6 +162,10 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"DeviceBootMode", {PERSISTENT | BACKUP, INT, "0"}},
     {"DevUIInfo", {PERSISTENT | BACKUP, INT, "0"}},
     {"EnableCopyparty", {PERSISTENT | BACKUP, BOOL}},
+    {"SunnydriveEnabled", {PERSISTENT | BACKUP, BOOL}},
+    {"SunnydriveAutoPairPrompt", {PERSISTENT | BACKUP, BOOL, "1"}},
+    {"SunnydrivePairedClients", {PERSISTENT, JSON}},
+    {"SunnydrivePairingRequests", {CLEAR_ON_MANAGER_START, JSON}},
     {"EnableGithubRunner", {PERSISTENT | BACKUP, BOOL}},
     {"GreenLightAlert", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"GithubRunnerSufficientVoltage", {CLEAR_ON_MANAGER_START , BOOL}},

openpilot/selfdrive/modeld/modeld.py

@@ -474,6 +474,7 @@ 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
 
       fill_driving_model_data(drivingdata_send, modelv2_send)

openpilot/selfdrive/selfdrived/selfdrived.py

@@ -154,7 +154,7 @@ class SelfdriveD(CruiseHelper):
     self.state_machine = StateMachine()
     self.rk = Ratekeeper(100, print_delay_threshold=None)
 
-    self.ignored_processes = {'mapd', }
+    self.ignored_processes = {'mapd', 'sunnydrived'}
 
     # Determine startup event
     is_remote = build_metadata.openpilot.comma_remote or build_metadata.openpilot.sunnypilot_remote

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

@@ -4,7 +4,6 @@ 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
@@ -13,7 +12,8 @@ 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, queued_name
+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.system.ui.lib.multilang import tr
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.widgets import DialogResult, Widget
@@ -21,7 +21,6 @@ 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
@@ -40,6 +39,9 @@ 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
 
@@ -67,15 +69,14 @@ 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"), 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.refresh_item = button_item(tr("Refresh Model List"),
+                                    lambda: tr("FETCHING...") if self._refreshing else tr("REFRESH"), "",
+                                    self._refresh_models)
 
     self.clear_cache_item = ListItemSP(
       title=tr("Clear Model Cache"),
       description="",
-      action_item=NoElideButtonAction(tr("CLEAR")),
+      action_item=NoElideButtonAction(lambda: tr("CLEARING...") if self._clearing else tr("CLEAR")),
       callback=self._clear_cache
     )
 
@@ -115,39 +116,38 @@ 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", "0.2"))
+      sw = float(ui_state.params.get("LagdToggleDelay", return_default=True))
       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():
-    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)
+    return model_cache_size_mb()
 
   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)
 
-    if (current_time := time.monotonic()) - self.last_cache_calc_time > 0.5:
+    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:
       self.last_cache_calc_time = current_time
       self.clear_cache_item.action_item.set_value(f"{self.calculate_cache_size():.2f} MB")
 
@@ -345,6 +345,13 @@ 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/mici/layouts/models.py

@@ -4,15 +4,18 @@ 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 BigDialog
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigConfirmationDialog, 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_info, queued_name)
+                                                           default_model_name, model_cache_size_mb, model_info, queued_name,
+                                                           refresh_in_progress, refresh_model_list)
 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
@@ -81,10 +84,18 @@ 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.main_items = [self.current_model_info, self.select_model_btn, self.cancel_download_btn]
+    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._scroller.add_widgets(self.main_items)
 
   @property
@@ -162,6 +173,15 @@ 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
@@ -205,6 +225,21 @@ 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/settings.py

@@ -4,6 +4,10 @@ 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 math
+
+import pyray as rl
+
 from openpilot.selfdrive.ui.mici.layouts.settings import settings as OP
 from openpilot.selfdrive.ui.mici.layouts.settings.settings import SettingsBigButton
 from openpilot.selfdrive.ui.mici.layouts.settings.device import DeviceLayoutMici
@@ -11,6 +15,7 @@ from openpilot.selfdrive.ui.mici.widgets.button import BigCircleButton
 from openpilot.selfdrive.ui.mici.widgets.dialog import BigConfirmationDialog, BigDialog
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.sunnylink import SunnylinkLayoutMici
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.models import ModelsLayoutMici
+from openpilot.selfdrive.ui.sunnypilot.mici.layouts.sunnydrive import SunnydriveLayoutMici
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.multilang import tr
@@ -29,6 +34,40 @@ class SunnylinkBigButton(SettingsBigButton):
     return 56
 
 
+def sunnydrive_icon(width, height):
+  """The sunnydrive icon (a sun over a car roof), drawn once in code so it needs no image asset.
+  Drawn at 4x on a 336x312 grid, then scaled down for smooth edges."""
+  s = 4
+  img = rl.gen_image_color(336 * s, 312 * s, rl.BLANK)
+  p = rl.ffi.addressof(img)
+
+  def dot(x, y, r, color):
+    rl.image_draw_circle(p, int(x * s), int(y * s), int(r * s), color)
+
+  def roof(r, color):   # a shallow circular arc, apex under the sun, ends reaching down beside the wheels
+    for i in range(-52, 53):
+      t = math.radians(i)
+      dot(168 + 194 * math.sin(t), 399 - 194 * math.cos(t), r, color)
+
+  dot(168, 100, 100, rl.WHITE)   # the sun
+  roof(28, rl.BLANK)            # a gap between the sun and the roof
+  roof(14, rl.WHITE)            # the roof
+  rl.image_draw_rectangle(p, 70 * s, 284 * s, 196 * s, 28 * s, rl.WHITE)   # the car's body between its wheels
+  for x in (84, 252):
+    dot(x, 300, 18, rl.WHITE)
+    dot(x, 300, 11, rl.BLANK)   # wheel
+  rl.image_resize(p, width, height)
+  texture = rl.load_texture_from_image(img)
+  rl.unload_image(img)
+  rl.set_texture_filter(texture, rl.TextureFilter.TEXTURE_FILTER_BILINEAR)
+  return texture
+
+
+class SunnydriveBigButton(SettingsBigButton):
+  def _get_label_font_size(self):
+    return 54   # "sunnydrive" wraps under the icon at 64
+
+
 class SettingsLayoutSP(OP.SettingsLayout):
   def __init__(self):
     OP.SettingsLayout.__init__(self)
@@ -50,6 +89,10 @@ class SettingsLayoutSP(OP.SettingsLayout):
     models_btn = SettingsBigButton(tr("models"), "", gui_app.texture("../../sunnypilot/selfdrive/assets/offroad/icon_models.png", ICON_SIZE, ICON_SIZE))
     models_btn.set_click_callback(lambda: gui_app.push_widget(models_panel))
 
+    sunnydrive_panel = SunnydriveLayoutMici()
+    sunnydrive_btn = SunnydriveBigButton(tr("sunnydrive"), "", sunnydrive_icon(64, 59))
+    sunnydrive_btn.set_click_callback(lambda: gui_app.push_widget(sunnydrive_panel))
+
     # onroad: enable button sits at the front (left of toggles)
     self._enable_offroad_btn_onroad = BigCircleButton(self.icon_offroad_enable, red=True)
     self._enable_offroad_btn_onroad.set_click_callback(lambda: self._handle_always_offroad(True))
@@ -72,6 +115,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
     # front slots (only one ever visible at a time): exit-always-offroad, then enable-onroad
     items.insert(0, self._enable_offroad_btn_onroad)
     items.insert(0, self._disable_offroad_btn)
+    items.insert(0, sunnydrive_btn)
     # end slot: enable-offroad (right of developer)
     items.append(self._enable_offroad_btn_offroad)
 

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

@@ -0,0 +1,71 @@
+import time
+
+from openpilot.selfdrive.ui.mici.widgets.button import BigButton, BigParamControl
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigConfirmationDialog
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.sunnypilot.sunnydrive import pairing
+from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.widgets.scroller import NavScroller
+
+
+class SunnydriveLayoutMici(NavScroller):
+  def __init__(self):
+    super().__init__()
+    self._pending_id = ""
+    self._prompted_id = ""
+    self._approval_dialog = None
+    self._opened_for_prompt = False
+    self._next_prompt_check = 0.0
+    self._enable = BigParamControl("enabled", "SunnydriveEnabled")
+    self._pairing_prompts = BigParamControl("allow pairing", "SunnydriveAutoPairPrompt")
+    self._unpair = BigButton("paired phones", "none")
+    self._unpair.set_click_callback(self._confirm_unpair_all)
+    self._scroller.add_widgets([self._enable, self._pairing_prompts, self._unpair])
+    gui_app.add_nav_stack_tick(self._pairing_tick)
+
+  def _update_state(self):
+    super()._update_state()
+    self._enable.refresh()
+    self._pairing_prompts.refresh()
+    requests = pairing.pairing_requests()
+    pending = next(((request_id, request) for request_id, request in reversed(list(requests.items())) if request.get("status") == "pending"), None)
+    self._pending_id = pending[0] if pending else ""
+    count = len(pairing.paired_clients())
+    self._unpair.set_value(f"{count} paired" if count else "none")
+    self._unpair.set_visible(count > 0)
+
+  def _pairing_tick(self):
+    if time.monotonic() < self._next_prompt_check:
+      return
+    self._next_prompt_check = time.monotonic() + 0.5
+    if not ui_state.params.get_bool("SunnydriveAutoPairPrompt"):
+      return
+    requests = reversed(list(pairing.pairing_requests().items()))
+    pending = next(((request_id, request) for request_id, request in requests if request.get("status") == "pending"), None)
+    answered = not pending or pending[0] == self._prompted_id   # approved, expired, or its slide was dismissed
+    if self._opened_for_prompt and answered and gui_app.get_active_widget() is self:   # back to whatever was showing
+      self._opened_for_prompt = False
+      self.dismiss()
+    if pending and self._prompted_id != pending[0]:
+      self._pending_id = self._prompted_id = pending[0]
+      if self._approval_dialog and gui_app.widget_in_stack(self._approval_dialog):
+        self._approval_dialog.dismiss(self._confirm_pending)
+      else:
+        self._confirm_pending()
+
+  def _confirm_pending(self):
+    if not self._pending_id or (self._approval_dialog and gui_app.widget_in_stack(self._approval_dialog)):
+      return
+    request_id = self._pending_id
+    icon = gui_app.texture("icons_mici/settings/device/pair.png", 64, 64)
+    if not gui_app.widget_in_stack(self):
+      # The screen right under a dialog keeps handling touches, and onroad that's the driving view,
+      # whose swipe-left bookmark is the same gesture as this slider. Showing this panel underneath keeps it out.
+      gui_app.push_widget(self)
+      self._opened_for_prompt = True
+    self._approval_dialog = BigConfirmationDialog("slide to approve phone", icon, lambda: pairing.approve_request(request_id))
+    gui_app.push_widget(self._approval_dialog)
+
+  def _confirm_unpair_all(self):
+    icon = gui_app.texture("icons_mici/settings/network/new/trash.png", 54, 64)
+    gui_app.push_widget(BigConfirmationDialog("slide to unpair all phones", icon, lambda: pairing.unpair(), red=True))

openpilot/selfdrive/ui/sunnypilot/model_info.py

@@ -4,12 +4,28 @@ 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,
@@ -83,3 +99,22 @@ 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/sunnypilot/modeld_v2/camera_offset_helper.py

@@ -15,11 +15,19 @@ class CameraOffsetHelper:
     self.actual_camera_offset = 0.0
 
   @staticmethod
-  def apply_camera_offset(model_transform, intrinsics, height, offset_param):
+  def get_v_horizon(intrinsics, rpy_calib):
     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 * cy
+    shear[0, 2] = -offset_param / height * v_horizon
     model_transform = (shear @ model_transform).astype(np.float32)
     return model_transform
 
@@ -30,10 +38,13 @@ 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
-    model_transform_main = self.apply_camera_offset(model_transform_main, intrinsics_main, height, self.actual_camera_offset)
+    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)
 
     intrinsics_extra = dc.wide_road.intrinsics
-    model_transform_extra = self.apply_camera_offset(model_transform_extra, intrinsics_extra, height, self.actual_camera_offset)
+    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)
     return model_transform_main, model_transform_extra

openpilot/sunnypilot/modeld_v2/helpers.py

@@ -0,0 +1,100 @@
+"""
+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 io
+import struct
+import pickle
+import inspect
+import importlib
+import enum
+
+
+def _pad_args(func, args, kwargs):
+  try:
+    sig = inspect.signature(func)
+  except Exception:
+    return args, kwargs
+  params = list(sig.parameters.values())
+  if inspect.isfunction(func) and params and params[0].name in ('cls', 'self'):
+    params = params[1:]
+
+  new_args = list(args)
+  has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params)
+  if len(new_args) > len(params) and not has_varargs:
+    new_args = new_args[:len(params)]
+
+  for i in range(len(new_args), len(params)):
+    param = params[i]
+    if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+      continue
+    val = param.default if param.default is not inspect.Parameter.empty else None
+    new_args.append(val)
+  return new_args, kwargs
+
+
+def _enum_factory(enum_class):
+  def factory(*args, **kwargs):
+    try:
+      return enum_class(*args, **kwargs)
+    # OptOps and UOp objects in the .pkl are left over from the compilation phase,
+    # reassignment does nothing because they aren't tied to the execution graph
+    # It never executes or evaluates the UOp nodes again.
+    except ValueError:
+      return list(enum_class)[0]
+  factory.__name__ = enum_class.__name__
+  factory.__module__ = enum_class.__module__
+  return factory
+
+
+def _dynamic_factory(real_class):
+  if isinstance(real_class, type) and issubclass(real_class, enum.Enum):
+    return _enum_factory(real_class)
+
+  def factory(*args, **kwargs):
+    try:
+      return real_class(*args, **kwargs)
+    except TypeError:
+      new_args, new_kwargs = _pad_args(real_class, args, kwargs)
+      return real_class(*new_args, **new_kwargs)
+
+  class DynamicMeta(type(real_class)):
+    def __call__(cls, *args, **kwargs):
+      return factory(*args, **kwargs)
+
+  class DynamicProxy(real_class, metaclass=DynamicMeta):
+    __slots__ = ()
+
+    def __new__(cls, *args, **kwargs):
+      return factory(*args, **kwargs)
+
+  DynamicProxy.__name__ = real_class.__name__
+  DynamicProxy.__module__ = real_class.__module__
+  return DynamicProxy
+
+
+class DynamicTinygradUnpickler(pickle.Unpickler):
+  def find_class(self, module, name):
+    if module == "tinygrad.ops":
+      try:
+        importlib.import_module("tinygrad.uops")
+        module = "tinygrad.uops"
+      except ImportError:
+        pass
+    real_class = getattr(importlib.import_module(module), name)
+    if module.startswith("tinygrad"):
+      return _dynamic_factory(real_class)
+    return real_class
+
+
+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 DynamicTinygradUnpickler(io.BytesIO(opcodes), buffers=buffers()).load()

openpilot/sunnypilot/modeld_v2/modeld.py

@@ -17,7 +17,7 @@ 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, load_oob
+from openpilot.selfdrive.modeld.helpers import chestnut_present
 from openpilot.cereal import log
 from opendbc.car.structs import car
 from openpilot.cereal.services import SERVICE_LIST
@@ -52,6 +52,7 @@ from openpilot.sunnypilot.modeld_v2.compile_modeld import (derive_frame_skip, ma
                                                            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_oob
 from openpilot.sunnypilot.models.helpers import get_active_bundle
 from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
 
@@ -551,6 +552,7 @@ 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

openpilot/sunnypilot/modeld_v2/tests/test_camera_offset_helper.py

@@ -6,8 +6,9 @@ See the LICENSE.md file in the root directory for more details.
 """
 import numpy as np
 
-from openpilot.common.transformations.camera import DEVICE_CAMERAS
+from openpilot.common.transformations.camera import DEVICE_CAMERAS, view_frame_from_device_frame
 from openpilot.common.transformations.model import get_warp_matrix
+from openpilot.common.transformations.orientation import rot_from_euler
 from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
 from openpilot.common.test import OpenpilotTestCase
 
@@ -46,29 +47,50 @@ class TestCameraOffset(OpenpilotTestCase):
     self.camera_offset.update(main_transform, extra_transform, sm, False)
     np.testing.assert_almost_equal(self.camera_offset.actual_camera_offset, 0.038)
 
-  def test_camera_offset_(self):
+  def test_apply_camera_offset(self):
     intrinsics = self.dc.narrow_road.intrinsics
+    v_horizon = CameraOffsetHelper.get_v_horizon(intrinsics, [])  # pitch = 0 fallback: v_horizon == cy
     transform = np.eye(3, dtype=np.float32)
     height = 1.22
     offset = 0.1
 
-    cy = intrinsics[1, 2]
     expected_shear = np.eye(3, dtype=np.float32)
     expected_shear[0, 1] = offset / height
-    expected_shear[0, 2] = -offset / height * cy
+    expected_shear[0, 2] = -offset / height * v_horizon
 
-    result = CameraOffsetHelper.apply_camera_offset(transform, intrinsics, height, offset)
+    result = CameraOffsetHelper.apply_camera_offset(transform, height, offset, v_horizon)
     np.testing.assert_array_almost_equal(result, expected_shear)
 
+  def test_v_horizon_empty_rpy(self):
+    intrinsics = self.dc.narrow_road.intrinsics
+    v_horizon = CameraOffsetHelper.get_v_horizon(intrinsics, [])
+    np.testing.assert_almost_equal(v_horizon, intrinsics[1, 2])
+
+  def test_v_horizon_projection(self):
+    intrinsics = self.dc.narrow_road.intrinsics
+    f, cy = intrinsics[1, 1], intrinsics[1, 2]
+
+    for pitch_deg in [6.0, -6.0, 0.0]:
+      rpy = [0.0, np.radians(pitch_deg), 0.0]
+      d_dev = rot_from_euler(rpy) @ np.array([1.0, 0.0, 0.0])
+      view = view_frame_from_device_frame @ d_dev
+      expected = cy + f * view[1] / view[2]
+
+      v_horizon = CameraOffsetHelper.get_v_horizon(intrinsics, rpy)
+      np.testing.assert_almost_equal(v_horizon, expected, decimal=4)
+
   def test_update(self):
+    height = 1.2
+    pitch = np.radians(-8.0)
+
     sm = MockStruct(
       deviceState=MockStruct(deviceType='mici'),
       narrowRoadCameraState=MockStruct(sensor='os04c10'),
-      extrinsicsCalibration=MockStruct(rpyCalib=[0.0, 0.0, 0.0], height=[1.22])
+      extrinsicsCalibration=MockStruct(rpyCalib=[0.0, pitch, 0.0], height=[height])
     )
     intrinsics_main = self.dc.narrow_road.intrinsics
     intrinsics_extra = self.dc.wide_road.intrinsics
-    device_from_calib_euler = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+    device_from_calib_euler = np.array(sm['extrinsicsCalibration'].rpyCalib, dtype=np.float32)
     main_transform = get_warp_matrix(device_from_calib_euler, intrinsics_main, False).astype(np.float32)
     extra_transform = get_warp_matrix(device_from_calib_euler, intrinsics_extra, True).astype(np.float32)
 
@@ -81,5 +103,13 @@ class TestCameraOffset(OpenpilotTestCase):
     main_out, extra_out = self.camera_offset.update(main_transform, extra_transform, sm, False)
     assert not np.array_equal(main_out, main_transform)
     assert not np.array_equal(extra_out, extra_transform)
-    assert main_out[0, 1] != 0.0
-    assert main_out[0, 2] != 0.0
+
+    # settle the low-pass filter
+    for _ in range(100):
+      main_out, extra_out = self.camera_offset.update(main_transform, extra_transform, sm, False)
+
+    # undo main_transform dot product to get shear matrix
+    shear = main_out @ np.linalg.inv(main_transform)
+    expected_v_horizon = intrinsics_main[1, 2] - intrinsics_main[1, 1] * np.tan(pitch)
+    np.testing.assert_almost_equal(shear[0, 1], self.camera_offset.actual_camera_offset / height, decimal=4)
+    np.testing.assert_almost_equal(shear[0, 2], -self.camera_offset.actual_camera_offset / height * expected_v_horizon, decimal=4)

openpilot/sunnypilot/modeld_v2/tests/test_models.py

@@ -0,0 +1,43 @@
+"""
+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 unittest
+from unittest.mock import patch
+from openpilot.common.file_chunker import open_file_chunked
+from openpilot.sunnypilot.modeld_v2.helpers import load_oob
+from tinygrad.device import Device
+
+
+class TestLegacyModels(unittest.TestCase):
+  def test_legacy_model_load(self):
+    base_name = os.environ.get("MODEL_BASE_NAME")
+    if not base_name:
+      raise unittest.SkipTest("MODEL_BASE_NAME env var not set, skipping integration test.")
+    chunk_dir = os.environ.get("MODEL_CHUNK_DIR", "/tmp/model_chunks")
+    base_path = os.path.join(chunk_dir, base_name)
+
+    try:
+      f = open_file_chunked(base_path)
+    except Exception as error:
+      self.fail(f"Failed to open chunked file {base_path}: {error}")
+    self.addCleanup(f.close)
+
+    real_getitem = Device.__class__.__getitem__
+
+    def safe_getitem(device_self, ix):
+      if ix == "QCOM" and not os.path.exists("/dev/kgsl-3d0"):
+        return real_getitem(device_self, "CPU")
+      if ix == "AMD" and not os.path.exists("/dev/kfd"):
+        return real_getitem(device_self, "CPU")
+      return real_getitem(device_self, ix)
+
+    with patch.object(Device.__class__, "__getitem__", safe_getitem):
+      obj = load_oob(f)
+
+    assert isinstance(obj, dict), "Parsed object is not a dictionary"
+    assert "metadata" in obj, "Metadata key is missing"

openpilot/sunnypilot/models/tests/test_tinygrad_ref.py

@@ -1,24 +0,0 @@
-import requests
-
-from openpilot.sunnypilot.models.tinygrad_ref import get_tinygrad_ref
-from openpilot.sunnypilot.models.fetcher import ModelFetcher
-from openpilot.common.test import OpenpilotTestCase
-
-def fetch_tinygrad_ref():
-  response = requests.get(ModelFetcher.MODEL_URL, timeout=10)
-  response.raise_for_status()
-  json_data = response.json()
-  return json_data.get("tinygrad_ref")
-
-
-class TestTinygradRef(OpenpilotTestCase):
-  def test_tinygrad_ref(self):
-    current_ref = get_tinygrad_ref()
-    remote_ref = fetch_tinygrad_ref()
-    assert remote_ref == current_ref, (
-      f"""tinygrad_repo ref does not match remote tinygrad_ref of current compiled driving models json.
-    Current: {current_ref}
-    Remote: {remote_ref}
-    Please run build-all workflow to update models."""
-    )
-    print("tinygrad_repo ref matches current compiled driving models json ref.")

openpilot/sunnypilot/sunnydrive/pairing.py

@@ -0,0 +1,132 @@
+"""Local Sunnydrive pairing shared by sunnydrived and the comma UI."""
+
+import hashlib
+import re
+import secrets
+import time
+from datetime import UTC, datetime
+
+from openpilot.common.params import Params
+
+
+PAIRED_KEY = "SunnydrivePairedClients"
+REQUESTS_KEY = "SunnydrivePairingRequests"
+PAIRING_SECONDS = 5 * 60
+CLIENT_ID_RE = re.compile(r"[A-Za-z0-9_-]{16,128}")
+
+
+def _params(params=None):
+  return params or Params()
+
+
+def _dict(params, key):
+  value = params.get(key)
+  return value if isinstance(value, dict) else {}
+
+
+def device_id(params=None):
+  params = _params(params)
+  return params.get("DongleId") or params.get("HardwareSerial") or "unregistered"
+
+
+def device_name(params=None):
+  identity = device_id(params)
+  return f"comma {identity[-8:]}" if identity != "unregistered" else "comma"
+
+
+def is_offroad(params=None):
+  return _params(params).get_bool("IsOffroad")
+
+
+def _require_allowed(params):
+  if not params.get_bool("SunnydriveAutoPairPrompt"):   # the comma's "allow pairing" switch
+    raise PermissionError("pairing is turned off on the comma")
+
+
+def paired_clients(params=None):
+  return _dict(_params(params), PAIRED_KEY)
+
+
+def is_paired(client_id, params=None):
+  return client_id in paired_clients(params)
+
+
+def authorized(token, params=None):
+  if not token:
+    return False
+  digest = hashlib.sha256(token.encode()).hexdigest()
+  return any(secrets.compare_digest(digest, str(client.get("token_hash", ""))) for client in paired_clients(params).values())
+
+
+def _pair(client_id, name, params):
+  if not CLIENT_ID_RE.fullmatch(client_id):
+    raise ValueError("invalid client id")
+  token = secrets.token_urlsafe(32)
+  clients = paired_clients(params)
+  clients[client_id] = {"name": str(name or "Sunnydrive phone")[:80], "token_hash": hashlib.sha256(token.encode()).hexdigest(),
+                        "paired_at": int(datetime.now(UTC).timestamp())}
+  params.put(PAIRED_KEY, clients, block=True)
+  return token
+
+
+def request_pairing(client_id, name, params=None):
+  if not CLIENT_ID_RE.fullmatch(client_id):
+    raise ValueError("invalid client id")
+  params = _params(params)
+  _require_allowed(params)
+  now = int(time.monotonic())
+  requests = {key: value for key, value in _dict(params, REQUESTS_KEY).items()
+              if int(value.get("expires", 0)) > now and value.get("client_id") != client_id}
+  request_id = secrets.token_urlsafe(18)
+  requests[request_id] = {"client_id": client_id, "name": str(name or "Sunnydrive phone")[:80], "status": "pending", "expires": now + PAIRING_SECONDS}
+  params.put(REQUESTS_KEY, requests, block=True)
+  return request_id
+
+
+def pairing_requests(params=None):
+  params = _params(params)
+  now = int(time.monotonic())
+  requests = _dict(params, REQUESTS_KEY)
+  fresh = {key: value for key, value in requests.items() if int(value.get("expires", 0)) > now}
+  if fresh != requests:
+    params.put(REQUESTS_KEY, fresh, block=True) if fresh else params.remove(REQUESTS_KEY)
+  return fresh
+
+
+def approve_request(request_id, params=None):
+  params = _params(params)
+  requests = pairing_requests(params)
+  request = requests.get(request_id)
+  if not request or request.get("status") != "pending":
+    return False
+  request["token"] = _pair(request["client_id"], request.get("name"), params)
+  request["status"] = "approved"
+  requests[request_id] = request
+  params.put(REQUESTS_KEY, requests, block=True)
+  return True
+
+
+def consume_request(request_id, params=None):
+  params = _params(params)
+  requests = pairing_requests(params)
+  request = requests.get(request_id)
+  if not request:
+    return {"status": "expired"}
+  result = {"status": request.get("status", "pending")}
+  if request.get("status") == "approved":
+    result["token"] = request.get("token", "")
+    requests.pop(request_id, None)
+    params.put(REQUESTS_KEY, requests, block=True) if requests else params.remove(REQUESTS_KEY)
+  return result
+
+
+def unpair(client_id=None, params=None):
+  params = _params(params)
+  clients = paired_clients(params)
+  if client_id is None:
+    params.remove(PAIRED_KEY)
+    return bool(clients)
+  removed = clients.pop(client_id, None) is not None
+  if removed:
+    params.put(PAIRED_KEY, clients, block=True) if clients else params.remove(PAIRED_KEY)
+  return removed

openpilot/sunnypilot/sunnydrive/test_sunnydrived.py

@@ -0,0 +1,172 @@
+import json
+import threading
+import time
+import unittest
+import unittest.mock
+from pathlib import Path
+from types import SimpleNamespace
+from tempfile import TemporaryDirectory
+from unittest.mock import patch
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+from openpilot.sunnypilot.sunnydrive import sunnydrived
+from openpilot.sunnypilot.sunnydrive import pairing
+from openpilot.sunnypilot.sunnydrive.sunnydrived import SunnydriveServer
+
+
+class SunnydriveApiTest(unittest.TestCase):
+  class FakeParams:
+    def __init__(self):
+      self.values = {"DongleId": "comma-test-12345678", "IsOffroad": True, "SunnydriveAutoPairPrompt": True}
+
+    def get(self, key):
+      return self.values.get(key)
+
+    def get_bool(self, key):
+      return bool(self.values.get(key))
+
+    def put(self, key, value, block=False):
+      self.values[key] = value
+
+    def remove(self, key):
+      self.values.pop(key, None)
+
+  def test_slide_approval_pairing(self):
+    params = self.FakeParams()
+    request = pairing.request_pairing("phone_abcdefghijklmnop", "Second phone", params)
+    replacement = pairing.request_pairing("phone_abcdefghijklmnop", "Second phone", params)
+    self.assertNotEqual(replacement, request)
+    request = replacement
+    self.assertEqual(len(pairing.pairing_requests(params)), 1)
+    self.assertTrue(pairing.approve_request(request, params))
+    approved = pairing.consume_request(request, params)
+    self.assertEqual(approved["status"], "approved")
+    self.assertTrue(pairing.authorized(approved["token"], params))
+    self.assertEqual(pairing.consume_request(request, params)["status"], "expired")
+
+    params.values["SunnydriveAutoPairPrompt"] = False
+    with self.assertRaisesRegex(PermissionError, "turned off"):
+      pairing.request_pairing("phone_switched_off_123456", "Off", params)
+    params.values["SunnydriveAutoPairPrompt"] = True
+
+    params.values["IsOffroad"] = False   # pairing works onroad too
+    self.assertTrue(pairing.approve_request(pairing.request_pairing("phone_onroad_123456789", "Onroad", params), params))
+
+  def test_subscribed_services_exist(self):   # a renamed service crashes the sample loop and freezes telemetry
+    from openpilot.cereal.services import SERVICE_LIST
+    self.assertEqual([name for name in sunnydrived.SERVICES if name not in SERVICE_LIST], [])
+
+  def test_discovery_is_metadata_only(self):
+    packet = sunnydrived.DISCOVERY_PREFIX + b'{"v":1,"nonce":"12345678","clientId":"phone_1234567890123456"}'
+    with patch.object(pairing, "device_id", return_value="comma-id"), \
+         patch.object(pairing, "device_name", return_value="comma test"), \
+         patch.object(pairing, "is_paired", return_value=False), \
+         patch.object(pairing, "is_offroad", return_value=True):
+      reply = sunnydrived.discovery_response(packet)
+    body = json.loads(reply[len(sunnydrived.DISCOVERY_PREFIX):])
+    self.assertEqual(set(body), {"v", "nonce", "deviceId", "name", "httpPort", "apiVersion", "paired", "offroad"})
+    self.assertNotIn("token", body)
+
+  def test_settings_follow_sunnylink_safety_rules(self):
+    with patch("openpilot.common.params.Params") as params_class, patch.object(sunnydrived, "_setting_engaged", return_value=False) as engaged:
+      params_class.return_value.get_bool.return_value = False
+      params_class.return_value.get_type.return_value = 1
+      sunnydrived.sunnylink_set("AlphaLongitudinalEnabled", True)
+      params_class.return_value.put.assert_called_once()
+      with self.assertRaisesRegex(PermissionError, "onroad or engaged"):
+        sunnydrived.sunnylink_set("Mads", True)
+      engaged.return_value = True
+      with self.assertRaisesRegex(PermissionError, "onroad or engaged"):
+        sunnydrived.sunnylink_set("AlphaLongitudinalEnabled", True)
+      params_class.return_value.put.assert_called_once()
+      params_class.return_value.get.return_value = b"1"   # TorqueParamsOverrideEnabled satisfies the schema's onroad alternative
+      params_class.return_value.get_type.return_value = 3
+      sunnydrived.sunnylink_set("TorqueParamsOverrideFriction", 0.1)
+      self.assertEqual(params_class.return_value.put.call_count, 2)
+      params_class.return_value.remove.assert_not_called()
+
+  def test_live_frames_start_at_keyframe(self):
+    def msg(key, data):
+      frame = SimpleNamespace(idx=SimpleNamespace(flags=0x8 if key else 0), header=b"H" if key else b"", data=data)
+      return SimpleNamespace(which=lambda: "livestreamCabinEncodeData", livestreamCabinEncodeData=frame)
+    params = unittest.mock.MagicMock()
+    with patch.object(sunnydrived.messaging, "sub_sock"), \
+         patch.object(sunnydrived.messaging, "recv_one", side_effect=[msg(False, b"p0"), None, msg(True, b"k1"), msg(False, b"p2")]):
+      frames = sunnydrived.live_frames("driver", params)
+      self.assertEqual([next(frames) for _ in range(3)], [None, (True, b"Hk1"), (False, b"p2")])
+    self.assertEqual([c.args for c in params.put_bool.call_args_list], [("LivestreamRequestKeyframe", True), ("LivestreamRequestKeyframe", False)])
+
+  def test_route_list_cache(self):
+    with TemporaryDirectory() as folder, patch.object(sunnydrived, "REALDATA", Path(folder)):
+      sunnydrived._connect_routes.cache_clear()
+      try:
+        self.assertEqual(sunnydrived.connect_routes(), [])
+        self.assertEqual(sunnydrived.connect_routes(), [])
+        self.assertEqual(sunnydrived._connect_routes.cache_info().hits, 1)
+      finally:
+        sunnydrived._connect_routes.cache_clear()
+
+  def test_api_only(self):
+    server = SunnydriveServer(("127.0.0.1", 0))
+    server.publish_telemetry({"timestampMs": 123})
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+      base = f"http://127.0.0.1:{server.server_address[1]}"
+      request = Request(base + "/telemetry", headers={"Origin": "https://ai.sunnypilot.sunnydrive"})
+      with urlopen(request, timeout=2) as response:
+        self.assertEqual(json.load(response), server.telemetry)
+        self.assertEqual(response.headers["Access-Control-Allow-Origin"], "https://ai.sunnypilot.sunnydrive")
+      with urlopen(base + "/telemetry/stream", timeout=2) as first, urlopen(base + "/telemetry/stream", timeout=2) as second:
+        self.assertEqual(first.readline(), b'data: {"timestampMs":123}\n')
+        self.assertEqual(second.readline(), b'data: {"timestampMs":123}\n')
+        first.readline()
+        second.readline()
+        server.publish_telemetry({"timestampMs": 456})
+        self.assertEqual(first.readline(), b'data: {"timestampMs":456}\n')
+        self.assertEqual(second.readline(), b'data: {"timestampMs":456}\n')
+      for path in ("/", "/index.html", "/replay", "/youtube-playlists"):
+        with self.assertRaises(HTTPError) as error:
+          urlopen(base + path, timeout=2)
+        self.assertEqual(error.exception.code, 404)
+    finally:
+      server.shutdown()
+      server.server_close()
+      thread.join(timeout=2)
+
+  def test_unpaired_phone_cannot_read_api(self):
+    server = SunnydriveServer(("127.0.0.1", 0), allow_loopback=False)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+      base = f"http://127.0.0.1:{server.server_address[1]}"
+      with patch.object(pairing, "authorized", return_value=False):
+        with self.assertRaises(HTTPError) as error:
+          urlopen(base + "/telemetry", timeout=2)
+        self.assertEqual(error.exception.code, 401)
+      with patch.object(pairing, "device_id", return_value="comma-id"), \
+           patch.object(pairing, "device_name", return_value="comma test"), \
+           patch.object(pairing, "is_paired", return_value=False), \
+           patch.object(pairing, "is_offroad", return_value=True):
+        with urlopen(base + "/pair/info?client_id=phone_1234567890123456", timeout=2) as response:
+          self.assertEqual(json.load(response)["deviceId"], "comma-id")
+      with patch.object(pairing, "authorized", return_value=True):
+        with urlopen(base + "/telemetry?auth=paired", timeout=2) as response:
+          self.assertIn("timestampMs", json.load(response))
+      with patch.object(pairing, "authorized", return_value=True) as authorized:   # unpairing cuts an open stream within a second
+        with urlopen(base + "/telemetry/stream?auth=paired", timeout=5) as stream:
+          self.assertTrue(stream.readline().startswith(b"data: "))
+          stream.readline()   # the event's blank line
+          authorized.return_value = False
+          time.sleep(1.1)
+          server.publish_telemetry({"timestampMs": 789})
+          self.assertEqual(stream.read(), b"")
+    finally:
+      server.shutdown()
+      server.server_close()
+      thread.join(timeout=2)
+
+
+if __name__ == "__main__":
+  unittest.main()

openpilot/system/manager/process_config.py

@@ -71,6 +71,9 @@ def livestream(started: bool, params: Params, CP: car.CarParams) -> bool:
 def use_copyparty(started, params, CP: car.CarParams) -> bool:
   return bool(params.get_bool("EnableCopyparty"))
 
+def sunnydrive_enabled(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return params.get_bool("SunnydriveEnabled")
+
 def sunnylink_ready_shim(started, params, CP: car.CarParams) -> bool:
   """Shim for sunnylink_ready to match the process manager signature."""
   return sunnylink_ready(params)
@@ -167,6 +170,7 @@ procs = [
 
 # sunnypilot
 procs += [
+  PythonProcess("sunnydrived", "openpilot.sunnypilot.sunnydrive.sunnydrived", sunnydrive_enabled),
   # Models
   PythonProcess("models_manager", "openpilot.sunnypilot.models.manager", only_offroad),
   NativeProcess("modeld_tinygrad", "openpilot/sunnypilot/modeld_v2", ["./modeld"], and_(only_onroad, is_tinygrad_model)),