add fsspec'd objaverse v1 script

objaverse_xl/objaverse_v1.py

@@ -0,0 +1,296 @@
+import gzip
+import json
+import os
+import urllib.request
+from multiprocessing import Pool
+from typing import Any, Dict, List, Optional, Tuple
+
+import fsspec
+from loguru import logger
+from tqdm import tqdm
+
+
+def load_annotations(
+    uids: Optional[List[str]] = None,
+    download_dir: str = "~/.objaverse",
+) -> List[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 list of dictionaries with 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 = (
+        set([object_paths[uid].split("/")[1] for uid in uids])
+        if uids is not None
+        else set([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 = set([
+        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 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)
+
+        # 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())
+
+
+def _download_object(
+    uid: str,
+    hf_object_path: str,
+    download_dir: str,
+) -> Tuple[str, str]:
+    """Download the object for the given uid.
+
+    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".
+
+    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(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 = set([
+        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.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 - 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
+
+    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
+        ]
+
+        # download the objects in parallel
+        with Pool(download_processes) as pool:
+            new_object_downloads = list(
+                tqdm(pool.imap_unordered(_parallel_download_object, args), total=len(args))
+            )
+
+        for uid, local_path in new_object_downloads:
+            out[uid] = local_path
+
+    return out
+
+
+def load_lvis_annotations(download_dir: str = "~/.objaverse") -> Dict[str, List[str]]:
+    """Load the LVIS annotations.
+
+    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".
+
+    Returns:
+        A dictionary mapping the LVIS category to the list of uids in that category.
+    """
+    hf_url = f"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")
+
+    # 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())
+
+    # 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

objaverse_xl/smithsonian.py

@@ -1,6 +1,5 @@
 import multiprocessing
 import os
-import uuid
 from functools import partial
 from multiprocessing import Pool
 from typing import Dict, List, Optional
@@ -13,65 +12,59 @@ from tqdm import tqdm
 from utils import get_uid_from_str
 
 
-def load_smithsonian_metadata(
-    download_dir: str = "~/.objaverse-xl",
-) -> pd.DataFrame:
+def load_smithsonian_metadata(download_dir: str = "~/.objaverse") -> pd.DataFrame:
     """Loads the Smithsonian Object Metadata dataset as a Pandas DataFrame.
 
     Args:
         download_dir (str, optional): Directory to download the parquet metadata file.
-            Supports all file systems supported by fsspec. Defaults to
-            "~/.objaverse-xl".
+            Supports all file systems supported by fsspec. Defaults to "~/.objaverse".
 
     Returns:
         pd.DataFrame: Smithsonian Object Metadata dataset as a Pandas DataFrame with
             columns for the object "title", "url", "quality", "file_type", "uid", and
             "license". The quality is always Medium and the file_type is always glb.
     """
-    dirname = os.path.expanduser(os.path.join(download_dir, "smithsonian"))
-    filename = os.path.join(dirname, "object-metadata.parquet")
+    filename = os.path.join(download_dir, "smithsonian", "object-metadata.parquet")
     fs, path = fsspec.core.url_to_fs(filename)
-    if fs.protocol == "file":
-        os.makedirs(dirname, exist_ok=True)
+    fs.makedirs(os.path.dirname(path), exist_ok=True)
 
-    if fs.exists(filename):
-        df = pd.read_parquet(filename)
-        return df
-    else:
+    # download the parquet file if it doesn't exist
+    if not fs.exists(path):
         url = "https://huggingface.co/datasets/allenai/objaverse-xl/resolve/main/smithsonian/object-metadata.parquet"
         response = requests.get(url)
         response.raise_for_status()
-        with fs.open(filename, "wb") as file:
+        with fs.open(path, "wb") as file:
             file.write(response.content)
-        df = pd.read_parquet(filename)
 
+    # load the parquet file with fsspec
+    with fs.open(path) as f:
+        df = pd.read_parquet(f)
+
+    # add uid and license columns
     df["uid"] = df["url"].apply(get_uid_from_str)
     df["license"] = "CC0"
+
     return df
 
 
-def download_smithsonian_object(url: str, download_dir: str = "~/.objaverse-xl") -> str:
+def download_smithsonian_object(url: str, download_dir: str = "~/.objaverse") -> str:
     """Downloads a Smithsonian Object from a URL.
 
     Args:
         url (str): URL to download the Smithsonian Object from.
         download_dir (str, optional): Directory to download the Smithsonian Object to.
-            Supports all file systems supported by fsspec. Defaults to
-            "~/.objaverse-xl".
+            Supports all file systems supported by fsspec. Defaults to "~/.objaverse".
 
     Returns:
         str: Path to the downloaded Smithsonian Object.
     """
     uid = get_uid_from_str(url)
 
-    dirname = os.path.expanduser(os.path.join(download_dir, "smithsonian", "objects"))
-    filename = os.path.join(dirname, f"{uid}.glb")
+    filename = os.path.join(download_dir, "smithsonian", "objects", f"{uid}.glb")
     fs, path = fsspec.core.url_to_fs(filename)
-    if fs.protocol == "file":
-        os.makedirs(dirname, exist_ok=True)
+    fs.makedirs(os.path.dirname(path), exist_ok=True)
 
-    if not fs.exists(filename):
-        tmp_path = os.path.join(dirname, f"{uid}.glb.tmp")
+    if not fs.exists(path):
         response = requests.get(url)
 
         # check if the path is valid
@@ -79,13 +72,14 @@ def download_smithsonian_object(url: str, download_dir: str = "~/.objaverse-xl")
             logger.warning(f"404 for {url}")
             return None
 
-        # write to tmp path
+        # write to tmp path so that we don't have a partial file
+        tmp_path = f"{path}.tmp"
         with fs.open(tmp_path, "wb") as file:
             for chunk in response.iter_content(chunk_size=8192):
                 file.write(chunk)
 
         # rename to final path
-        fs.rename(tmp_path, filename)
+        fs.rename(tmp_path, path)
 
     return filename
 
@@ -93,7 +87,7 @@ def download_smithsonian_object(url: str, download_dir: str = "~/.objaverse-xl")
 def download_smithsonian_objects(
     urls: Optional[str] = None,
     processes: Optional[int] = None,
-    download_dir: str = "~/.objaverse-xl",
+    download_dir: str = "~/.objaverse",
 ) -> List[Dict[str, str]]:
     """Downloads all Smithsonian Objects.
 
@@ -105,8 +99,7 @@ def download_smithsonian_objects(
             number of CPUs on the machine (multiprocessing.cpu_count()). Defaults to
             None.
         download_dir (str, optional): Directory to download the Smithsonian Objects to.
-            Supports all file systems supported by fsspec. Defaults to
-            "~/.objaverse-xl".
+            Supports all file systems supported by fsspec. Defaults to "~/.objaverse".
 
     Returns:
         List[Dict[str, str]]: List of dictionaries with keys "download_path" and "url"