convert objaverse 1.0 to use the abstract class

objaverse_xl/objaverse_v1.py

@@ -10,100 +10,151 @@ import requests
 import pandas as pd
 import tempfile
 from objaverse_xl.utils import get_file_hash
+from objaverse_xl.abstract import ObjaverseSource
 
 import fsspec
 from loguru import logger
 from tqdm import tqdm
 
 
-def load_annotations(download_dir: str = "~/.objaverse") -> pd.DataFrame:
-    """Load the annotations from the given directory.
-
-    Args:
-        download_dir (str, optional): The directory to load the annotations from.
-            Supports all file systems supported by fsspec. Defaults to
-            "~/.objaverse".
-
-    Returns:
-        pd.DataFrame: The annotations, which includes the columns "thingId", "fileId",
-            "filename", and "license".
-    """
-    remote_url = "https://huggingface.co/datasets/allenai/objaverse-xl/resolve/main/objaverse_v1/object-metadata.parquet"
-    download_path = os.path.join(
-        download_dir, "hf-objaverse-v1", "thingiverse-objects.parquet"
-    )
-    fs, path = fsspec.core.url_to_fs(download_path)
-
-    if not fs.exists(path):
-        fs.makedirs(os.path.dirname(path), exist_ok=True)
-        logger.info(f"Downloading {remote_url} to {download_path}")
-        response = requests.get(remote_url)
-        response.raise_for_status()
-        with fs.open(path, "wb") as file:
-            file.write(response.content)
+class Sketchfab(ObjaverseSource):
+    """A class for downloading and processing Objaverse 1.0."""
+
+    def load_annotations(self, download_dir: str = "~/.objaverse") -> pd.DataFrame:
+        """Load the annotations from the given directory.
+
+        Args:
+            download_dir (str, optional): The directory to load the annotations from.
+                Supports all file systems supported by fsspec. Defaults to
+                "~/.objaverse".
+
+        Returns:
+            pd.DataFrame: The annotations, which includes the columns "thingId", "fileId",
+                "filename", and "license".
+        """
+        remote_url = "https://huggingface.co/datasets/allenai/objaverse-xl/resolve/main/objaverse_v1/object-metadata.parquet"
+        download_path = os.path.join(
+            download_dir, "hf-objaverse-v1", "thingiverse-objects.parquet"
+        )
+        fs, path = fsspec.core.url_to_fs(download_path)
+
+        if not fs.exists(path):
+            fs.makedirs(os.path.dirname(path), exist_ok=True)
+            logger.info(f"Downloading {remote_url} to {download_path}")
+            response = requests.get(remote_url)
+            response.raise_for_status()
+            with fs.open(path, "wb") as file:
+                file.write(response.content)
+
+        # read the file with pandas and fsspec
+        with fs.open(download_path, "rb") as f:
+            annotations_df = pd.read_parquet(f)
+
+        annotations_df["metadata"] = "{}"
+
+        return annotations_df
+
+    def load_full_annotations(
+        self,
+        uids: Optional[List[str]] = None,
+        download_dir: str = "~/.objaverse",
+    ) -> Dict[str, Any]:
+        """Load the full metadata of all objects in the dataset.
+
+        Args:
+            uids: A list of uids with which to load metadata. If None, it loads
+                the metadata for all uids.
+            download_dir: The base directory to download the annotations to. Supports all
+                file systems supported by fsspec. Defaults to "~/.objaverse".
+
+        Returns:
+            A dictionary of the metadata for each object. The keys are the uids and the
+            values are the metadata for that object.
+        """
+        # make the metadata dir if it doesn't exist
+        metadata_path = os.path.join(download_dir, "hf-objaverse-v1", "metadata")
+        fs, _ = fsspec.core.url_to_fs(metadata_path)
+        fs.makedirs(metadata_path, exist_ok=True)
+
+        # get the dir ids that need to be loaded if only downloading a subset of uids
+        object_paths = self._load_object_paths(download_dir=download_dir)
+        dir_ids = (
+            {object_paths[uid].split("/")[1] for uid in uids}
+            if uids is not None
+            else {f"{i // 1000:03d}-{i % 1000:03d}" for i in range(160)}
+        )
+
+        # get the existing metadata files
+        existing_metadata_files = fs.glob(
+            os.path.join(metadata_path, "*.json.gz"), refresh=True
+        )
+        existing_dir_ids = {
+            file.split("/")[-1].split(".")[0]
+            for file in existing_metadata_files
+            if file.endswith(".json.gz")  # note partial files end with .json.gz.tmp
+        }
+        downloaded_dir_ids = existing_dir_ids.intersection(dir_ids)
+        logger.info(
+            f"Found {len(downloaded_dir_ids)} metadata files already downloaded"
+        )
+
+        # download the metadata from the missing dir_ids
+        dir_ids_to_download = dir_ids - existing_dir_ids
+        logger.info(f"Downloading {len(dir_ids_to_download)} metadata files")
+
+        # download the metadata file if it doesn't exist
+        if len(dir_ids_to_download) > 0:
+            for i_id in tqdm(dir_ids_to_download, desc="Downloading metadata files"):
+                # get the path to the json file
+                path = os.path.join(metadata_path, f"{i_id}.json.gz")
+
+                # get the url to the remote json file
+                hf_url = f"https://huggingface.co/datasets/allenai/objaverse/resolve/main/metadata/{i_id}.json.gz"
+
+                # download the file to a tmp path to avoid partial downloads on interruption
+                tmp_path = f"{path}.tmp"
+                with fs.open(tmp_path, "wb") as f:
+                    with urllib.request.urlopen(hf_url) as response:
+                        f.write(response.read())
+                fs.rename(tmp_path, path)
+
+        out = {}
+        for i_id in tqdm(dir_ids, desc="Reading metadata files"):
+            # get the path to the json file
+            path = os.path.join(metadata_path, f"{i_id}.json.gz")
 
