apply Black 2024 style in fbcode (4/16)

Summary:
Formats the covered files with pyfmt.

paintitblack

Reviewed By: aleivag

Differential Revision: D54447727

fbshipit-source-id: 8844b1caa08de94d04ac4df3c768dbf8c865fd2f

pytorch3d/implicitron/dataset/frame_data.py

@@ -576,11 +576,11 @@ class GenericFrameDataBuilder(FrameDataBuilderBase[FrameDataSubtype], ABC):
             camera_quality_score=safe_as_tensor(
                 sequence_annotation.viewpoint_quality_score, torch.float
             ),
-            point_cloud_quality_score=safe_as_tensor(
-                point_cloud.quality_score, torch.float
-            )
-            if point_cloud is not None
-            else None,
+            point_cloud_quality_score=(
+                safe_as_tensor(point_cloud.quality_score, torch.float)
+                if point_cloud is not None
+                else None
+            ),
         )
 
         fg_mask_np: Optional[np.ndarray] = None

pytorch3d/implicitron/dataset/json_index_dataset.py

@@ -124,9 +124,9 @@ class JsonIndexDataset(DatasetBase, ReplaceableBase):
             dimension of the cropping bounding box, relative to box size.
     """
 
-    frame_annotations_type: ClassVar[
-        Type[types.FrameAnnotation]
-    ] = types.FrameAnnotation
+    frame_annotations_type: ClassVar[Type[types.FrameAnnotation]] = (
+        types.FrameAnnotation
+    )
 
     path_manager: Any = None
     frame_annotations_file: str = ""

pytorch3d/implicitron/dataset/visualize.py

@@ -88,9 +88,11 @@ def get_implicitron_sequence_pointcloud(
             frame_data.camera,
             frame_data.image_rgb,
             frame_data.depth_map,
-            (cast(torch.Tensor, frame_data.fg_probability) > 0.5).float()
-            if mask_points and frame_data.fg_probability is not None
-            else None,
+            (
+                (cast(torch.Tensor, frame_data.fg_probability) > 0.5).float()
+                if mask_points and frame_data.fg_probability is not None
+                else None
+            ),
         )
 
     return point_cloud, frame_data

pytorch3d/implicitron/evaluation/evaluate_new_view_synthesis.py

@@ -282,9 +282,9 @@ def eval_batch(
             image_rgb_masked=image_rgb_masked,
             depth_render=cloned_render["depth_render"],
             depth_map=frame_data.depth_map,
-            depth_mask=frame_data.depth_mask[:1]
-            if frame_data.depth_mask is not None
-            else None,
+            depth_mask=(
+                frame_data.depth_mask[:1] if frame_data.depth_mask is not None else None
+            ),
             visdom_env=visualize_visdom_env,
         )
 

pytorch3d/implicitron/models/generic_model.py

@@ -395,9 +395,11 @@ class GenericModel(ImplicitronModelBase):  # pyre-ignore: 13
         n_targets = (
             1
             if evaluation_mode == EvaluationMode.EVALUATION
-            else batch_size
-            if self.n_train_target_views <= 0
-            else min(self.n_train_target_views, batch_size)
+            else (
+                batch_size
+                if self.n_train_target_views <= 0
+                else min(self.n_train_target_views, batch_size)
+            )
         )
 
         # A helper function for selecting n_target first elements from the input
@@ -422,9 +424,12 @@ class GenericModel(ImplicitronModelBase):  # pyre-ignore: 13
         ray_bundle: ImplicitronRayBundle = self.raysampler(
             target_cameras,
             evaluation_mode,
-            mask=mask_crop[:n_targets]
-            if mask_crop is not None and sampling_mode == RenderSamplingMode.MASK_SAMPLE
-            else None,
+            mask=(
+                mask_crop[:n_targets]
+                if mask_crop is not None
+                and sampling_mode == RenderSamplingMode.MASK_SAMPLE
+                else None
+            ),
         )
 
         # custom_args hold additional arguments to the implicit function.

pytorch3d/implicitron/models/implicit_function/idr_feature_field.py

@@ -102,9 +102,7 @@ class IdrFeatureField(ImplicitFunctionBase, torch.nn.Module):
                 elif self.n_harmonic_functions_xyz >= 0 and layer_idx == 0:
                     torch.nn.init.constant_(lin.bias, 0.0)
                     torch.nn.init.constant_(lin.weight[:, 3:], 0.0)
-                    torch.nn.init.normal_(
-                        lin.weight[:, :3], 0.0, 2**0.5 / out_dim**0.5
-                    )
+                    torch.nn.init.normal_(lin.weight[:, :3], 0.0, 2**0.5 / out_dim**0.5)
                 elif self.n_harmonic_functions_xyz >= 0 and layer_idx in self.skip_in:
                     torch.nn.init.constant_(lin.bias, 0.0)
                     torch.nn.init.normal_(lin.weight, 0.0, 2**0.5 / out_dim**0.5)

pytorch3d/implicitron/models/implicit_function/neural_radiance_field.py

@@ -193,9 +193,9 @@ class NeuralRadianceFieldBase(ImplicitFunctionBase, torch.nn.Module):
         embeds = create_embeddings_for_implicit_function(
             xyz_world=rays_points_world,
             #  for 2nd param but got `Union[None, torch.Tensor, torch.nn.Module]`.
-            xyz_embedding_function=self.harmonic_embedding_xyz
-            if self.input_xyz
-            else None,
+            xyz_embedding_function=(
+                self.harmonic_embedding_xyz if self.input_xyz else None
+            ),
             global_code=global_code,
             fun_viewpool=fun_viewpool,
             xyz_in_camera_coords=self.xyz_ray_dir_in_camera_coords,

pytorch3d/implicitron/models/overfit_model.py

@@ -356,9 +356,12 @@ class OverfitModel(ImplicitronModelBase):  # pyre-ignore: 13
         ray_bundle: ImplicitronRayBundle = self.raysampler(
             camera,
             evaluation_mode,
-            mask=mask_crop
-            if mask_crop is not None and sampling_mode == RenderSamplingMode.MASK_SAMPLE
-            else None,
+            mask=(
+                mask_crop
+                if mask_crop is not None
+                and sampling_mode == RenderSamplingMode.MASK_SAMPLE
+                else None
+            ),
         )
 
         inputs_to_be_chunked = {}
@@ -381,10 +384,12 @@ class OverfitModel(ImplicitronModelBase):  # pyre-ignore: 13
                 frame_timestamp=frame_timestamp,
             )
             implicit_functions = [
-                functools.partial(implicit_function, global_code=global_code)
-                if isinstance(implicit_function, Callable)
-                else functools.partial(
-                    implicit_function.forward, global_code=global_code
+                (
+                    functools.partial(implicit_function, global_code=global_code)
+                    if isinstance(implicit_function, Callable)
+                    else functools.partial(
+                        implicit_function.forward, global_code=global_code
+                    )
                 )
                 for implicit_function in implicit_functions
             ]

pytorch3d/implicitron/models/renderer/ray_sampler.py

@@ -145,10 +145,12 @@ class AbstractMaskRaySampler(RaySamplerBase, torch.nn.Module):
             n_pts_per_ray=n_pts_per_ray_training,
             min_depth=0.0,
             max_depth=0.0,
-            n_rays_per_image=self.n_rays_per_image_sampled_from_mask
-            if self._sampling_mode[EvaluationMode.TRAINING]
-            == RenderSamplingMode.MASK_SAMPLE
-            else None,
+            n_rays_per_image=(
+                self.n_rays_per_image_sampled_from_mask
+                if self._sampling_mode[EvaluationMode.TRAINING]
+                == RenderSamplingMode.MASK_SAMPLE
+                else None
+            ),
             n_rays_total=self.n_rays_total_training,
             unit_directions=True,
             stratified_sampling=self.stratified_point_sampling_training,
@@ -160,10 +162,12 @@ class AbstractMaskRaySampler(RaySamplerBase, torch.nn.Module):
             n_pts_per_ray=n_pts_per_ray_evaluation,
             min_depth=0.0,
             max_depth=0.0,
-            n_rays_per_image=self.n_rays_per_image_sampled_from_mask
-            if self._sampling_mode[EvaluationMode.EVALUATION]
-            == RenderSamplingMode.MASK_SAMPLE
-            else None,
+            n_rays_per_image=(
+                self.n_rays_per_image_sampled_from_mask
+                if self._sampling_mode[EvaluationMode.EVALUATION]
+                == RenderSamplingMode.MASK_SAMPLE
+                else None
+            ),
             unit_directions=True,
             stratified_sampling=self.stratified_point_sampling_evaluation,
         )

pytorch3d/implicitron/models/renderer/ray_tracing.py

@@ -415,7 +415,7 @@ class RayTracing(Configurable, nn.Module):
             ]
             sampler_dists[mask_intersect_idx[p_out_mask]] = pts_intervals[
                 p_out_mask,
-                :
+                :,
                 # pyre-fixme[6]: For 1st param expected `Union[bool, float, int]` but
                 #  got `Tensor`.
             ][torch.arange(n_p_out), out_pts_idx]

pytorch3d/implicitron/models/renderer/sdf_renderer.py

@@ -43,9 +43,9 @@ class SignedDistanceFunctionRenderer(BaseRenderer, torch.nn.Module):  # pyre-ign
 
         run_auto_creation(self)
 
-        self.ray_normal_coloring_network_args[
-            "feature_vector_size"
-        ] = render_features_dimensions
+        self.ray_normal_coloring_network_args["feature_vector_size"] = (
+            render_features_dimensions
+        )
         self._rgb_network = RayNormalColoringNetwork(
             **self.ray_normal_coloring_network_args
         )
@@ -201,15 +201,15 @@ class SignedDistanceFunctionRenderer(BaseRenderer, torch.nn.Module):  # pyre-ign
                 None, :, 0, :
             ]
             normals_full.view(-1, 3)[surface_mask] = normals
-            render_full.view(-1, self.render_features_dimensions)[
-                surface_mask
-            ] = self._rgb_network(
-                features,
-                differentiable_surface_points[None],
-                normals,
-                ray_bundle,
-                surface_mask[None, :, None],
-                pooling_fn=None,  # TODO
+            render_full.view(-1, self.render_features_dimensions)[surface_mask] = (
+                self._rgb_network(
+                    features,
+                    differentiable_surface_points[None],
+                    normals,
+                    ray_bundle,
+                    surface_mask[None, :, None],
+                    pooling_fn=None,  # TODO
+                )
             )
             mask_full.view(-1, 1)[~surface_mask] = torch.sigmoid(
                 # pyre-fixme[6]: For 1st param expected `Tensor` but got `float`.

pytorch3d/implicitron/tools/config.py

@@ -241,9 +241,9 @@ class _Registry:
     """
 
     def __init__(self) -> None:
