feat: only __replace__

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

src/packaging/version.py

@@ -9,7 +9,6 @@
 
 from __future__ import annotations
 
-import copy
 import re
 import sys
 import typing
@@ -334,11 +333,6 @@ def __replace__(self, **kwargs: Unpack[_VersionReplace]) -> Self:
 
         return new_version
 
-    def replace(self, **kwargs: Unpack[_VersionReplace]) -> Self:
-        if sys.version_info >= (3, 13):
-            return copy.replace(self, **kwargs)
-        return self.__replace__(**kwargs)
-
     @property
     def _key(self) -> CmpKey:
         if self._key_cache is None:

tests/test_version.py

@@ -6,16 +6,32 @@
 
 import itertools
 import operator
+import sys
 import typing
 
 import pretend
 import pytest
 
-from packaging.version import InvalidVersion, Version, parse
+from packaging.version import InvalidVersion, Version, _VersionReplace, parse
 
 if typing.TYPE_CHECKING:
     from collections.abc import Callable
 
+    from typing_extensions import Self, Unpack
+
+if sys.version_info >= (3, 13):
+    from copy import replace
+else:
+    T = typing.TypeVar("T")
+
+    class SupportsReplace(typing.Protocol):
+        def __replace__(self, **kwargs: Unpack[_VersionReplace]) -> Self: ...
+
+    S = typing.TypeVar("S", bound="SupportsReplace")
+
+    def replace(item: S, **kwargs: Unpack[_VersionReplace]) -> S:
+        return item.__replace__(**kwargs)
+
 
 def test_parse() -> None:
     assert isinstance(parse("1.0"), Version)
@@ -780,189 +796,189 @@ def test_micro_version(self) -> None:
     def test_replace_no_args(self) -> None:
         """replace() with no arguments should return an equivalent version"""
         v = Version("1.2.3a1.post2.dev3+local")
-        v_replaced = v.replace()
+        v_replaced = replace(v)
         assert v == v_replaced
         assert str(v) == str(v_replaced)
 
     def test_replace_epoch(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(epoch=2)) == "2!1.2.3"
-        assert v.replace(epoch=0).epoch == 0
+        assert str(replace(v, epoch=2)) == "2!1.2.3"
+        assert replace(v, epoch=0).epoch == 0
 
         v_with_epoch = Version("1!1.2.3")
-        assert str(v_with_epoch.replace(epoch=2)) == "2!1.2.3"
-        assert str(v_with_epoch.replace(epoch=None)) == "1.2.3"
+        assert str(replace(v_with_epoch, epoch=2)) == "2!1.2.3"
+        assert str(replace(v_with_epoch, epoch=None)) == "1.2.3"
 
     def test_replace_release_tuple(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(release=(2, 0, 0))) == "2.0.0"
-        assert str(v.replace(release=(1,))) == "1"
-        assert str(v.replace(release=(1, 2, 3, 4, 5))) == "1.2.3.4.5"
+        assert str(replace(v, release=(2, 0, 0))) == "2.0.0"
+        assert str(replace(v, release=(1,))) == "1"
+        assert str(replace(v, release=(1, 2, 3, 4, 5))) == "1.2.3.4.5"
 
     def test_replace_release_none(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(release=None)) == "0"
+        assert str(replace(v, release=None)) == "0"
 
     def test_replace_pre_alpha(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(pre=("a", 1))) == "1.2.3a1"
-        assert str(v.replace(pre=("a", 0))) == "1.2.3a0"
+        assert str(replace(v, pre=("a", 1))) == "1.2.3a1"
+        assert str(replace(v, pre=("a", 0))) == "1.2.3a0"
 
     def test_replace_pre_alpha_none(self) -> None:
         v = Version("1.2.3a1")
-        assert str(v.replace(pre=None)) == "1.2.3"
+        assert str(replace(v, pre=None)) == "1.2.3"
 
     def test_replace_pre_beta(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(pre=("b", 1))) == "1.2.3b1"