-    # read the file with pandas and fsspec
-    with fs.open(download_path, "rb") as f:
-        annotations_df = pd.read_parquet(f)
+            # read the json file of the metadata chunk
+            with fs.open(path, "rb") as f:
+                with gzip.GzipFile(fileobj=f) as gfile:
+                    content = gfile.read()
+                    data = json.loads(content)
 
-    annotations_df["metadata"] = "{}"
+            # filter the data to only include the uids we want
+            if uids is not None:
+                data = {uid: data[uid] for uid in uids if uid in data}
 
-    return annotations_df
+            # add the data to the out dict
+            out.update(data)
 
+        return out
 
-def load_full_annotations(
-    uids: Optional[List[str]] = None,
-    download_dir: str = "~/.objaverse",
-) -> Dict[str, Any]:
-    """Load the full metadata of all objects in the dataset.
+    def _load_object_paths(self, download_dir: str) -> Dict[str, str]:
+        """Load the object paths from the dataset.
 
-    Args:
-        uids: A list of uids with which to load metadata. If None, it loads
-            the metadata for all uids.
-        download_dir: The base directory to download the annotations to. Supports all
-            file systems supported by fsspec. Defaults to "~/.objaverse".
+        The object paths specify the location of where the object is located in the
+        Hugging Face repo.
 
-    Returns:
-        A dictionary of the metadata for each object. The keys are the uids and the
-        values are the metadata for that object.
-    """
-    # make the metadata dir if it doesn't exist
-    metadata_path = os.path.join(download_dir, "hf-objaverse-v1", "metadata")
-    fs, _ = fsspec.core.url_to_fs(metadata_path)
-    fs.makedirs(metadata_path, exist_ok=True)
-
-    # get the dir ids that need to be loaded if only downloading a subset of uids
-    object_paths = _load_object_paths(download_dir=download_dir)
-    dir_ids = (
-        {object_paths[uid].split("/")[1] for uid in uids}
-        if uids is not None
-        else {f"{i // 1000:03d}-{i % 1000:03d}" for i in range(160)}
-    )
-
-    # get the existing metadata files
-    existing_metadata_files = fs.glob(
-        os.path.join(metadata_path, "*.json.gz"), refresh=True
-    )
-    existing_dir_ids = {
-        file.split("/")[-1].split(".")[0]
-        for file in existing_metadata_files
-        if file.endswith(".json.gz")  # note partial files end with .json.gz.tmp
-    }
-    downloaded_dir_ids = existing_dir_ids.intersection(dir_ids)
-    logger.info(f"Found {len(downloaded_dir_ids)} metadata files already downloaded")
-
-    # download the metadata from the missing dir_ids
-    dir_ids_to_download = dir_ids - existing_dir_ids
-    logger.info(f"Downloading {len(dir_ids_to_download)} metadata files")
-
-    # download the metadata file if it doesn't exist
-    if len(dir_ids_to_download) > 0:
-        for i_id in tqdm(dir_ids_to_download, desc="Downloading metadata files"):
-            # get the path to the json file
-            path = os.path.join(metadata_path, f"{i_id}.json.gz")
+        Returns:
+            A dictionary mapping the uid to the object path.
+        """
+        object_paths_file = "object-paths.json.gz"
+        local_path = os.path.join(download_dir, "hf-objaverse-v1", object_paths_file)
 