-        self._mapping: Dict[
-            Type[ReplaceableBase], Dict[str, Type[ReplaceableBase]]
-        ] = defaultdict(dict)
+        self._mapping: Dict[Type[ReplaceableBase], Dict[str, Type[ReplaceableBase]]] = (
+            defaultdict(dict)
+        )
 
     def register(self, some_class: Type[_X]) -> Type[_X]:
         """

pytorch3d/implicitron/tools/eval_video_trajectory.py

@@ -139,9 +139,11 @@ def generate_eval_video_cameras(
         fit = fit_circle_in_3d(
             cam_centers,
             angles=angle,
-            offset=angle.new_tensor(traj_offset_canonical)
-            if traj_offset_canonical is not None
-            else None,
+            offset=(
+                angle.new_tensor(traj_offset_canonical)
+                if traj_offset_canonical is not None
+                else None
+            ),
             up=angle.new_tensor(up),
         )
         traj = fit.generated_points

pytorch3d/implicitron/tools/utils.py

@@ -146,9 +146,11 @@ def cat_dataclass(batch, tensor_collator: Callable):
             )
         elif isinstance(elem_f, collections.abc.Mapping):
             collated[f.name] = {
-                k: tensor_collator([getattr(e, f.name)[k] for e in batch])
-                if elem_f[k] is not None
-                else None
+                k: (
+                    tensor_collator([getattr(e, f.name)[k] for e in batch])
+                    if elem_f[k] is not None
+                    else None
+                )
                 for k in elem_f
             }
         else:

pytorch3d/renderer/fisheyecameras.py

@@ -81,7 +81,6 @@ class FishEyeCameras(CamerasBase):
         device: Device = "cpu",
         image_size: Optional[Union[List, Tuple, torch.Tensor]] = None,
     ) -> None:
-
         """
 
         Args:

