Fix mypy complaints

python/lsst/daf/butler/datastores/fileDatastore.py

@@ -1662,6 +1662,13 @@ def emptyTrash(self, ignore_errors: bool = True) -> None:
                                                                  if isinstance(info, StoredFileInfo)])
 
                 for ref, info in trashed:
+
+                    # Mypy needs to know this is not the base class
+                    assert isinstance(info, StoredFileInfo), f"Unexpectedly got info of class {type(info)}"
+
+                    # Check for mypy
+                    assert ref.id is not None, f"Internal logic error in emptyTrash with ref {ref}/{info}"
+
                     path_map[info.path].remove(ref.id)
                     if not path_map[info.path]:
                         del path_map[info.path]

python/lsst/daf/butler/registry/bridge/ephemeral.py

@@ -83,8 +83,9 @@ def emptyTrash(self, records_table: Optional[OpaqueTableStorage] = None,
                    record_column: Optional[str] = None,
                    ) -> Iterator[Tuple[Iterable[Tuple[DatasetIdRef,
                                                       Optional[StoredDatastoreItemInfo]]],
-                                       Set[str]]]:
+                                       Optional[Set[str]]]]:
         # Docstring inherited from DatastoreRegistryBridge
+        matches: Iterable[Tuple[FakeDatasetRef, Optional[StoredDatastoreItemInfo]]] = ()
         if isinstance(records_table, OpaqueTableStorage):
             if record_class is None:
                 raise ValueError("Record class must be provided if records table is given.")

python/lsst/daf/butler/registry/bridge/monolithic.py

@@ -191,21 +191,23 @@ def emptyTrash(self, records_table: Optional[OpaqueTableStorage] = None,
                    record_column: Optional[str] = None,
                    ) -> Iterator[Tuple[Iterable[Tuple[DatasetIdRef,
                                                       Optional[StoredDatastoreItemInfo]]],
-                                       Set[str]]]:
+                                       Optional[Set[str]]]]:
         # Docstring inherited from DatastoreRegistryBridge
 
         if records_table is None:
             raise ValueError("This implementation requires a records table.")
 
-        if not isinstance(records_table, ByNameOpaqueTableStorage):
-            raise ValueError(f"Records table must support hidden attributes. Got {type(records_table)}.")
+        assert isinstance(records_table, ByNameOpaqueTableStorage),\
+            f"Records table must support hidden attributes. Got {type(records_table)}."
 
         if record_class is None:
             raise ValueError("Record class must be provided if records table is given.")
 
         # Helper closure to generate the common join+where clause.
         def join_records(select: sqlalchemy.sql.Select, location_table: sqlalchemy.schema.Table
                          ) -> sqlalchemy.sql.FromClause:
+            # mypy needs to be sure
+            assert isinstance(records_table, ByNameOpaqueTableStorage)
             return select.select_from(
                 records_table._table.join(
                     location_table,

python/lsst/daf/butler/registry/interfaces/_bridge.py

@@ -199,8 +199,8 @@ def emptyTrash(self, records_table: Optional[OpaqueTableStorage] = None,
                    record_class: Optional[Type[StoredDatastoreItemInfo]] = None,
                    record_column: Optional[str] = None,
                    ) -> ContextManager[Tuple[Iterable[Tuple[DatasetIdRef,
-                                                      Optional[StoredDatastoreItemInfo]]],
-                                       Set[str]]]:
+                                                            Optional[StoredDatastoreItemInfo]]],
+                                             Optional[Set[str]]]]:
         """Retrieve all the dataset ref IDs that are in the trash
         associated for this datastore, and then remove them if the context
         exists without an exception being raised.