-            # get the url to the remote json file
-            hf_url = f"https://huggingface.co/datasets/allenai/objaverse/resolve/main/metadata/{i_id}.json.gz"
+        # download the object_paths file if it doesn't exist
+        fs, path = fsspec.core.url_to_fs(local_path)
+        if not fs.exists(path):
+            hf_url = f"https://huggingface.co/datasets/allenai/objaverse/resolve/main/{object_paths_file}"
+            fs.makedirs(os.path.dirname(path), exist_ok=True)
 
             # download the file to a tmp path to avoid partial downloads on interruption
             tmp_path = f"{path}.tmp"
@@ -112,235 +163,330 @@ def load_full_annotations(
                     f.write(response.read())
             fs.rename(tmp_path, path)
 
-    out = {}
-    for i_id in tqdm(dir_ids, desc="Reading metadata files"):
-        # get the path to the json file
-        path = os.path.join(metadata_path, f"{i_id}.json.gz")
-
-        # read the json file of the metadata chunk
+        # read the object_paths
         with fs.open(path, "rb") as f:
             with gzip.GzipFile(fileobj=f) as gfile:
                 content = gfile.read()
-                data = json.loads(content)
-
-        # filter the data to only include the uids we want
-        if uids is not None:
-            data = {uid: data[uid] for uid in uids if uid in data}
-
-        # add the data to the out dict
-        out.update(data)
-
-    return out
-
-
-annotations = load_annotations(download_dir="~/.objaverse-temp-400")
-
-
-def _load_object_paths(download_dir: str) -> Dict[str, str]:
-    """Load the object paths from the dataset.
-
-    The object paths specify the location of where the object is located
-    in the Hugging Face repo.
-
-    Returns:
-        A dictionary mapping the uid to the object path.
-    """
-    object_paths_file = "object-paths.json.gz"
-    local_path = os.path.join(download_dir, "hf-objaverse-v1", object_paths_file)
-
-    # download the object_paths file if it doesn't exist
-    fs, path = fsspec.core.url_to_fs(local_path)
-    if not fs.exists(path):
-        hf_url = f"https://huggingface.co/datasets/allenai/objaverse/resolve/main/{object_paths_file}"
-        fs.makedirs(os.path.dirname(path), exist_ok=True)
-
-        # download the file to a tmp path to avoid partial downloads on interruption
-        tmp_path = f"{path}.tmp"
-        with fs.open(tmp_path, "wb") as f:
-            with urllib.request.urlopen(hf_url) as response:
-                f.write(response.read())
-        fs.rename(tmp_path, path)
-
-    # read the object_paths
-    with fs.open(path, "rb") as f:
-        with gzip.GzipFile(fileobj=f) as gfile:
-            content = gfile.read()
-            object_paths = json.loads(content)
-
-    return object_paths
-
-
-def load_uids(download_dir: str = "~/.objaverse") -> List[str]:
-    """Load the uids from the dataset.
-
-    Returns:
-        A list of all the UIDs from the dataset.
-    """
-    return list(_load_object_paths(download_dir=download_dir).keys())
-
+                object_paths = json.loads(content)
+
+        return object_paths
+
+    def load_uids(self, download_dir: str = "~/.objaverse") -> List[str]:
+        """Load the uids from the dataset.
+
+        Returns:
+            A list of all the UIDs from the dataset.
+        """
+        return list(self._load_object_paths(download_dir=download_dir).keys())
+
+    def _download_object(
+        self,
+        file_identifier: str,
+        hf_object_path: str,
+        download_dir: Optional[str],
+        expected_sha256: str,
+        handle_found_object: Optional[Callable] = None,
+        handle_modified_object: Optional[Callable] = None,
+        handle_missing_object: Optional[Callable] = None,
+    ) -> Tuple[str, Optional[str]]:
+        """Download the object for the given uid.
+
+        Args:
+            file_identifier: The file identifier of the object.
+            hf_object_path: The path to the object in the Hugging Face repo. Here,
+                hf_object_path is the part that comes after "main" in the Hugging Face
+                repo url:
+                https://huggingface.co/datasets/allenai/objaverse/resolve/main/{hf_object_path}
+            download_dir: The base directory to download the object to. Supports all
+                file systems supported by fsspec. Defaults to "~/.objaverse".
+            expected_objects (str): The expected SHA256 of the contents of the
+                downloaded object.
+            handle_found_object (Optional[Callable], optional): Called when an object is
+                successfully found and downloaded. Here, the object has the same sha256
+                as the one that was downloaded with Objaverse-XL. If None, the object
+                will be downloaded, but nothing will be done with it. Args for the
+                function include:
+                - local_path (str): Local path to the downloaded 3D object.
+                - file_identifier (str): GitHub URL of the 3D object.
+                - sha256 (str): SHA256 of the contents of the 3D object.
+                - metadata (Dict[str, Any]): Metadata about the 3D object, including the
+                    GitHub organization and repo names.
+                Return is not used. Defaults to None.
+            handle_modified_object (Optional[Callable], optional): Called when a
+                modified object is found and downloaded. Here, the object is
+                successfully downloaded, but it has a different sha256 than the one that
+                was downloaded with Objaverse-XL. This is not expected to happen very
+                often, because the same commit hash is used for each repo. If None, the
+                object will be downloaded, but nothing will be done with it. Args for
+                the function include:
+                - local_path (str): Local path to the downloaded 3D object.
+                - file_identifier (str): GitHub URL of the 3D object.
+                - new_sha256 (str): SHA256 of the contents of the newly downloaded 3D
+                    object.
+                - old_sha256 (str): Expected SHA256 of the contents of the 3D object as
+                    it was when it was downloaded with Objaverse-XL.
+                - metadata (Dict[str, Any]): Metadata about the 3D object, including the
+                    GitHub organization and repo names.
+                Return is not used. Defaults to None.
+            handle_missing_object (Optional[Callable], optional): Called when an object
+                that is in Objaverse-XL is not found. Here, it is likely that the
+                repository was deleted or renamed. If None, nothing will be done with
+                the missing object. Args for the function include:
+                - file_identifier (str): GitHub URL of the 3D object.
+                - sha256 (str): SHA256 of the contents of the original 3D object.
+                - metadata (Dict[str, Any]): Metadata about the 3D object, including the
+                    GitHub organization and repo names.
+                Return is not used. Defaults to None.
+
+        Returns:
+            A tuple of the uid and the path to where the downloaded object. If
+            download_dir is None, the path will be None.
+        """
+        hf_url = f"https://huggingface.co/datasets/allenai/objaverse/resolve/main/{hf_object_path}"
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # download the file locally
+            temp_path = os.path.join(temp_dir, hf_object_path)
+            os.makedirs(os.path.dirname(temp_path), exist_ok=True)
+            temp_path_tmp = f"{temp_path}.tmp"
+            with open(temp_path_tmp, "wb") as file:
+                with urllib.request.urlopen(hf_url) as response:
+                    file.write(response.read())
+            os.rename(temp_path_tmp, temp_path)
+
+            # get the sha256 of the downloaded file
+            sha256 = get_file_hash(temp_path)
+
+            if sha256 == expected_sha256:
+                if handle_found_object is not None:
+                    handle_found_object(
+                        local_path=temp_path,
+                        file_identifier=file_identifier,
+                        sha256=sha256,
+                        metadata=dict(),
+                    )
+            else:
+                if handle_modified_object is not None:
+                    handle_modified_object(
+                        local_path=temp_path,
+                        file_identifier=file_identifier,
+                        new_sha256=sha256,
+                        old_sha256=expected_sha256,
+                        metadata=dict(),
+                    )
+
+            if download_dir is not None:
+                filename = os.path.join(download_dir, "hf-objaverse-v1", hf_object_path)
+                fs, path = fsspec.core.url_to_fs(filename)
+                fs.makedirs(os.path.dirname(path), exist_ok=True)
+                fs.put(temp_path, path)
+            else:
+                path = None
+
+        return file_identifier, path
+
+    def _parallel_download_object(self, args):
+        # workaround since starmap doesn't work well with tqdm
+        return self._download_object(*args)
+
+    def _get_uid(self, item: pd.Series) -> str:
+        file_identifier = item["fileIdentifier"]
+        return file_identifier.split("/")[-1]
+
+    def uid_to_file_identifier(self, uid: str) -> str:
+        """Convert the uid to the file identifier.
+
+        Args:
+            uid (str): The uid of the object.
+
+        Returns:
+            The file identifier of the object.
+        """
+        return f"https://sketchfab.com/3d-models/{uid}"
+
+    def file_identifier_to_uid(self, file_identifier: str) -> str:
+        """Convert the file identifier to the uid.
+
+        Args:
+            file_identifier (str): The file identifier of the object.
+
+        Returns:
+            The uid of the object.
+        """
+        return file_identifier.split("/")[-1]
+
+    def download_objects(
+        self,
+        objects: pd.DataFrame,
+        download_dir: Optional[str] = "~/.objaverse",
+        processes: Optional[int] = None,
+        handle_found_object: Optional[Callable] = None,
+        handle_modified_object: Optional[Callable] = None,
+        handle_missing_object: Optional[Callable] = None,
+        **kwargs,
+    ) -> Dict[str, str]:
+        """Return the path to the object files for the given uids.
+
+        If the object is not already downloaded, it will be downloaded.
+
+        Args:
+            objects (pd.DataFrame): Objects to download. Must have columns for
+                the object "fileIdentifier" and "sha256". Use the `load_annotations`
+                function to get the metadata.
+            processes (int, optional): The number of processes to use to download
+                the objects. Defaults to 1.
+            download_dir (Optional[str], optional): The base directory to download the
+                object to. Supports all file systems supported by fsspec. If None, the
+                objects will be removed after downloading. Defaults to "~/.objaverse".
+
+        Returns:
+            A dictionary mapping the object fileIdentifier to the local path of where
+            the object downloaded.
+        """
+        hf_object_paths = self._load_object_paths(
+            download_dir=download_dir if download_dir is not None else "~/.objaverse"
+        )
+
+        # make a copy of the objects so we don't modify the original
+        objects = objects.copy()
+        objects["uid"] = objects.apply(self._get_uid, axis=1)
+        uids_to_sha256 = dict(zip(objects["uid"], objects["sha256"]))
+        uids_set = set(uids_to_sha256.keys())
+
+        # create a new df where the uids are the index
+        objects_uid_index = objects.set_index("uid")
+
+        out = {}
+        objects_to_download = []
+        if download_dir is None:
+            for _, item in objects.iterrows():
+                uid = item["uid"]
+                if uid not in hf_object_paths:
+                    logger.error(f"Could not find object with uid {uid}!")
+                    if handle_missing_object is not None:
+                        handle_missing_object(
+                            file_identifier=item["fileIdentifier"],
+                            sha256=item["sha256"],
+                            metadata=dict(),
+                        )
+                    continue
+                objects_to_download.append(
+                    (item["fileIdentifier"], hf_object_paths[uid], item["sha256"])
+                )
+        else:
+            versioned_dirname = os.path.join(download_dir, "hf-objaverse-v1")
+            fs, path = fsspec.core.url_to_fs(versioned_dirname)
+
+            # Get the existing file paths. This is much faster than calling fs.exists() for each
+            # file. `glob()` is like walk, but returns a list of files instead of the nested
+            # directory structure. glob() is also faster than find() / walk() since it doesn't
+            # need to traverse the entire directory structure.
+            existing_file_paths = fs.glob(
+                os.path.join(path, "glbs", "*", "*.glb"), refresh=True
+            )
+            existing_uids = {
+                file.split("/")[-1].split(".")[0]
+                for file in existing_file_paths
+                if file.endswith(".glb")  # note partial files end with .glb.tmp
+            }
+
+            # add the existing downloaded uids to the return dict
+            already_downloaded_uids = uids_set.intersection(existing_uids)
+            for uid in already_downloaded_uids:
+                hf_object_path = hf_object_paths[uid]
+                fs_abs_object_path = os.path.join(versioned_dirname, hf_object_path)
+                out[self.uid_to_file_identifier(uid)] = fs_abs_object_path
+
+            logger.info(
+                f"Found {len(already_downloaded_uids)} objects already downloaded"
+            )
 
-def _download_object(
-    uid: str,
-    hf_object_path: str,
-    download_dir: str,
-) -> Tuple[str, str]:
-    """Download the object for the given uid.
+            # get the uids that need to be downloaded
+            remaining_uids = uids_set - existing_uids
+            for uid in remaining_uids:
+                item = objects_uid_index.loc[uid]
+                if uid not in hf_object_paths:
+                    logger.error(f"Could not find object with uid {uid}. Skipping it.")
+                    if handle_missing_object is not None:
+                        handle_missing_object(
+                            file_identifier=item["fileIdentifier"],
+                            sha256=item["sha256"],
+                            metadata=dict(),
+                        )
+                    continue
+                objects_to_download.append(
+                    (item["fileIdentifier"], hf_object_paths[uid], item["sha256"])
+                )
 
-    Args:
-        uid: The uid of the object to load.
-        hf_object_path: The path to the object in the Hugging Face repo. Here, hf_object_path
-            is the part that comes after "main" in the Hugging Face repo url:
-            https://huggingface.co/datasets/allenai/objaverse/resolve/main/{hf_object_path}
-        download_dir: The base directory to download the object to. Supports all
-            file systems supported by fsspec. Defaults to "~/.objaverse".
+            logger.info(f"Downloading {len(objects_to_download)} new objects")
 
-    Returns:
-        A tuple of the uid and the path to where the downloaded object.
-    """
-    hf_url = f"https://huggingface.co/datasets/allenai/objaverse/resolve/main/{hf_object_path}"
-
-    filename = os.path.join(download_dir, "hf-objaverse-v1", hf_object_path)
-    fs, path = fsspec.core.url_to_fs(filename)
-
-    # download the file
-    fs.makedirs(os.path.dirname(path), exist_ok=True)
-    tmp_path = f"{path}.tmp"
-    with fs.open(tmp_path, "wb") as file:
-        with urllib.request.urlopen(hf_url) as response:
-            file.write(response.read())
-
-    fs.rename(tmp_path, path)
-
-    return uid, filename
-
-
-def _parallel_download_object(args):
-    # workaround since starmap doesn't work well with tqdm
-    return _download_object(*args)
-
-
-def load_objects(
-    uids: List[str],
-    download_processes: int = 1,
-    download_dir: str = "~/.objaverse",
-) -> Dict[str, str]:
-    """Return the path to the object files for the given uids.
-
-    If the object is not already downloaded, it will be downloaded.
-
-    Args:
-        uids: A list of uids.
-        download_processes: The number of processes to use to download the objects.
-
-    Returns:
-        A dictionary mapping the object uid to the local path of where the object
-        downloaded.
-    """
-    uids_set = set(uids)
-    hf_object_paths = _load_object_paths(download_dir=download_dir)
-
-    versioned_dirname = os.path.join(download_dir, "hf-objaverse-v1")
-    fs, path = fsspec.core.url_to_fs(versioned_dirname)
-
-    # Get the existing file paths. This is much faster than calling fs.exists() for each
-    # file. `glob()` is like walk, but returns a list of files instead of the nested
-    # directory structure. glob() is also faster than find() / walk() since it doesn't
-    # need to traverse the entire directory structure.
-    existing_file_paths = fs.glob(
-        os.path.join(path, "glbs", "*", "*.glb"), refresh=True
-    )
-    existing_uids = {
-        file.split("/")[-1].split(".")[0]
-        for file in existing_file_paths
-        if file.endswith(".glb")  # note partial files end with .glb.tmp
-    }
-
-    # add the existing downloaded uids to the return dict
-    out = {}
-    already_downloaded_uids = uids_set.intersection(existing_uids)
-    for uid in already_downloaded_uids:
-        hf_object_path = hf_object_paths[uid]
-        fs_abs_object_path = os.path.join(versioned_dirname, hf_object_path)
-        out[uid] = fs_abs_object_path
-
-    logger.info(f"Found {len(already_downloaded_uids)} objects already downloaded")
-
-    # get the uids that need to be downloaded
-    remaining_uids = uids_set - existing_uids
-    uids_to_download = []
-    for uid in remaining_uids:
-        if uid not in hf_object_paths:
-            logger.error(f"Could not find object with uid {uid}. Skipping it.")
-            continue
-        uids_to_download.append((uid, hf_object_paths[uid]))
-
-    logger.info(f"Downloading {len(uids_to_download)} new objects")
-
-    # check if all objects are already downloaded
-    if len(uids_to_download) == 0:
-        return out
+        # check if all objects are already downloaded
+        if len(objects_to_download) == 0:
+            return out
 
-    if download_processes == 1:
-        # iteratively download the objects
-        for uid, hf_object_path in tqdm(uids_to_download):
-            uid, local_path = _download_object(
-                uid=uid, hf_object_path=hf_object_path, download_dir=download_dir
-            )
-            out[uid] = local_path
-    else:
         args = [
-            (uid, hf_object_path, download_dir)
-            for uid, hf_object_path in uids_to_download
+            (
+                file_identifier,
+                hf_object_path,
+                download_dir,
+                sha256,
+                handle_found_object,
+                handle_modified_object,
+                handle_missing_object,
+            )
+            for file_identifier, hf_object_path, sha256 in objects_to_download
         ]
 
         # download the objects in parallel
-        with Pool(download_processes) as pool:
+        with Pool(processes) as pool:
             new_object_downloads = list(
                 tqdm(
-                    pool.imap_unordered(_parallel_download_object, args),
+                    pool.imap_unordered(self._parallel_download_object, args),
                     total=len(args),
                 )
             )
 
-        for uid, local_path in new_object_downloads:
-            out[uid] = local_path
-
-    return out
+        for file_identifier, local_path in new_object_downloads:
+            out[file_identifier] = local_path
 
+        return out
 
-def load_lvis_annotations(download_dir: str = "~/.objaverse") -> Dict[str, List[str]]:
-    """Load the LVIS annotations.
+    def load_lvis_annotations(
+        self,
+        download_dir: str = "~/.objaverse",
+    ) -> Dict[str, List[str]]:
+        """Load the LVIS annotations.
 
-    If the annotations are not already downloaded, they will be downloaded.
+        If the annotations are not already downloaded, they will be downloaded.
 
-    Args:
-        download_dir: The base directory to download the annotations to. Supports all
-        file systems supported by fsspec. Defaults to "~/.objaverse".
+        Args:
+            download_dir: The base directory to download the annotations to. Supports all
+            file systems supported by fsspec. Defaults to "~/.objaverse".
 
-    Returns:
-        A dictionary mapping the LVIS category to the list of uids in that category.
-    """
-    hf_url = "https://huggingface.co/datasets/allenai/objaverse/resolve/main/lvis-annotations.json.gz"
+        Returns:
+            A dictionary mapping the LVIS category to the list of uids in that category.
+        """
+        hf_url = "https://huggingface.co/datasets/allenai/objaverse/resolve/main/lvis-annotations.json.gz"
 
-    download_path = os.path.join(
-        download_dir, "hf-objaverse-v1", "lvis-annotations.json.gz"
-    )
+        download_path = os.path.join(
+            download_dir, "hf-objaverse-v1", "lvis-annotations.json.gz"
+        )
 
-    # use fsspec
-    fs, path = fsspec.core.url_to_fs(download_path)
-    if not fs.exists(path):
-        # make dir if it doesn't exist
-        fs.makedirs(os.path.dirname(path), exist_ok=True)
+        # use fsspec
+        fs, path = fsspec.core.url_to_fs(download_path)
+        if not fs.exists(path):
+            # make dir if it doesn't exist
+            fs.makedirs(os.path.dirname(path), exist_ok=True)
 
-        # download the file
-        with fs.open(path, "wb") as f:
-            with urllib.request.urlopen(hf_url) as response:
-                f.write(response.read())
+            # download the file
+            with fs.open(path, "wb") as f:
+                with urllib.request.urlopen(hf_url) as response:
+                    f.write(response.read())
 
-    # load the gzip file
-    with fs.open(path, "rb") as f:
-        with gzip.GzipFile(fileobj=f) as gfile:
-            content = gfile.read()
-            data = json.loads(content)
+        # load the gzip file
+        with fs.open(path, "rb") as f:
+            with gzip.GzipFile(fileobj=f) as gfile:
+                content = gfile.read()
+                data = json.loads(content)
 
-    return data
+        return data