sunnypilot v2026.002.000

version: sunnypilot v2026.002.000 (staging)
date: 2026-07-21T07:44:02
master commit: 2c334ede443d7391d27575af8c854a095ba702a8

openpilot/sunnypilot/mapd/__init__.py

@@ -0,0 +1,5 @@
+import os
+from openpilot.common.basedir import BASEDIR
+
+MAPD_BIN_DIR = os.path.join(BASEDIR, 'openpilot', 'third_party/mapd_pfeiferj')
+MAPD_PATH = os.path.join(MAPD_BIN_DIR, 'mapd')

openpilot/sunnypilot/mapd/live_map_data/__init__.py

@@ -0,0 +1,22 @@
+"""
+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.
+"""
+from openpilot.common.swaglog import cloudlog
+
+LOOK_AHEAD_HORIZON_TIME = 15.  # s. Time horizon for look ahead of turn speed sections to provide on liveMapDataSP msg.
+_DEBUG = False
+_CLOUDLOG_DEBUG = False
+ROAD_NAME_TIMEOUT = 30  # secs
+R = 6373000.0  # approximate radius of earth in mts
+QUERY_RADIUS = 3000  # mts. Radius to use on OSM data queries.
+QUERY_RADIUS_OFFLINE = 2250  # mts. Radius to use on offline OSM data queries.
+
+
+def get_debug(msg, log_to_cloud=True):
+  if _CLOUDLOG_DEBUG and log_to_cloud:
+    cloudlog.debug(msg)
+  if _DEBUG:
+    print(msg)

openpilot/sunnypilot/mapd/live_map_data/base_map_data.py

@@ -0,0 +1,65 @@
+"""
+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.
+"""
+from abc import abstractmethod, ABC
+
+import openpilot.cereal.messaging as messaging
+from openpilot.common.params import Params
+from openpilot.common.constants import CV
+from openpilot.selfdrive.car.cruise import V_CRUISE_UNSET
+from openpilot.sunnypilot.navd.helpers import coordinate_from_param
+
+MAX_SPEED_LIMIT = V_CRUISE_UNSET * CV.KPH_TO_MS
+
+
+class BaseMapData(ABC):
+  def __init__(self):
+    self.params = Params()
+
+    self.sm = messaging.SubMaster(['liveLocationKalman'])
+    self.pm = messaging.PubMaster(['liveMapDataSP'])
+
+    self.localizer_valid = False
+    self.last_bearing = None
+    self.last_position = coordinate_from_param("LastGPSPositionLLK", self.params)
+
+  @abstractmethod
+  def update_location(self) -> None:
+    pass
+
+  @abstractmethod
+  def get_current_speed_limit(self) -> float:
+    pass
+
+  @abstractmethod
+  def get_next_speed_limit_and_distance(self) -> tuple[float, float]:
+    pass
+
+  @abstractmethod
+  def get_current_road_name(self) -> str:
+    pass
+
+  def publish(self) -> None:
+    speed_limit = self.get_current_speed_limit()
+    next_speed_limit, next_speed_limit_distance = self.get_next_speed_limit_and_distance()
+
+    mapd_sp_send = messaging.new_message('liveMapDataSP')
+    mapd_sp_send.valid = self.sm['liveLocationKalman'].gpsOK
+    live_map_data = mapd_sp_send.liveMapDataSP
+
+    live_map_data.speedLimitValid = bool(MAX_SPEED_LIMIT > speed_limit > 0)
+    live_map_data.speedLimit = speed_limit
+    live_map_data.speedLimitAheadValid = bool(MAX_SPEED_LIMIT > next_speed_limit > 0)
+    live_map_data.speedLimitAhead = next_speed_limit
+    live_map_data.speedLimitAheadDistance = next_speed_limit_distance
+    live_map_data.roadName = self.get_current_road_name()
+
+    self.pm.send('liveMapDataSP', mapd_sp_send)
+
+  def tick(self) -> None:
+    self.sm.update(0)
+    self.update_location()
+    self.publish()

openpilot/sunnypilot/mapd/live_map_data/debug.py