-        assert str(v.replace(pre=("b", 0))) == "1.2.3b0"
+        assert str(replace(v, pre=("b", 1))) == "1.2.3b1"
+        assert str(replace(v, pre=("b", 0))) == "1.2.3b0"
 
     def test_replace_pre_beta_none(self) -> None:
         v = Version("1.2.3b1")
-        assert str(v.replace(pre=None)) == "1.2.3"
+        assert str(replace(v, pre=None)) == "1.2.3"
 
     def test_replace_pre_rc(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(pre=("rc", 1))) == "1.2.3rc1"
-        assert str(v.replace(pre=("rc", 0))) == "1.2.3rc0"
+        assert str(replace(v, pre=("rc", 1))) == "1.2.3rc1"
+        assert str(replace(v, pre=("rc", 0))) == "1.2.3rc0"
 
     def test_replace_pre_rc_none(self) -> None:
         v = Version("1.2.3rc1")
-        assert str(v.replace(pre=None)) == "1.2.3"
+        assert str(replace(v, pre=None)) == "1.2.3"
 
     def test_replace_post(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(post=1)) == "1.2.3.post1"
-        assert str(v.replace(post=0)) == "1.2.3.post0"
+        assert str(replace(v, post=1)) == "1.2.3.post1"
+        assert str(replace(v, post=0)) == "1.2.3.post0"
 
     def test_replace_post_none(self) -> None:
         v = Version("1.2.3.post1")
-        assert str(v.replace(post=None)) == "1.2.3"
+        assert str(replace(v, post=None)) == "1.2.3"
 
     def test_replace_dev(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(dev=1)) == "1.2.3.dev1"
-        assert str(v.replace(dev=0)) == "1.2.3.dev0"
+        assert str(replace(v, dev=1)) == "1.2.3.dev1"
+        assert str(replace(v, dev=0)) == "1.2.3.dev0"
 
     def test_replace_dev_none(self) -> None:
         v = Version("1.2.3.dev1")
-        assert str(v.replace(dev=None)) == "1.2.3"
+        assert str(replace(v, dev=None)) == "1.2.3"
 
     def test_replace_local_string(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(local="abc")) == "1.2.3+abc"
-        assert str(v.replace(local="abc.123")) == "1.2.3+abc.123"
-        assert str(v.replace(local="abc-123")) == "1.2.3+abc.123"
+        assert str(replace(v, local="abc")) == "1.2.3+abc"
+        assert str(replace(v, local="abc.123")) == "1.2.3+abc.123"
+        assert str(replace(v, local="abc-123")) == "1.2.3+abc.123"
 
     def test_replace_local_none(self) -> None:
         v = Version("1.2.3+local")
-        assert str(v.replace(local=None)) == "1.2.3"
+        assert str(replace(v, local=None)) == "1.2.3"
 
     def test_replace_multiple_components(self) -> None:
         v = Version("1.2.3")
-        assert str(v.replace(pre=("a", 1), post=1)) == "1.2.3a1.post1"
-        assert str(v.replace(release=(2, 0, 0), pre=("b", 2), dev=1)) == "2.0.0b2.dev1"
-        assert str(v.replace(epoch=1, release=(3, 0), local="abc")) == "1!3.0+abc"
+        assert str(replace(v, pre=("a", 1), post=1)) == "1.2.3a1.post1"
+        assert str(replace(v, release=(2, 0, 0), pre=("b", 2), dev=1)) == "2.0.0b2.dev1"
+        assert str(replace(v, epoch=1, release=(3, 0), local="abc")) == "1!3.0+abc"
 
     def test_replace_clear_all_optional(self) -> None:
         v = Version("1!1.2.3a1.post2.dev3+local")
-        cleared = v.replace(epoch=None, pre=None, post=None, dev=None, local=None)
+        cleared = replace(v, epoch=None, pre=None, post=None, dev=None, local=None)
         assert str(cleared) == "1.2.3"
 
     def test_replace_preserves_comparison(self) -> None:
         v1 = Version("1.2.3")
         v2 = Version("1.2.4")
 
-        v1_new = v1.replace(release=(1, 2, 4))
+        v1_new = replace(v1, release=(1, 2, 4))
         assert v1_new == v2
         assert v1 < v2
         assert v1_new >= v2
 
     def test_replace_preserves_hash(self) -> None:
         v1 = Version("1.2.3")
