Consolidate repr

references/classification/transforms.py

@@ -72,13 +72,15 @@ def forward(self, batch: Tensor, target: Tensor) -> Tuple[Tensor, Tensor]:
         return batch, target
 
     def __repr__(self) -> str:
-        s = self.__class__.__name__ + "("
-        s += "num_classes={num_classes}"
-        s += ", p={p}"
-        s += ", alpha={alpha}"
-        s += ", inplace={inplace}"
-        s += ")"
-        return s.format(**self.__dict__)
+        s = (
+            f"{self.__class__.__name__}("
+            f"num_classes={self.num_classes}"
+            f", p={self.p}"
+            f", alpha={self.alpha}"
+            f", inplace={self.inplace}"
+            f")"
+        )
+        return s
 
 
 class RandomCutmix(torch.nn.Module):
@@ -162,10 +164,12 @@ def forward(self, batch: Tensor, target: Tensor) -> Tuple[Tensor, Tensor]:
         return batch, target
 
     def __repr__(self) -> str:
-        s = self.__class__.__name__ + "("
-        s += "num_classes={num_classes}"
-        s += ", p={p}"
-        s += ", alpha={alpha}"
-        s += ", inplace={inplace}"
-        s += ")"
-        return s.format(**self.__dict__)
+        s = (
+            f"{self.__class__.__name__}("
+            f"num_classes={self.num_classes}"
+            f", p={self.p}"
+            f", alpha={self.alpha}"
+            f", inplace={self.inplace}"
+            f")"
+        )
+        return s

test/test_datasets_download.py

@@ -180,7 +180,7 @@ def __init__(self, url, md5=None, id=None):
         self.md5 = md5
         self.id = id or url
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self.id
 
 

torchvision/models/detection/anchor_utils.py