@@ -0,0 +1,56 @@
+"""
+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.
+"""
+# DISCLAIMER: This code is intended principally for development and debugging purposes.
+# Although it provides a standalone entry point to the program, users should refer
+# to the actual implementations for consumption. Usage outside of development scenarios
+# is not advised and could lead to unpredictable results.
+
+import threading
+import traceback
+
+from openpilot.cereal import messaging
+from openpilot.common.gps import get_gps_location_service
+from openpilot.common.params import Params
+from openpilot.common.realtime import config_realtime_process
+from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.common import Policy
+from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_resolver import SpeedLimitResolver
+from openpilot.sunnypilot.mapd.live_map_data import get_debug
+
+
+def excepthook(args):
+  get_debug(f'MapD: Threading exception:\n{args}')
+  traceback.print_exception(args.exc_type, args.exc_value, args.exc_traceback)
+
+
+def live_map_data_sp_thread():
+  config_realtime_process([0, 1, 2, 3], 5)
+
+  params = Params()
+  gps_location_service = get_gps_location_service(params)
+
+  while True:
+    live_map_data_sp_thread_debug(gps_location_service)
+
+
+def live_map_data_sp_thread_debug(gps_location_service):
+  _sub_master = messaging.SubMaster(['carState', 'livePose', 'liveMapDataSP', 'longitudinalPlanSP', 'carStateSP', gps_location_service])
+  _sub_master.update()
+
+  v_ego = _sub_master['carState'].vEgo
+  _resolver = SpeedLimitResolver()
+  _resolver.policy = Policy.car_state_priority
+  _resolver.update(v_ego, _sub_master)
+  print(_resolver.speed_limit, _resolver.distance, _resolver.source)
+
+
+def main():
+  threading.excepthook = excepthook
+  live_map_data_sp_thread()
+
+
+if __name__ == "__main__":
+  main()

openpilot/sunnypilot/mapd/live_map_data/osm_map_data.py

