Align clamp naming with PyTorch

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redcat"
-version = "0.0.1a115"
+version = "0.0.1a116"
 description = "A library to manipulate batches of examples"
 readme = "README.md"
 authors = ["Thibaut Durand <durand.tibo+gh@gmail.com>"]

src/redcat/basetensor.py

@@ -1147,19 +1147,19 @@ def abs_(self) -> None:
 
     def clamp(
         self,
-        min_value: int | float | None = None,
-        max_value: int | float | None = None,
+        min: int | float | None = None,  # noqa: A002
+        max: int | float | None = None,  # noqa: A002
     ) -> TBatchedTensor:
         r"""Clamps all elements in ``self`` into the range ``[min_value,
         max_value]``.
 
         Note: ``min_value`` and ``max_value`` cannot be both ``None``.
 
         Args:
-            min_value (int, float or ``None``, optional): Specifies
+            min (int, float or ``None``, optional): Specifies
                 the lower bound. If ``min_value`` is ``None``,
                 there is no lower bound. Default: ``None``
-            max_value (int, float or ``None``, optional): Specifies
+            max (int, float or ``None``, optional): Specifies
                 the upper bound. If ``max_value`` is ``None``,
                 there is no upper bound. Default: ``None``
 
@@ -1173,17 +1173,17 @@ def clamp(
             >>> import torch
             >>> from redcat import BatchedTensor
             >>> batch = BatchedTensor(torch.arange(10).view(2, 5))
-            >>> batch.clamp(min_value=2, max_value=5)
+            >>> batch.clamp(min=2, max=5)
             tensor([[2, 2, 2, 3, 4],
                     [5, 5, 5, 5, 5]], batch_dim=0)
-            >>> batch.clamp(min_value=2)
+            >>> batch.clamp(min=2)
             tensor([[2, 2, 2, 3, 4],
                     [5, 6, 7, 8, 9]])
-            >>> batch.clamp(max_value=7)
+            >>> batch.clamp(max=7)
             tensor([[0, 1, 2, 3, 4],
                     [5, 6, 7, 7, 7]], batch_dim=0)
         """
-        return torch.clamp(self, min=min_value, max=max_value)
+        return torch.clamp(self, min=min, max=max)
 
     def clamp_(
         self,

src/redcat/tensor.py

@@ -43,6 +43,7 @@ def __torch_function__(
         args: tuple[Any, ...] = (),
         kwargs: dict[str, Any] | None = None,
     ) -> BatchedTensor:
+        # print(func, types, args, kwargs)
         kwargs = kwargs or {}
         batch_dims = get_batch_dims(args, kwargs)
         check_batch_dims(batch_dims)

tests/unit/test_tensor.py

@@ -1728,31 +1728,31 @@ def test_batched_tensor_abs__custom_batch_dim() -> None:
 def test_batched_tensor_clamp() -> None:
     assert (
         BatchedTensor(torch.arange(10).view(2, 5))
-        .clamp(min_value=2, max_value=5)
+        .clamp(min=2, max=5)
         .equal(BatchedTensor(torch.tensor([[2, 2, 2, 3, 4], [5, 5, 5, 5, 5]])))
     )
 
 
 def test_batched_tensor_clamp_only_max_value() -> None:
     assert (
         BatchedTensor(torch.arange(10).view(2, 5))
-        .clamp(max_value=5)
+        .clamp(max=5)
         .equal(BatchedTensor(torch.tensor([[0, 1, 2, 3, 4], [5, 5, 5, 5, 5]])))
     )
 
 
 def test_batched_tensor_clamp_only_min_value() -> None:
     assert (
         BatchedTensor(torch.arange(10).view(2, 5))
-        .clamp(min_value=2)
+        .clamp(min=2)
         .equal(BatchedTensor(torch.tensor([[2, 2, 2, 3, 4], [5, 6, 7, 8, 9]])))
     )
 
 
 def test_batched_tensor_clamp_custom_dims() -> None:
     assert (
         BatchedTensor(torch.arange(10).view(2, 5), batch_dim=1)
-        .clamp(min_value=2, max_value=5)
+        .clamp(min=2, max=5)
         .equal(BatchedTensor(torch.tensor([[2, 2, 2, 3, 4], [5, 5, 5, 5, 5]]), batch_dim=1))
     )
 

tests/unit/test_tensorseq.py

@@ -2131,31 +2131,31 @@ def test_batched_tensor_seq_abs__custom_dims() -> None:
 def test_batched_tensor_seq_clamp() -> None:
     assert (
         BatchedTensorSeq(torch.arange(10).view(2, 5))
-        .clamp(min_value=2, max_value=5)
+        .clamp(min=2, max=5)
         .equal(BatchedTensorSeq(torch.tensor([[2, 2, 2, 3, 4], [5, 5, 5, 5, 5]])))
     )
 
 
 def test_batched_tensor_seq_clamp_only_max_value() -> None:
     assert (
         BatchedTensorSeq(torch.arange(10).view(2, 5))
-        .clamp(max_value=5)
+        .clamp(max=5)
         .equal(BatchedTensorSeq(torch.tensor([[0, 1, 2, 3, 4], [5, 5, 5, 5, 5]])))
     )
 
 
 def test_batched_tensor_seq_clamp_only_min_value() -> None:
     assert (
         BatchedTensorSeq(torch.arange(10).view(2, 5))
-        .clamp(min_value=2)
+        .clamp(min=2)
         .equal(BatchedTensorSeq(torch.tensor([[2, 2, 2, 3, 4], [5, 6, 7, 8, 9]])))
     )
 
 
 def test_batched_tensor_seq_clamp_custom_dims() -> None:
     assert (
         BatchedTensorSeq(torch.arange(10).view(2, 5), batch_dim=1, seq_dim=0)
-        .clamp(min_value=2, max_value=5)
+        .clamp(min=2, max=5)
         .equal(
             BatchedTensorSeq(
                 torch.tensor([[2, 2, 2, 3, 4], [5, 5, 5, 5, 5]]), batch_dim=1, seq_dim=0