-        v2 = v1.replace(release=(1, 2, 3))
+        v2 = replace(v1, release=(1, 2, 3))
         assert hash(v1) == hash(v2)
 
-        v3 = v1.replace(release=(2, 0, 0))
+        v3 = replace(v1, release=(2, 0, 0))
         assert hash(v1) != hash(v3)
 
     def test_replace_change_pre_type(self) -> None:
         """Can change from one pre-release type to another"""
         v = Version("1.2.3a1")
-        assert str(v.replace(pre=("b", 2))) == "1.2.3b2"
-        assert str(v.replace(pre=("rc", 1))) == "1.2.3rc1"
+        assert str(replace(v, pre=("b", 2))) == "1.2.3b2"
+        assert str(replace(v, pre=("rc", 1))) == "1.2.3rc1"
 
         v2 = Version("1.2.3rc5")
-        assert str(v2.replace(pre=("a", 0))) == "1.2.3a0"
+        assert str(replace(v2, pre=("a", 0))) == "1.2.3a0"
 
     def test_replace_invalid_epoch_type(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="epoch must be non-negative"):
-            v.replace(epoch="1")  # type: ignore[arg-type]
+            replace(v, epoch="1")  # type: ignore[arg-type]
 
     def test_replace_invalid_post_type(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="post must be non-negative"):
-            v.replace(post="1")  # type: ignore[arg-type]
+            replace(v, post="1")  # type: ignore[arg-type]
 
     def test_replace_invalid_dev_type(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="dev must be non-negative"):
-            v.replace(dev="1")  # type: ignore[arg-type]
+            replace(v, dev="1")  # type: ignore[arg-type]
 
     def test_replace_invalid_epoch_negative(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="epoch must be non-negative"):
-            v.replace(epoch=-1)
+            replace(v, epoch=-1)
 
     def test_replace_invalid_release_empty(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="release must be a non-empty tuple"):
-            v.replace(release=())
+            replace(v, release=())
 
     def test_replace_invalid_release_tuple_content(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(
             InvalidVersion, match="release must be a non-empty tuple of non-negative"
         ):
-            v.replace(release=(1, -2, 3))
+            replace(v, release=(1, -2, 3))
 
     def test_replace_invalid_pre_negative(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="pre must be a tuple"):
-            v.replace(pre=("a", -1))
+            replace(v, pre=("a", -1))
 
     def test_replace_invalid_pre_type(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="pre must be a tuple"):
-            v.replace(pre=("x", 1))  # type: ignore[arg-type]
+            replace(v, pre=("x", 1))  # type: ignore[arg-type]
 
     def test_replace_invalid_pre_format(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="pre must be a tuple"):
-            v.replace(pre="a1")  # type: ignore[arg-type]
+            replace(v, pre="a1")  # type: ignore[arg-type]
         with pytest.raises(InvalidVersion, match="pre must be a tuple"):
-            v.replace(pre=("a",))  # type: ignore[arg-type]
+            replace(v, pre=("a",))  # type: ignore[arg-type]
         with pytest.raises(InvalidVersion, match="pre must be a tuple"):
-            v.replace(pre=("a", 1, 2))  # type: ignore[arg-type]
+            replace(v, pre=("a", 1, 2))  # type: ignore[arg-type]
 
     def test_replace_invalid_post_negative(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="post must be non-negative"):
-            v.replace(post=-1)
+            replace(v, post=-1)
 
     def test_replace_invalid_dev_negative(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(InvalidVersion, match="dev must be non-negative"):
-            v.replace(dev=-1)
+            replace(v, dev=-1)
 
     def test_replace_invalid_local_string(self) -> None:
         v = Version("1.2.3")
         with pytest.raises(
             InvalidVersion, match="local must be a valid version string"
         ):
-            v.replace(local="abc+123")
+            replace(v, local="abc+123")
         with pytest.raises(
             InvalidVersion, match="local must be a valid version string"
         ):
-            v.replace(local="+abc")
+            replace(v, local="+abc")