MakeHardwareStation() always triggers GitHub model download even with manually patched package_map

[UnderJollyRogers]

Issue Description:

When using manipulation.station.MakeHardwareStation() with a custom Parser and a patched package_map to point to local model resources (e.g., inside a virtual environment), Drake still attempts to download model files from GitHub.

I am working in a virtual environment where I pre-installed all required models under:

$VIRTUAL_ENV/share/drake_models/

In order to avoid online fetching, I use a parser_preload_callback:

def prefinalize(parser):
    package_map = parser.package_map()
    if package_map.Contains("drake_models"):
        package_map.Remove("drake_models")
    package_map.Add("drake_models", models_dir)


station = builder.AddSystem(MakeHardwareStation(
    scenario,
    parser_preload_callback=prefinalize
))

Despite this setup, Drake still attempts to fetch packages online when calling MakeHardwareStation().

Workaround

I was able to bypass the issue by not using MakeHardwareStation() and instead building the plant manually. This method gives me full control over the Parser and package_map, avoiding the unwanted GitHub downloads:

venv = os.environ.get("VIRTUAL_ENV")
if not venv:
    raise RuntimeError("No VIRTUAL_ENV found. Activate your venv first.")

models_dir = os.path.join(venv, "share", "drake_models")
allegro_pkg_dir = os.path.join(models_dir, "allegro_hand_description")
allegro_urdf = os.path.join(allegro_pkg_dir, "urdf", "allegro_hand_description_left.urdf")

if not os.path.exists(allegro_urdf):
    raise FileNotFoundError(f"Can't find Allegro URDF at: {allegro_urdf}")

builder = DiagramBuilder()
plant, scene_graph = AddMultibodyPlantSceneGraph(builder, time_step=0.0)
meshcat = StartMeshcat()
MeshcatVisualizer.AddToBuilder(builder, scene_graph, meshcat)

parser = Parser(plant)
pm = parser.package_map()

# Forcefully remove and remap the 'drake_models' package to local
if pm.Contains("drake_models"):
    pm.Remove("drake_models")
pm.Add("drake_models", models_dir)

# Also add the sub-package if needed
if not pm.Contains("allegro_hand_description"):
    pm.Add("allegro_hand_description", allegro_pkg_dir)

instances = parser.AddModels(allegro_urdf)
plant.Finalize()

This manual setup works as expected and respects the local model paths. However, a similar result is currently not possible using MakeHardwareStation() due to its internal handling of model loading.

[UnderJollyRogers]

I think I found the issue, along with a partial solution. It appears that when running MakeHardwareStation(), there is a call to _ApplyDriverConfigsSim(), which in turn calls MakeMultibodyPlant(). Inside MakeMultibodyPlant(), a new instance of Parser is created, and this seems to reinitialize its configuration. Then, when

flattened_directives = FlattenModelDirectives(
    ModelDirectives(directives=scenario.directives), parser.package_map()
).directives

is executed, it starts downloading the drake_models again.

I was able to partially solve the issue by modifying the MakeMultibodyPlant() function and adding the following:

pm=parser.package_map()
venv = os.environ.get("VIRTUAL_ENV")
drake_models_dir = os.path.join(venv, "share", "drake_models/models/package.xml")
if pm.Contains("drake_models"):
    pm.Remove("drake_models")
pm.AddPackageXml(filename=drake_models_dir)
for p in pm.GetPackageNames():
    print(pm.GetPath(p))

When printing the package names, the output is:

/home/robotgentlemen/Documents/antipodal_ws/AIRA_repository/drake-venv/lib/python3.10/site-packages/pydrake/common/../lib/../share/drake
/home/robotgentlemen/Documents/antipodal_ws/AIRA_repository/drake-venv/share/drake_models/models

This confirms that the local folders with the drake_models are being included.

I think a better solution would be to feed the modified parser directly to _ApplyDriverConfigsSim(), so that it propagates into MakeHardwareStation().

[UnderJollyRogers]

I found a better solution to the issue by modifying both MakeHardwareStation() and ApplyMultibodyPlantConfig() to handle package paths more reliably.

1. Changes to MakeHardwareStation()

Before:

for p in package_xmls:
    parser.package_map().AddPackageXml(p)
ConfigureParser(parser)

After:

if package_xmls:
    for name in list(parser.package_map().GetPackageNames()):
        parser.package_map().Remove(name)
    for p in package_xmls:
        parser.package_map().AddPackageXml(p)

This ensures that the package paths do not conflict with previously registered packages.

2. Handling parser_preload_callback

I also ensure that the package_xmls list is rebuilt after parser_preload_callback is invoked:

if parser_preload_callback:
    parser_preload_callback(parser)
    paths = [parser.package_map().GetPath(p) for p in parser.package_map().GetPackageNames()]
    package_xmls = [os.path.join(path, "package.xml") for path in paths]

This guarantees that functions which do not pass a parser but do pass package_xmls receive the correct files.

3. Changes to ApplyMultibodyPlantConfig()

The same issue appeared in ApplyMultibodyPlantConfig(), so I applied the same modifications there.
I’ve attached the updated station.py file with all modifications for reference.