enable ruff d103 (kornia#3096)

* RUFF: D417
* Add doc strings for missing arguments detected

* RUFF: Fix some improper doc string formats.

* Fix typo.

* Non-functional change:
* Don't download during doc test to avoid flaky failure

* RUFF: Minimally address D103

* Fix incorrect clamp

Author: ntjohnson1

conftest.py

@@ -71,16 +71,19 @@ def get_test_dtypes() -> dict[str, torch.dtype]:
 
 @pytest.fixture()
 def device(device_name) -> torch.device:
+    """Return device for testing."""
     return TEST_DEVICES[device_name]
 
 
 @pytest.fixture()
 def dtype(dtype_name) -> torch.dtype:
+    """Return dtype for testing."""
     return TEST_DTYPES[dtype_name]
 
 
 @pytest.fixture()
 def torch_optimizer(optimizer_backend):
+    """Return torch optimizer."""
     if not optimizer_backend:
         return lambda x: x
 
@@ -102,6 +105,7 @@ def torch_optimizer(optimizer_backend):
 
 
 def pytest_generate_tests(metafunc):
+    """Generate tests."""
     device_names = None
     dtype_names = None
     optimizer_backends_names = None
@@ -151,6 +155,7 @@ def pytest_generate_tests(metafunc):
 
 
 def pytest_collection_modifyitems(config, items):
+    """Collect test options."""
     if config.getoption("--runslow"):
         # --runslow given in cli: do not skip slow tests
         return
@@ -162,6 +167,7 @@ def pytest_collection_modifyitems(config, items):
 
 
 def pytest_addoption(parser):
+    """Add options."""
     parser.addoption("--device", action="store", default="cpu")
     parser.addoption("--dtype", action="store", default="float32")
     parser.addoption("--optimizer", action="store", default="inductor")
@@ -188,6 +194,7 @@ def forward(self, x):
 
 
 def pytest_sessionstart(session):
+    """Start pytest session."""
     try:
         _setup_torch_compile()
     except RuntimeError as ex:
@@ -248,6 +255,7 @@ def _get_gpu_info() -> dict[str, str]:
 
 
 def pytest_report_header(config):
+    """Return report header."""
     try:
         import accelerate
 
@@ -292,6 +300,7 @@ def pytest_report_header(config):
 
 @pytest.fixture(autouse=True)
 def add_doctest_deps(doctest_namespace):
+    """Add dependencies for doctests."""
     doctest_namespace["np"] = np
     doctest_namespace["torch"] = torch
     doctest_namespace["kornia"] = kornia
@@ -305,6 +314,7 @@ def add_doctest_deps(doctest_namespace):
 
 @pytest.fixture(scope="session")
 def data(request):
+    """Return loaded data."""
     url = {
         "loftr_homo": f"https://github.com/kornia/data_test/blob/{sha}/loftr_outdoor_and_homography_data.pt?raw=true",
         "loftr_fund": f"https://github.com/kornia/data_test/blob/{sha}/loftr_indoor_and_fundamental_data.pt?raw=true",

kornia/augmentation/auto/autoaugment/ops.py

@@ -21,6 +21,7 @@
 
 
 def shear_x(probability: float, magnitude: int) -> OperationBase:
+    """Return ShearX op."""
     magnitudes = linspace(-0.3, 0.3, 11) * 180.0
     return ShearX(
         None,
@@ -31,6 +32,7 @@ def shear_x(probability: float, magnitude: int) -> OperationBase:
 
 
 def shear_y(probability: float, magnitude: int) -> OperationBase:
+    """Return ShearY op."""
     magnitudes = linspace(-0.3, 0.3, 11) * 180.0
     return ShearY(
         None,
@@ -41,6 +43,7 @@ def shear_y(probability: float, magnitude: int) -> OperationBase:
 
 
 def translate_x(probability: float, magnitude: int) -> OperationBase:
+    """Return TranslateX op."""
     magnitudes = linspace(-0.5, 0.5, 11)
     return TranslateX(
         None,
@@ -51,6 +54,7 @@ def translate_x(probability: float, magnitude: int) -> OperationBase:
 
 
 def translate_y(probability: float, magnitude: int) -> OperationBase:
+    """Return TranslateY op."""
     magnitudes = linspace(-0.5, 0.5, 11)
     return TranslateY(
         None,
@@ -61,6 +65,7 @@ def translate_y(probability: float, magnitude: int) -> OperationBase:
 
 
 def rotate(probability: float, magnitude: int) -> OperationBase:
+    """Return rotate op."""
     magnitudes = linspace(-30, 30, 11)
     return Rotate(
         None,
@@ -71,48 +76,57 @@ def rotate(probability: float, magnitude: int) -> OperationBase:
 
 
 def auto_contrast(probability: float, _: int) -> OperationBase:
+    """Return AutoConstrast op."""
     return AutoContrast(probability)
 
 
 def invert(probability: float, _: int) -> OperationBase:
+    """Return invert op."""
     return Invert(probability)
 
 
 def equalize(probability: float, _: int) -> OperationBase:
+    """Return equalize op."""
     return Equalize(probability)
 
 
 def solarize(probability: float, magnitude: int) -> OperationBase:
+    """Return solarize op."""
     magnitudes = linspace(0, 255, 11) / 255.0
     return Solarize(None, probability, magnitude_range=(magnitudes[magnitude].item(), magnitudes[magnitude + 1].item()))
 
 
 def posterize(probability: float, magnitude: int) -> OperationBase:
+    """Return posterize op."""
     magnitudes = linspace(4, 8, 11)
     return Posterize(
         None, probability, magnitude_range=(magnitudes[magnitude].item(), magnitudes[magnitude + 1].item())
     )
 
 
 def contrast(probability: float, magnitude: int) -> OperationBase:
+    """Return contrast op."""
     magnitudes = linspace(0.1, 1.9, 11)
     return Contrast(None, probability, magnitude_range=(magnitudes[magnitude].item(), magnitudes[magnitude + 1].item()))
 
 
 def brightness(probability: float, magnitude: int) -> OperationBase:
+    """Return brightness op."""
     magnitudes = linspace(0.1, 1.9, 11)
     return Brightness(
         None, probability, magnitude_range=(magnitudes[magnitude].item(), magnitudes[magnitude + 1].item())
     )
 
 
 def sharpness(probability: float, magnitude: int) -> OperationBase:
+    """Return sharpness op."""
     magnitudes = linspace(0.1, 1.9, 11)
     return Sharpness(
         None, probability, magnitude_range=(magnitudes[magnitude].item(), magnitudes[magnitude + 1].item())
     )
 
 
 def color(probability: float, magnitude: int) -> OperationBase:
+    """Return color op."""
     magnitudes = linspace(0.1, 1.9, 11)
     return Saturate(None, probability, magnitude_range=(magnitudes[magnitude].item(), magnitudes[magnitude + 1].item()))

kornia/augmentation/auto/rand_augment/ops.py

@@ -21,6 +21,7 @@
 
 
 def shear_x(min_mag: float, max_mag: float) -> OperationBase:
+    """Return ShearX op."""
     if min_mag != -max_mag:
         raise ValueError(
             f"{ShearX.__name__} is a symmetric operation that `- min_mag == max_mag`. Got [{min_mag}, {max_mag}]"
@@ -29,6 +30,7 @@ def shear_x(min_mag: float, max_mag: float) -> OperationBase:
 
 
 def shear_y(min_mag: float, max_mag: float) -> OperationBase:
+    """Return ShearY op."""
     if min_mag != -max_mag:
         raise ValueError(
             f"{ShearY.__name__} is a symmetric operation that `- min_mag == max_mag`. Got [{min_mag}, {max_mag}]"
@@ -37,6 +39,7 @@ def shear_y(min_mag: float, max_mag: float) -> OperationBase:
 
 
 def translate_x(min_mag: float, max_mag: float) -> OperationBase:
+    """Return TranslateX op."""
     if min_mag != -max_mag:
         raise ValueError(
             f"{TranslateX.__name__} is a symmetric operation that `- min_mag == max_mag`. Got [{min_mag}, {max_mag}]"
@@ -45,6 +48,7 @@ def translate_x(min_mag: float, max_mag: float) -> OperationBase:
 
 
 def translate_y(min_mag: float, max_mag: float) -> OperationBase:
+    """Return TranslateY op."""
     if min_mag != -max_mag:
         raise ValueError(
             f"{TranslateY.__name__} is a symmetric operation that `- min_mag == max_mag`. Got [{min_mag}, {max_mag}]"
@@ -53,6 +57,7 @@ def translate_y(min_mag: float, max_mag: float) -> OperationBase:
 
 
 def rotate(min_mag: float, max_mag: float) -> OperationBase:
+    """Return rotate op."""
     if min_mag != -max_mag:
         raise ValueError(
             f"{Rotate.__name__} is a symmetric operation that `- min_mag == max_mag`. Got [{min_mag}, {max_mag}]"
@@ -61,40 +66,50 @@ def rotate(min_mag: float, max_mag: float) -> OperationBase:
 
 
 def auto_contrast(min_mag: float, max_mag: float) -> OperationBase:
+    """Return AutoConstrast op."""
     return AutoContrast(1.0)
 
 
 def invert(min_mag: float, max_mag: float) -> OperationBase:
+    """Return invert op."""
     return Invert(1.0)
 
 
 def equalize(min_mag: float, max_mag: float) -> OperationBase:
+    """Return equalize op."""
     return Equalize(1.0)
 
 
 def solarize(min_mag: float, max_mag: float) -> OperationBase:
+    """Return solarize op."""
     return Solarize(None, 1.0, magnitude_range=(min_mag, max_mag))
 
 
 def solarize_add(min_mag: float, max_mag: float) -> OperationBase:
+    """Return SolarizeAdd op."""
     return SolarizeAdd(None, 1.0, magnitude_range=(min_mag, max_mag))
 
 
 def posterize(min_mag: float, max_mag: float) -> OperationBase:
+    """Return posterize op."""
     return Posterize(None, 1.0, magnitude_range=(min_mag, max_mag))
 
 
 def contrast(min_mag: float, max_mag: float) -> OperationBase:
+    """Return contrast op."""
     return Contrast(None, 1.0, magnitude_range=(min_mag, max_mag))
 
 
 def brightness(min_mag: float, max_mag: float) -> OperationBase:
+    """Return brightness op."""
     return Brightness(None, 1.0, magnitude_range=(min_mag, max_mag))
 
 
 def sharpness(min_mag: float, max_mag: float) -> OperationBase:
+    """Return sharpness op."""
     return Sharpness(None, 1.0, magnitude_range=(min_mag, max_mag))
 
 
 def color(min_mag: float, max_mag: float) -> OperationBase:
+    """Return color op."""
     return Saturate(None, 1.0, magnitude_range=(min_mag, max_mag))

kornia/augmentation/container/ops.py

@@ -172,6 +172,7 @@ def f(*args: P.args, **kwargs: P.kwargs) -> Tensor:
 
 
 def get_geometric_only_param(module: "K.container.ImageSequentialBase", param: List[ParamItem]) -> List[ParamItem]:
+    """Return geometry param."""
     named_modules = module.get_forward_sequence(param)
 
     res: List[ParamItem] = []

kornia/contrib/extract_patches.py

@@ -14,6 +14,7 @@
 
 
 def create_padding_tuple(padding: PadType, unpadding: bool = False) -> FullPadType:
+    """Create argument for padding op."""
     padding = cast(TuplePadType, _pair(padding))
 
     if len(padding) not in [2, 4]:

kornia/contrib/models/efficient_vit/backbone.py

@@ -139,6 +139,7 @@ def forward(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
 
 
 def efficientvit_backbone_b0(**kwargs: dict[str, Any]) -> EfficientViTBackbone:
+    """Create EfficientViT B0."""
     backbone = EfficientViTBackbone(
         width_list=[8, 16, 32, 64, 128],
         depth_list=[1, 2, 2, 2, 2],
@@ -149,6 +150,7 @@ def efficientvit_backbone_b0(**kwargs: dict[str, Any]) -> EfficientViTBackbone:
 
 
 def efficientvit_backbone_b1(**kwargs: dict[str, Any]) -> EfficientViTBackbone:
+    """Create EfficientViT B1."""
     backbone = EfficientViTBackbone(
         width_list=[16, 32, 64, 128, 256],
         depth_list=[1, 2, 3, 3, 4],
@@ -159,6 +161,7 @@ def efficientvit_backbone_b1(**kwargs: dict[str, Any]) -> EfficientViTBackbone:
 
 
 def efficientvit_backbone_b2(**kwargs: dict[str, Any]) -> EfficientViTBackbone:
+    """Create EfficientViT B2."""
     backbone = EfficientViTBackbone(
         width_list=[24, 48, 96, 192, 384],
         depth_list=[1, 3, 4, 4, 6],
@@ -169,6 +172,7 @@ def efficientvit_backbone_b2(**kwargs: dict[str, Any]) -> EfficientViTBackbone:
 
 
 def efficientvit_backbone_b3(**kwargs: dict[str, Any]) -> EfficientViTBackbone:
+    """Create EfficientViT B3."""
     backbone = EfficientViTBackbone(
         width_list=[32, 64, 128, 256, 512],
         depth_list=[1, 4, 6, 6, 9],
@@ -307,6 +311,7 @@ def forward(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
 
 
 def efficientvit_backbone_l0(**kwargs: dict[str, Any]) -> EfficientViTLargeBackbone:
+    """Create EfficientViT L0."""
     backbone = EfficientViTLargeBackbone(
         width_list=[32, 64, 128, 256, 512],
         depth_list=[1, 1, 1, 4, 4],
@@ -316,6 +321,7 @@ def efficientvit_backbone_l0(**kwargs: dict[str, Any]) -> EfficientViTLargeBackb
 
 
 def efficientvit_backbone_l1(**kwargs: dict[str, Any]) -> EfficientViTLargeBackbone:
+    """Create EfficientViT L."""
     backbone = EfficientViTLargeBackbone(
         width_list=[32, 64, 128, 256, 512],
         depth_list=[1, 1, 1, 6, 6],
@@ -325,6 +331,7 @@ def efficientvit_backbone_l1(**kwargs: dict[str, Any]) -> EfficientViTLargeBackb
 
 
 def efficientvit_backbone_l2(**kwargs: dict[str, Any]) -> EfficientViTLargeBackbone:
+    """Create EfficientViT L2."""
     backbone = EfficientViTLargeBackbone(
         width_list=[32, 64, 128, 256, 512],
         depth_list=[1, 2, 2, 8, 8],
@@ -334,6 +341,7 @@ def efficientvit_backbone_l2(**kwargs: dict[str, Any]) -> EfficientViTLargeBackb
 
 
 def efficientvit_backbone_l3(**kwargs: dict[str, Any]) -> EfficientViTLargeBackbone:
+    """Create EfficientViT L3."""
     backbone = EfficientViTLargeBackbone(
         width_list=[64, 128, 256, 512, 1024],
         depth_list=[1, 2, 2, 8, 8],

kornia/contrib/models/efficient_vit/nn/act.py

@@ -21,6 +21,7 @@
 
 
 def build_act(name: Optional[str], **kwargs: dict[str, Any]) -> Union[nn.Module, None]:
+    """Return activation op."""
     if name in REGISTERED_ACT_DICT:
         act_cls = REGISTERED_ACT_DICT[name]
         args = build_kwargs_from_config(kwargs, act_cls)

kornia/contrib/models/efficient_vit/nn/norm.py

@@ -25,6 +25,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
 
 
 def build_norm(name: str = "bn2d", num_features: Optional[int] = None, **kwargs: Any) -> Optional[nn.Module]:
+    """Return norm op."""
     if name in ["ln", "ln2d"]:
         kwargs["normalized_shape"] = num_features
     else:

kornia/contrib/models/efficient_vit/utils/list.py

@@ -7,12 +7,14 @@
 
 
 def val2list(x: Union[list[Any], tuple[Any, ...], Any], repeat_time: int = 1) -> list[Any]:
+    """Convert value to list."""
     if isinstance(x, (list, tuple)):
         return list(x)
     return [x for _ in range(repeat_time)]
 
 
 def val2tuple(x: Union[list[Any], tuple[Any, ...], Any], min_len: int = 1, idx_repeat: int = -1) -> tuple[Any, ...]:
+    """Convert value to tuple."""
     x = val2list(x)
 
     # repeat elements if necessary

kornia/contrib/models/efficient_vit/utils/network.py

@@ -8,6 +8,7 @@
 
 
 def get_same_padding(kernel_size: Union[int, tuple[int, ...]]) -> Union[int, tuple[int, ...]]:
+    """Return padding values."""
     if isinstance(kernel_size, (tuple,)):
         return tuple([get_same_padding(ks) for ks in kernel_size])  # type: ignore
 
@@ -16,6 +17,7 @@ def get_same_padding(kernel_size: Union[int, tuple[int, ...]]) -> Union[int, tup
 
 
 def build_kwargs_from_config(config: dict[str, Any], target_func: Any) -> dict[str, Any]:
+    """Return kwargs from config object."""
     valid_keys = list(signature(target_func).parameters)
     kwargs = {}
     for key, value in config.items():

kornia/contrib/object_detection.py

@@ -42,6 +42,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
 
 
 def results_from_detections(*args: Any, **kwargs: Any) -> list[ObjectDetectorResultBase]:
+    """Return detector results."""
     warnings.warn(
         "results_from_detections is deprecated and will be removed in v0.8.0. "
         "Use kornia.models.detection.results_from_detections instead.",