lint updates

objaverse_xl/github.py

@@ -71,12 +71,31 @@ def _get_repo_id_with_hash(item: pd.Series) -> str:
 
 
 def _git_shallow_clone(repo_url: str, target_directory: str) -> bool:
+    """Helper function to shallow clone a repo with git.
+
+    Args:
+        repo_url (str): URL of the repo to clone.
+        target_directory (str): Directory to clone the repo to.
+
+    Returns:
+        bool: True if the clone was successful, False otherwise.
+    """
     return _run_command_with_check(
         ["git", "clone", "--depth", "1", repo_url, target_directory],
     )
 
 
 def _run_command_with_check(command: List[str], cwd: Optional[str] = None) -> bool:
+    """Helper function to run a command and check if it was successful.
+
+    Args:
+        command (List[str]): Command to run.
+        cwd (Optional[str], optional): Current working directory to run the command in.
+            Defaults to None.
+
+    Returns:
+        bool: True if the command was successful, False otherwise.
+    """
     try:
         subprocess.run(
             command,
@@ -94,6 +113,14 @@ def _run_command_with_check(command: List[str], cwd: Optional[str] = None) -> bo
 
 
 def get_file_hash(file_path: str) -> str:
+    """Get the sha256 hash of a file.
+
+    Args:
+        file_path (str): Path to the file.
+
+    Returns:
+        str: sha256 hash of the file.
+    """
     # Check if the path is a symbolic link
     if os.path.islink(file_path):
         # Resolve the symbolic link
@@ -124,12 +151,20 @@ def _process_repo(
     handle_new_object: Optional[Callable],
     commit_hash: Optional[str],
 ) -> List[Dict[str, str]]:
-    """
+    """Process a single repo.
 
     Args:
+        repo_id (str): GitHub repo ID in the format of organization/repo.
+        fs (fsspec.AbstractFileSystem): File system to use for saving the repo.
+        base_dir (str): Base directory to save the repo to.
         expected_objects (Dict[str, str]): Dictionary of objects that one expects to
             find in the repo. Keys are the GitHub URLs and values are the sha256 of the
             objects.
+        {and the rest of the args are the same as download_github_objects}
+
+    Returns:
+        List[Dict[str, str]]: List of dictionaries with the keys "githubUrl" and
+            "sha256" for each downloaded object.
     """
     # NOTE: assuming that the user has already checked that the repo doesn't exist,
     org, repo = repo_id.split("/")
@@ -237,7 +272,9 @@ def _process_repo(
 
         # save the file hashes to a json file
         with open(
-            os.path.join(target_directory, ".objaverse-file-hashes.json"), "w"
+            os.path.join(target_directory, ".objaverse-file-hashes.json"),
+            "w",
+            encoding="utf-8",
         ) as f:
             json.dump(file_hashes, f, indent=2)
 
@@ -299,14 +336,14 @@ def _list_files(root_dir: str) -> List[str]:
 
 def _pull_lfs_files(repo_dir: str) -> None:
     if _has_lfs_files(repo_dir):
-        subprocess.run(["git", "lfs", "pull"], cwd=repo_dir)
+        subprocess.run(["git", "lfs", "pull"], cwd=repo_dir, check=True)
 
 
 def _has_lfs_files(repo_dir: str) -> bool:
     gitattributes_path = os.path.join(repo_dir, ".gitattributes")
     if not os.path.exists(gitattributes_path):
         return False
-    with open(gitattributes_path, "r") as f:
+    with open(gitattributes_path, "r", encoding="utf-8") as f:
         for line in f:
             if "filter=lfs" in line:
                 return True
@@ -316,13 +353,26 @@ def _has_lfs_files(repo_dir: str) -> bool:
 def _get_commit_hash_from_local_git_dir(local_git_dir: str) -> str:
     # get the git hash of the repo
     result = subprocess.run(
-        ["git", "rev-parse", "HEAD"], cwd=local_git_dir, capture_output=True
+        ["git", "rev-parse", "HEAD"], cwd=local_git_dir, capture_output=True, check=True
     )
     commit_hash = result.stdout.strip().decode("utf-8")
     return commit_hash
 
 
 def _parallel_process_repo(args) -> List[Dict[str, str]]:
+    """Helper function to process a repo in parallel.
+
+    Note: This function is used to parallelize the processing of repos. It is not
+    intended to be called directly.
+
+    Args:
+        args (Tuple): Tuple of arguments to pass to _process_repo.
+
+    Returns:
+        List[Dict[str, str]]: List of dictionaries with the keys "githubUrl" and
+            "sha256" for each downloaded object.
+    """
+
     (
         repo_id_hash,
         fs,
@@ -440,9 +490,9 @@ def download_github_objects(
     # Getting immediate subdirectories of root_path
     if save_repo_format == "files":
         downloaded_repo_dirs = fs.glob(base_download_dir + "/repos/*/*/")
-        downloaded_repo_ids = set(
-            ["/".join(x.split("/")[-2:]) for x in downloaded_repo_dirs]
-        )
+        downloaded_repo_ids = {
+            "/".join(x.split("/")[-2:]) for x in downloaded_repo_dirs
+        }
     else:
         downloaded_repo_dirs = fs.glob(
             base_download_dir + f"/repos/*/*.{save_repo_format}"
@@ -460,9 +510,9 @@ def download_github_objects(
     # get the unique repoIds
     objects["repoIdHash"] = objects.apply(_get_repo_id_with_hash, axis=1)
     repo_id_hashes = set(objects["repoIdHash"].unique().tolist())
-    repo_ids = set(
-        ["/".join(repo_id_hash.split("/")[:2]) for repo_id_hash in repo_id_hashes]
-    )
+    repo_ids = {
+        "/".join(repo_id_hash.split("/")[:2]) for repo_id_hash in repo_id_hashes
+    }
     assert len(repo_id_hashes) == len(repo_ids), (
         f"More than 1 commit hash per repoId!"
         f" {len(repo_id_hashes)=}, {len(repo_ids)=}"

objaverse_xl/objaverse_v1.py

@@ -36,22 +36,20 @@ def load_annotations(
     # 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])
+        {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)])
+        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 = 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
-        ]
-    )
+    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")
 
@@ -212,13 +210,11 @@ def load_objects(
     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
-        ]
-    )
+    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 = {}
@@ -285,7 +281,7 @@ def load_lvis_annotations(download_dir: str = "~/.objaverse") -> Dict[str, List[
     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"
+    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"

objaverse_xl/thingiverse.py

@@ -125,9 +125,9 @@ def download_thingiverse_objects(
 
     # check to filter out files that already exist
     existing_files = fs.glob(os.path.join(download_dir, "*.stl"), refresh=True)
-    existing_file_ids = set(
-        [os.path.basename(file).split(".")[0].split("-")[-1] for file in existing_files]
-    )
+    existing_file_ids = {
+        os.path.basename(file).split(".")[0].split("-")[-1] for file in existing_files
+    }
 
     # filter out existing files
     items_to_download = []
@@ -222,8 +222,8 @@ def load_annotations(download_dir: str = "~/.objaverse") -> pd.DataFrame:
     return annotations_df
 
 
-if __name__ == "__main__":
-    # example usage
-    annotations = load_annotations()
-    file_ids = annotations.head(n=100)["fileId"].tolist()
-    download_thingiverse_objects(file_ids=file_ids, processes=5)
+# if __name__ == "__main__":
+#     # example usage
+#     annotations = load_annotations()
+#     file_ids = annotations.head(n=100)["fileId"].tolist()
+#     download_thingiverse_objects(file_ids=file_ids, processes=5)