@@ -0,0 +1,61 @@
+"""
+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 json
+import math
+import platform
+
+from openpilot.cereal import log
+from openpilot.common.params import Params
+from openpilot.sunnypilot.mapd.live_map_data.base_map_data import BaseMapData
+from openpilot.sunnypilot.navd.helpers import Coordinate
+
+
+class OsmMapData(BaseMapData):
+  def __init__(self):
+    super().__init__()
+    self.mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else self.params
+
+  def update_location(self) -> None:
+    location = self.sm['liveLocationKalman']
+    self.localizer_valid = (location.status == log.LiveLocationKalman.Status.valid) and location.positionGeodetic.valid
+
+    if self.localizer_valid:
+      self.last_bearing = math.degrees(location.calibratedOrientationNED.value[2])
+      self.last_position = Coordinate(location.positionGeodetic.value[0], location.positionGeodetic.value[1])
+
+    if self.last_position is None:
+      return
+
+    params = {
+      "latitude": self.last_position.latitude,
+      "longitude": self.last_position.longitude,
+    }
+
+    if self.last_bearing is not None:
+      params['bearing'] = self.last_bearing
+
+    self.mem_params.put("LastGPSPosition", json.dumps(params), block=True)
+
+  def get_current_speed_limit(self) -> float:
+    return float(self.mem_params.get("MapSpeedLimit") or 0.0)
+
+  def get_current_road_name(self) -> str:
+    return str(self.mem_params.get("RoadName") or "")
+
+  def get_next_speed_limit_and_distance(self) -> tuple[float, float]:
+    next_speed_limit_section_str = self.mem_params.get("NextMapSpeedLimit")
+    next_speed_limit_section = next_speed_limit_section_str if next_speed_limit_section_str else {}
+    next_speed_limit = next_speed_limit_section.get('speedlimit', 0.0)
+    next_speed_limit_latitude = next_speed_limit_section.get('latitude')
+    next_speed_limit_longitude = next_speed_limit_section.get('longitude')
+    next_speed_limit_distance = 0.0
+
+    if next_speed_limit_latitude and next_speed_limit_longitude:
+      next_speed_limit_coordinates = Coordinate(next_speed_limit_latitude, next_speed_limit_longitude)
+      next_speed_limit_distance = (self.last_position or Coordinate(0, 0)).distance_to(next_speed_limit_coordinates)
+
+    return next_speed_limit, next_speed_limit_distance

openpilot/sunnypilot/mapd/live_map_data/standalone.py

@@ -0,0 +1,42 @@
+"""
+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.
+"""
+# DISCLAIMER: This code is intended principally for development and debugging purposes.
+# Although it provides a standalone entry point to the program, users should refer
+# to the actual implementations for consumption. Usage outside of development scenarios
+# is not advised and could lead to unpredictable results.
+
+import threading
+import traceback
+
+from openpilot.common.realtime import Ratekeeper, config_realtime_process
+from openpilot.sunnypilot.mapd.live_map_data import get_debug
+from openpilot.sunnypilot.mapd.live_map_data.osm_map_data import OsmMapData
+
+
+def excepthook(args):
+  get_debug(f'MapD: Threading exception:\n{args}')
+  traceback.print_exception(args.exc_type, args.exc_value, args.exc_traceback)
+
+
+def live_map_data_sp_thread():
+  config_realtime_process([0, 1, 2, 3], 5)
+
+  live_map_sp = OsmMapData()
+  rk = Ratekeeper(1, print_delay_threshold=None)
+
+  while True:
+    live_map_sp.tick()
+    rk.keep_time()
+
+
+def main():
+  threading.excepthook = excepthook
+  live_map_data_sp_thread()
+
+
+if __name__ == "__main__":
+  main()

openpilot/sunnypilot/mapd/mapd_installer.py

@@ -0,0 +1,154 @@
+#!/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 logging
+import os
+import stat
+import time
+import traceback
+import requests
+from pathlib import Path
+from urllib.request import urlopen
+
+from openpilot.cereal import messaging
+from openpilot.common.params import Params
+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"
+
+
+def update_installed_version(version: str, params: Params = None) -> None:
+  if params is None:
+    params = Params()
+
+  params.put("MapdVersion", version, block=True)
+
+
+class MapdInstallManager:
+  def __init__(self, spinner_ref: Spinner):
+    self._spinner = spinner_ref
+    self._params = Params()
+
+  def download(self) -> None:
+    self.ensure_directories_exist()
+    self._download_file()
+    update_installed_version(VERSION, self._params)
+
+  def check_and_download(self) -> None:
+    if self.download_needed():
+      self.download()
+
+  def download_needed(self) -> bool:
+    return not os.path.exists(MAPD_PATH) or self.get_installed_version() != VERSION
+
+  @staticmethod
+  def ensure_directories_exist() -> None:
+    if not os.path.exists(Paths.mapd_root()):
+      os.makedirs(Paths.mapd_root())
+    if not os.path.exists(MAPD_BIN_DIR):
+      os.makedirs(MAPD_BIN_DIR)
+
+  @staticmethod
+  def _safe_write_and_set_executable(file_path: Path, content: bytes) -> None:
+    with open(file_path, 'wb') as output:
+      output.write(content)
+      output.flush()
+      os.fsync(output.fileno())
+    current_permissions = stat.S_IMODE(os.lstat(file_path).st_mode)
+    os.chmod(file_path, current_permissions | stat.S_IEXEC)
+
+  def _download_file(self, num_retries=5) -> None:
+    temp_file = Path(MAPD_PATH + ".tmp")
+    download_timeout = 60
+    for cnt in range(num_retries):
+      try:
+        response = requests.get(URL, stream=True, timeout=download_timeout)
+        response.raise_for_status()
+        self._safe_write_and_set_executable(temp_file, response.content)
+        # No exceptions encountered. Safe to replace original file.
+        temp_file.replace(MAPD_PATH)
+        return
+      except requests.exceptions.ReadTimeout:
+        self._spinner.update(f"ReadTimeout caught. Timeout is [{download_timeout}]. Retrying download... [{cnt}]")
+        time.sleep(0.5)
+      except requests.exceptions.RequestException as e:
+        self._spinner.update(f"RequestException caught: {e}. Retrying download... [{cnt}]")
+        time.sleep(0.5)
+
+    # Delete temp file if the process was not successful.
+    if temp_file.exists():
+      temp_file.unlink()
+    logging.error("Failed to download file after all retries")
+
+  def get_installed_version(self) -> str:
+    return str(self._params.get("MapdVersion") or "")
+
+  def wait_for_internet_connection(self, return_on_failure: bool = False) -> bool:
+    max_retries = 10
+    for retries in range(max_retries + 1):
+      self._spinner.update(f"Waiting for internet connection... [{retries}/{max_retries}]")
+      time.sleep(2)
+      try:
+        _ = urlopen('https://sentry.io', timeout=10)
+        return True
+      except Exception as e:
+        print(f'Wait for internet failed: {e}')
+        if return_on_failure and retries == max_retries:
+          return False
+
+    return False
+
+  def non_prebuilt_install(self) -> None:
+    sm = messaging.SubMaster(['deviceState'])
+    metered = sm['deviceState'].networkMetered
+
+    if metered:
+      self._spinner.update("Can't proceed with mapd install since network is metered!")
+      time.sleep(5)
+      return
+
+    try:
+      self.ensure_directories_exist()
+      if not self.download_needed():
+        self._spinner.update("Mapd is good!")
+        time.sleep(0.1)
+        return
+
+      if self.wait_for_internet_connection(return_on_failure=True):
+        self._spinner.update(f"Downloading pfeiferj's mapd [{self.get_installed_version()}] => [{VERSION}].")
+        time.sleep(0.1)
+        self.check_and_download()
+      self._spinner.close()
+
+    except Exception:
+      for i in range(6):
+        self._spinner.update("Failed to download OSM maps won't work until properly downloaded!" +
+                             "Try again manually rebooting. " +
+                             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__":
+  spinner = Spinner()
+  install_manager = MapdInstallManager(spinner)
+  install_manager.ensure_directories_exist()
+  if is_prebuilt():
+    debug_msg = f"[DEBUG] This is prebuilt, no mapd install required. VERSION: [{VERSION}], Param [{install_manager.get_installed_version()}]"
+    spinner.update(debug_msg)
+    update_installed_version(VERSION)
+  else:
+    spinner.update(f"Checking if mapd is installed and valid. Prebuilt [{is_prebuilt()}]")
+    install_manager.non_prebuilt_install()

openpilot/sunnypilot/mapd/mapd_manager.py

@@ -0,0 +1,144 @@
+#!/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 json
+import platform
+import os
+import glob
+import shutil
+from datetime import datetime
+
+from openpilot.common.params import Params
+from openpilot.common.realtime import Ratekeeper, config_realtime_process
+from openpilot.common.swaglog import cloudlog
+from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
+from openpilot.sunnypilot.mapd.live_map_data.osm_map_data import OsmMapData
+from openpilot.common.hardware.hw import Paths
+from openpilot.sunnypilot.mapd import MAPD_PATH
+from openpilot.sunnypilot.mapd.mapd_installer import VERSION, update_installed_version
+
+# PFEIFER - MAPD {{
+params = Params()
+mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else params
+# }} PFEIFER - MAPD
+
+
+def get_files_for_cleanup() -> list[str]:
+  paths = [
+    f"{Paths.mapd_root()}/db",
+    f"{Paths.mapd_root()}/v*"
+  ]
+  files_to_remove = []
+  for path in paths:
+    if os.path.exists(path):
+      files = glob.glob(path + '/**', recursive=True)
+      files_to_remove.extend(files)
+  # check for version and mapd files
+  if not os.path.isfile(MAPD_PATH):
+    files_to_remove.append(MAPD_PATH)
+  return files_to_remove
+
+
+def cleanup_old_osm_data(files_to_remove: list[str]) -> None:
+  for file in files_to_remove:
+    # Remove trailing slash if path is file
+    if file.endswith('/') and os.path.isfile(file[:-1]):
+      file = file[:-1]
+    # Try to remove as file or symbolic link first
+    if os.path.islink(file) or os.path.isfile(file):
+      os.remove(file)
+    elif os.path.isdir(file):  # If it's a directory
+      shutil.rmtree(file, ignore_errors=False)
+
+
+def request_refresh_osm_location_data(nations: list[str], states: list[str] | None = None) -> None:
+  params.put("OsmDownloadedDate", str(datetime.now().timestamp()), block=True)
+  params.put_bool("OsmDbUpdatesCheck", False, block=True)
+
+  osm_download_locations = {
+    "nations": nations,
+    "states": states or []
+  }
+
+  print(f"Downloading maps for {json.dumps(osm_download_locations)}")
+  mem_params.put("OSMDownloadLocations", osm_download_locations, block=True)
+
+
+def filter_nations_and_states(nations: list[str], states: list[str] | None = None) -> tuple[list[str], list[str]]:
+  """Filters and prepares nation and state data for OSM map download.
+
+  If the nation is 'US' and a specific state is provided, the nation 'US' is removed from the list.
+  If the nation is 'US' and the state is 'All', the 'All' is removed from the list.
+  The idea behind these filters is that if a specific state in the US is provided,
+  there's no need to download map data for the entire US. Conversely,
+  if the state is unspecified (i.e., 'All'), we intend to download map data for the whole US,
+  and 'All' isn't a valid state name, so it's removed.
+
+  Parameters:
+  nations (list): A list of nations for which the map data is to be downloaded.
+  states (list, optional): A list of states for which the map data is to be downloaded. Defaults to None.
+
+  Returns:
+  tuple: Two lists. The first list is filtered nations and the second list is filtered states.
+  """
+
+  if "US" in nations and states and not any(x.lower() == "all" for x in states):
+    # If a specific state in the US is provided, remove 'US' from nations
+    nations.remove("US")
+  elif "US" in nations and states and any(x.lower() == "all" for x in states):
+    # If 'All' is provided as a state (case invariant), remove those instances from states
+    states = [x for x in states if x.lower() != "all"]
+  elif "US" not in nations and states and any(x.lower() == "all" for x in states):
+    states.remove("All")
+  return nations, states or []
+
+
+def update_osm_db() -> None:
+  if params.get_bool("OsmDbUpdatesCheck"):
+    cleanup_old_osm_data(get_files_for_cleanup())
+    country = params.get("OsmLocationName", return_default=True)
+    state = params.get("OsmStateName", return_default=True)
+    filtered_nations, filtered_states = filter_nations_and_states([country], [state])
+    request_refresh_osm_location_data(filtered_nations, filtered_states)
+
+  if not mem_params.get("OSMDownloadBounds"):
+    mem_params.put("OSMDownloadBounds", "", block=True)
+
+  if not mem_params.get("LastGPSPosition"):
+    mem_params.put("LastGPSPosition", "{}", block=True)
+
+
+def main_thread():
+  update_installed_version(VERSION, params)
+  config_realtime_process([0, 1, 2, 3], 5)
+
+  rk = Ratekeeper(1, print_delay_threshold=None)
+  live_map_sp = OsmMapData()
+
+  # Create folder needed for OSM
+  try:
+    os.mkdir(Paths.mapd_root())
+  except FileExistsError:
+    pass
+  except PermissionError:
+    cloudlog.exception(f"mapd: failed to make {Paths.mapd_root()}")
+
+  while True:
+    show_alert = get_files_for_cleanup() and params.get_bool("OsmLocal")
+    set_offroad_alert("Offroad_OSMUpdateRequired", show_alert, "This alert will be cleared when new maps are downloaded.")
+
+    update_osm_db()
+    live_map_sp.tick()
+    rk.keep_time()
+
+
+def main():
+  main_thread()
+
+
+if __name__ == "__main__":
+  main()

openpilot/sunnypilot/mapd/tests/mapd_hash

@@ -0,0 +1 @@
+fdb3b49ee19956e6ce09fdc3373cbba557f1263b2180e9f344c1d4053852284b

openpilot/sunnypilot/mapd/tests/test_mapd_version.py

@@ -0,0 +1,19 @@
+"""
+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.
+"""
+from openpilot.sunnypilot import get_file_hash
+from openpilot.sunnypilot.mapd import MAPD_PATH
+from openpilot.sunnypilot.mapd.update_version import MAPD_HASH_PATH
+
+
+class TestMapdVersion:
+  def test_compare_versions(self):
+    mapd_hash = get_file_hash(MAPD_PATH)
+
+    with open(MAPD_HASH_PATH) as f:
+      current_hash = f.read().strip()
+
+    assert current_hash == mapd_hash, "Run sunnypilot/mapd/update_version.py to update the current mapd version and hash"

openpilot/sunnypilot/mapd/update_version.py

@@ -0,0 +1,97 @@
+#!/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 os
+import re
+
+from openpilot.sunnypilot import get_file_hash
+from openpilot.common.basedir import BASEDIR
+from openpilot.sunnypilot.mapd import MAPD_PATH
+
+MAPD_HASH_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "mapd", "tests", "mapd_hash")
+MAPD_VERSION_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "mapd", "mapd_installer.py")
+
+
+def update_mapd_hash():
+  mapd_hash = get_file_hash(MAPD_PATH)
+
+  with open(MAPD_HASH_PATH, "w") as f:
+    f.write(mapd_hash)
+
+  print(f"Generated and updated new mapd hash to {MAPD_HASH_PATH}")
+
+
+def get_current_mapd_version(path: str) -> str:
+  print("[GET CURRENT MAPD VERSION]")
+  with open(path) as f:
+    for line in f:
+      if line.strip().startswith("VERSION"):
+        # Match VERSION = 'v1.11.0' or VERSION="v1.11.0" (with optional spaces)
+        match = re.search(r'VERSION\s*=\s*[\'"]([^\'"]+)[\'"]', line)
+        if match:
+          ver = match.group(1)
+          print(f'Current mapd version: "{ver}"')
+          return ver
+        else:
+          print("[ERROR] VERSION line found but no quoted value detected.")
+          return ""
+  print("[ERROR] VERSION not found in file!")
+  return ""
+
+
+def update_mapd_version(ver: str, path: str):
+  print("[CHANGE CURRENT MAPD VERSION]")
+
+  with open(path) as f:
+    lines = f.readlines()
+
+  found = False
+  new_lines = []
+  for line in lines:
+    if not found and line.startswith("VERSION ="):
+      new_lines.append(f'VERSION = "{ver}"\n')
+      found = True
+      new_lines.extend(lines[lines.index(line) + 1:])
+      break
+    else:
+      new_lines.append(line)
+
+  if not found:
+    print("[ERROR] VERSION line not found! Aborting without writing.")
+    return
+
+  with open(path, "w") as f:
+    f.writelines(new_lines)
+
+  print(f'New mapd version: "{ver}"')
+  print("[DONE]")
+
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser(description="Update mapd version and hash")
+  parser.add_argument("--new_ver", type=str, help="New mapd version")
+  args = parser.parse_args()
+
+  if not args.new_ver:
+    print("Warning: No new mapd version provided. Use --new_ver to specify")
+    print("Example:")
+    print("  python sunnypilot/mapd/update_version.py --new_ver \"v1.12.0\"")
+    print("Current mapd version and hash will not be updated! (aborted)")
+    exit(0)
+
+  current_ver = get_current_mapd_version(MAPD_VERSION_PATH)
+  new_ver = f"{args.new_ver}"
+  if current_ver == new_ver:
+    print(f'Proposed mapd version: "{new_ver}"')
+    confirm = input("Proposed mapd version is the same as the current mapd version. Confirm? (y/n): ").upper().strip()
+    if confirm != "Y":
+      print("Current mapd version and hash will not be updated! (aborted)")
+      exit(0)
+
+  update_mapd_version(new_ver, MAPD_VERSION_PATH)
+  update_mapd_hash()