pytorch3d/renderer/mesh/clip.py

@@ -712,9 +712,9 @@ def convert_clipped_rasterization_to_original_faces(
         )
 
         bary_coords_unclipped_subset = bary_coords_unclipped_subset.reshape([N * 3])
-        bary_coords_unclipped[
-            faces_to_convert_mask_expanded
-        ] = bary_coords_unclipped_subset
+        bary_coords_unclipped[faces_to_convert_mask_expanded] = (
+            bary_coords_unclipped_subset
+        )
 
         # dists for case 4 faces will be handled in the rasterizer
         # so no need to modify them here.

pytorch3d/renderer/mesh/rasterize_meshes.py

@@ -605,7 +605,10 @@ def rasterize_meshes_python(  # noqa: C901
         # If faces were clipped, map the rasterization result to be in terms of the
         # original unclipped faces.  This may involve converting barycentric
         # coordinates
-        (face_idxs, bary_coords,) = convert_clipped_rasterization_to_original_faces(
+        (
+            face_idxs,
+            bary_coords,
+        ) = convert_clipped_rasterization_to_original_faces(
             face_idxs,
             bary_coords,
             # pyre-fixme[61]: `clipped_faces` may not be initialized here.

pytorch3d/renderer/opengl/__init__.py

@@ -4,6 +4,7 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+
 # If we can access EGL, import MeshRasterizerOpenGL.
 def _can_import_egl_and_pycuda():
     import os

pytorch3d/renderer/opengl/rasterizer_opengl.py

@@ -292,9 +292,11 @@ class _OpenGLMachinery:
                 pix_to_face, bary_coord, zbuf = self._rasterize_mesh(
                     mesh,
                     image_size,
-                    projection_matrix=projection_matrix[mesh_id]
-                    if projection_matrix.shape[0] > 1
-                    else None,
+                    projection_matrix=(
+                        projection_matrix[mesh_id]
+                        if projection_matrix.shape[0] > 1
+                        else None
+                    ),
                 )
                 pix_to_faces.append(pix_to_face)
                 bary_coords.append(bary_coord)