@@ -239,13 +239,15 @@ def _grid_default_boxes(
         return torch.cat(default_boxes, dim=0)
 
     def __repr__(self) -> str:
-        s = self.__class__.__name__ + "("
-        s += "aspect_ratios={aspect_ratios}"
-        s += ", clip={clip}"
-        s += ", scales={scales}"
-        s += ", steps={steps}"
-        s += ")"
-        return s.format(**self.__dict__)
+        s = (
+            f"{self.__class__.__name__}("
+            f"aspect_ratios={self.aspect_ratios}"
+            f", clip={self.clip}"
+            f", scales={self.scales}"
+            f", steps={self.steps}"
+            ")"
+        )
+        return s
 
     def forward(self, image_list: ImageList, feature_maps: List[Tensor]) -> List[Tensor]:
         grid_sizes = [feature_map.shape[-2:] for feature_map in feature_maps]

torchvision/models/detection/transform.py

@@ -260,7 +260,7 @@ def postprocess(
         return result
 
     def __repr__(self) -> str:
-        format_string = self.__class__.__name__ + "("
+        format_string = f"{self.__class__.__name__}("
         _indent = "\n    "
         format_string += f"{_indent}Normalize(mean={self.image_mean}, std={self.image_std})"
         format_string += f"{_indent}Resize(min_size={self.min_size}, max_size={self.max_size}, mode='bilinear')"

torchvision/models/efficientnet.py

@@ -61,15 +61,17 @@ def __init__(
         self.num_layers = self.adjust_depth(num_layers, depth_mult)
 
     def __repr__(self) -> str:
-        s = self.__class__.__name__ + "("
-        s += "expand_ratio={expand_ratio}"
-        s += ", kernel={kernel}"
-        s += ", stride={stride}"
-        s += ", input_channels={input_channels}"
-        s += ", out_channels={out_channels}"
-        s += ", num_layers={num_layers}"
-        s += ")"
-        return s.format(**self.__dict__)
+        s = (
+            f"{self.__class__.__name__}("
+            f"expand_ratio={self.expand_ratio}"
+            f", kernel={self.kernel}"
+            f", stride={self.stride}"
+            f", input_channels={self.input_channels}"
+            f", out_channels={self.out_channels}"
+            f", num_layers={self.num_layers}"
+            f")"
+        )
+        return s
 
     @staticmethod
     def adjust_channels(channels: int, width_mult: float, min_value: Optional[int] = None) -> int:

torchvision/ops/deform_conv.py

@@ -179,14 +179,17 @@ def forward(self, input: Tensor, offset: Tensor, mask: Optional[Tensor] = None)
         )
 
     def __repr__(self) -> str:
-        s = self.__class__.__name__ + "("
-        s += "{in_channels}"
-        s += ", {out_channels}"
-        s += ", kernel_size={kernel_size}"
-        s += ", stride={stride}"
-        s += ", padding={padding}" if self.padding != (0, 0) else ""
-        s += ", dilation={dilation}" if self.dilation != (1, 1) else ""
-        s += ", groups={groups}" if self.groups != 1 else ""
+        s = (
+            f"{self.__class__.__name__}("
+            f"{self.in_channels}"
+            f", {self.out_channels}"
+            f", kernel_size={self.kernel_size}"
+            f", stride={self.stride}"
+        )
+        s += f", padding={self.padding}" if self.padding != (0, 0) else ""
+        s += f", dilation={self.dilation}" if self.dilation != (1, 1) else ""
+        s += f", groups={self.groups}" if self.groups != 1 else ""
         s += ", bias=False" if self.bias is None else ""
         s += ")"
-        return s.format(**self.__dict__)
+
+        return s

torchvision/ops/ps_roi_align.py

@@ -78,9 +78,11 @@ def forward(self, input: Tensor, rois: Tensor) -> Tensor:
         return ps_roi_align(input, rois, self.output_size, self.spatial_scale, self.sampling_ratio)
 
     def __repr__(self) -> str:
-        tmpstr = self.__class__.__name__ + "("
-        tmpstr += "output_size=" + str(self.output_size)
-        tmpstr += ", spatial_scale=" + str(self.spatial_scale)
-        tmpstr += ", sampling_ratio=" + str(self.sampling_ratio)
-        tmpstr += ")"
-        return tmpstr
+        s = (
+            f"{self.__class__.__name__}("
+            f"output_size={self.output_size}"
+            f", spatial_scale={self.spatial_scale}"
+            f", sampling_ratio={self.sampling_ratio}"
+            f")"
+        )
+        return s

torchvision/ops/ps_roi_pool.py

@@ -64,8 +64,5 @@ def forward(self, input: Tensor, rois: Tensor) -> Tensor:
         return ps_roi_pool(input, rois, self.output_size, self.spatial_scale)
 
     def __repr__(self) -> str:
-        tmpstr = self.__class__.__name__ + "("
-        tmpstr += "output_size=" + str(self.output_size)
-        tmpstr += ", spatial_scale=" + str(self.spatial_scale)
-        tmpstr += ")"
-        return tmpstr
+        s = f"{self.__class__.__name__}(output_size={self.output_size}, spatial_scale={self.spatial_scale})"
+        return s

torchvision/ops/roi_align.py

@@ -86,10 +86,12 @@ def forward(self, input: Tensor, rois: Tensor) -> Tensor:
         return roi_align(input, rois, self.output_size, self.spatial_scale, self.sampling_ratio, self.aligned)
 
     def __repr__(self) -> str:
-        tmpstr = self.__class__.__name__ + "("
-        tmpstr += "output_size=" + str(self.output_size)
-        tmpstr += ", spatial_scale=" + str(self.spatial_scale)
-        tmpstr += ", sampling_ratio=" + str(self.sampling_ratio)
-        tmpstr += ", aligned=" + str(self.aligned)
-        tmpstr += ")"
-        return tmpstr
+        s = (
+            f"{self.__class__.__name__}("
+            f"output_size={self.output_size}"
+            f", spatial_scale={self.spatial_scale}"
+            f", sampling_ratio={self.sampling_ratio}"
+            f", aligned={self.aligned}"
+            f")"
+        )
+        return s

torchvision/ops/roi_pool.py

@@ -66,8 +66,5 @@ def forward(self, input: Tensor, rois: Tensor) -> Tensor:
         return roi_pool(input, rois, self.output_size, self.spatial_scale)
 
     def __repr__(self) -> str:
-        tmpstr = self.__class__.__name__ + "("
-        tmpstr += "output_size=" + str(self.output_size)
-        tmpstr += ", spatial_scale=" + str(self.spatial_scale)
-        tmpstr += ")"
-        return tmpstr
+        s = f"{self.__class__.__name__}(output_size={self.output_size}, spatial_scale={self.spatial_scale})"
+        return s

torchvision/ops/stochastic_depth.py

@@ -62,8 +62,5 @@ def forward(self, input: Tensor) -> Tensor:
         return stochastic_depth(input, self.p, self.mode, self.training)
 
     def __repr__(self) -> str:
-        tmpstr = self.__class__.__name__ + "("
-        tmpstr += "p=" + str(self.p)
-        tmpstr += ", mode=" + str(self.mode)
-        tmpstr += ")"
-        return tmpstr
+        s = f"{self.__class__.__name__}(p={self.p}, mode={self.mode})"
+        return s

torchvision/prototype/features/_feature.py

@@ -96,5 +96,5 @@ def __torch_function__(
 
         return cls(output, like=args[0])
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return torch.Tensor.__repr__(self).replace("tensor", type(self).__name__)

torchvision/prototype/models/_api.py

@@ -67,7 +67,7 @@ def from_str(cls, value: str) -> "WeightsEnum":
     def get_state_dict(self, progress: bool) -> OrderedDict:
         return load_state_dict_from_url(self.url, progress=progress)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__.__name__}.{self._name_}"
 
     def __getattr__(self, name):

torchvision/transforms/_transforms_video.py

@@ -46,8 +46,8 @@ def __call__(self, clip):
         i, j, h, w = self.get_params(clip, self.size)
         return F.crop(clip, i, j, h, w)
 
-    def __repr__(self):
-        return self.__class__.__name__ + f"(size={self.size})"
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(size={self.size})"
 
 
 class RandomResizedCropVideo(RandomResizedCrop):
@@ -79,11 +79,8 @@ def __call__(self, clip):
         i, j, h, w = self.get_params(clip, self.scale, self.ratio)
         return F.resized_crop(clip, i, j, h, w, self.size, self.interpolation_mode)
 
-    def __repr__(self):
-        return (
-            self.__class__.__name__
-            + f"(size={self.size}, interpolation_mode={self.interpolation_mode}, scale={self.scale}, ratio={self.ratio})"
-        )
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(size={self.size}, interpolation_mode={self.interpolation_mode}, scale={self.scale}, ratio={self.ratio})"
 
 
 class CenterCropVideo:
@@ -103,8 +100,8 @@ def __call__(self, clip):
         """
         return F.center_crop(clip, self.crop_size)
 
-    def __repr__(self):
-        return self.__class__.__name__ + f"(crop_size={self.crop_size})"
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(crop_size={self.crop_size})"
 
 
 class NormalizeVideo:
@@ -128,8 +125,8 @@ def __call__(self, clip):
         """
         return F.normalize(clip, self.mean, self.std, self.inplace)
 
-    def __repr__(self):
-        return self.__class__.__name__ + f"(mean={self.mean}, std={self.std}, inplace={self.inplace})"
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(mean={self.mean}, std={self.std}, inplace={self.inplace})"
 
 
 class ToTensorVideo:
@@ -150,7 +147,7 @@ def __call__(self, clip):
         """
         return F.to_tensor(clip)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self.__class__.__name__
 
 
@@ -175,5 +172,5 @@ def __call__(self, clip):
             clip = F.hflip(clip)
         return clip
 
-    def __repr__(self):
-        return self.__class__.__name__ + f"(p={self.p})"
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(p={self.p})"

torchvision/transforms/autoaugment.py

@@ -280,7 +280,7 @@ def forward(self, img: Tensor) -> Tensor:
         return img
 
     def __repr__(self) -> str:
-        return self.__class__.__name__ + f"(policy={self.policy}, fill={self.fill})"
+        return f"{self.__class__.__name__}(policy={self.policy}, fill={self.fill})"
 
 
 class RandAugment(torch.nn.Module):
@@ -363,14 +363,16 @@ def forward(self, img: Tensor) -> Tensor:
         return img
 
     def __repr__(self) -> str:
-        s = self.__class__.__name__ + "("
-        s += "num_ops={num_ops}"
-        s += ", magnitude={magnitude}"
-        s += ", num_magnitude_bins={num_magnitude_bins}"
-        s += ", interpolation={interpolation}"
-        s += ", fill={fill}"
-        s += ")"
-        return s.format(**self.__dict__)
+        s = (
+            f"{self.__class__.__name__}("
+            f"num_ops={self.num_ops}"
+            f", magnitude={self.magnitude}"
+            f", num_magnitude_bins={self.num_magnitude_bins}"
+            f", interpolation={self.interpolation}"
+            f", fill={self.fill}"
+            f")"
+        )
+        return s
 
 
 class TrivialAugmentWide(torch.nn.Module):
@@ -448,9 +450,11 @@ def forward(self, img: Tensor) -> Tensor:
         return _apply_op(img, op_name, magnitude, interpolation=self.interpolation, fill=fill)
 
     def __repr__(self) -> str:
-        s = self.__class__.__name__ + "("
-        s += "num_magnitude_bins={num_magnitude_bins}"
-        s += ", interpolation={interpolation}"
-        s += ", fill={fill}"
-        s += ")"
-        return s.format(**self.__dict__)
+        s = (
+            f"{self.__class__.__name__}("
+            f"num_magnitude_bins={self.num_magnitude_bins}"
+            f", interpolation={self.interpolation}"
+            f", fill={self.fill}"
+            f")"
+        )
+        return s