Deprecate atomicwrites in favour of os.replace

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/dycw/pre-commit-hooks
-    rev: 0.14.108
+    rev: 0.14.109
     hooks:
       - id: add-hooks
         args:

pyproject.toml

@@ -14,7 +14,6 @@
     "tzlocal>=5.3.1",
     "whenever>=0.9.5",
   ]
-  cryptography = ["cryptography>=46.0.3"]
   cvxpy = ["cvxpy>=1.7.5"]
   dataclasses-test = ["orjson>=3.11.5", "polars>=1.37.1"]
   dev = [
@@ -116,7 +115,7 @@
   name = "dycw-utilities"
   readme = "README.md"
   requires-python = ">= 3.12"
-  version = "0.184.6"
+  version = "0.184.7"
 
   [project.entry-points.pytest11]
     pytest-randomly = "utilities.pytest_plugins.pytest_randomly"

src/tests/conftest.py

@@ -11,9 +11,9 @@
 from utilities.asyncio import sleep
 from utilities.constants import IS_CI, IS_CI_AND_NOT_LINUX, MINUTE
 from utilities.contextlib import enhanced_context_manager
+from utilities.core import TemporaryDirectory, TemporaryFile
 from utilities.pytest import skipif_ci
 from utilities.re import ExtractGroupError, extract_group
-from utilities.tempfile import TemporaryDirectory, TemporaryFile
 from utilities.whenever import get_now_local_plain
 
 if TYPE_CHECKING:

src/tests/core/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

src/tests/core/test_builtins.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+from functools import cache, lru_cache, partial, wraps
+from itertools import chain
+from operator import neg
+from types import NoneType
+from typing import TYPE_CHECKING, Any
+
+from hypothesis import given
+from hypothesis.strategies import (
+    DataObject,
+    data,
+    integers,
+    lists,
+    none,
+    permutations,
+    sampled_from,
+)
+from pytest import mark, param, raises
+
+from utilities.core import (
+    MaxNullableError,
+    MinNullableError,
+    get_class,
+    get_class_name,
+    get_func_name,
+    identity,
+    max_nullable,
+    min_nullable,
+)
+from utilities.errors import ImpossibleCaseError
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+
+
+class TestGetClass:
+    @mark.parametrize(
+        ("obj", "expected"), [param(None, NoneType), param(NoneType, NoneType)]
+    )
+    def test_main(self, *, obj: Any, expected: type[Any]) -> None:
+        assert get_class(obj) is expected
+
+
+class TestGetClassName:
+    def test_class(self) -> None:
+        class Example: ...
+
+        assert get_class_name(Example) == "Example"
+
+    def test_instance(self) -> None:
+        class Example: ...
+
+        assert get_class_name(Example()) == "Example"
+
+    def test_qual(self) -> None:
+        assert (
+            get_class_name(ImpossibleCaseError, qual=True)
+            == "utilities.errors.ImpossibleCaseError"
+        )
+
+
+class TestGetFuncName:
+    @mark.parametrize(
+        ("func", "expected"),
+        [
+            param(identity, "identity"),
+            param(lambda x: x, "<lambda>"),  # pyright: ignore[reportUnknownLambdaType]
+            param(len, "len"),
+            param(neg, "neg"),
+            param(object.__init__, "object.__init__"),
+            param(object.__str__, "object.__str__"),
+            param(repr, "repr"),
+            param(str, "str"),
+            param(str.join, "str.join"),
+            param(sys.exit, "exit"),
+        ],
+    )
+    def test_main(self, *, func: Callable[..., Any], expected: str) -> None:
+        assert get_func_name(func) == expected
+
+    def test_cache(self) -> None:
+        @cache
+        def cache_func(x: int, /) -> int:
+            return x
+
+        assert get_func_name(cache_func) == "cache_func"
+
+    def test_decorated(self) -> None:
+        @wraps(identity)
+        def wrapped[T](x: T, /) -> T:
+            return identity(x)
+
+        assert get_func_name(wrapped) == "identity"
+
+    def test_lru_cache(self) -> None:
+        @lru_cache
+        def lru_cache_func(x: int, /) -> int:
+            return x
+
+        assert get_func_name(lru_cache_func) == "lru_cache_func"
+
+    def test_object(self) -> None:
+        class Example:
+            def __call__[T](self, x: T, /) -> T:
+                return identity(x)
+
+        assert get_func_name(Example()) == "Example"
+
+    def test_obj_method(self) -> None:
+        class Example:
+            def obj_method[T](self, x: T) -> T:
+                return identity(x)
+
+        assert get_func_name(Example().obj_method) == "Example.obj_method"
+
+    def test_obj_classmethod(self) -> None:
+        class Example:
+            @classmethod
+            def obj_classmethod[T](cls: T) -> T:
+                return identity(cls)
+
+        assert get_func_name(Example.obj_classmethod) == "Example.obj_classmethod"
+
+    def test_obj_staticmethod(self) -> None:
+        class Example:
+            @staticmethod
+            def obj_staticmethod[T](x: T) -> T:
+                return identity(x)
+
+        assert get_func_name(Example.obj_staticmethod) == "Example.obj_staticmethod"
+
+    def test_partial(self) -> None:
+        assert get_func_name(partial(identity)) == "identity"
+
+
+class TestMinMaxNullable:
+    @given(
+        data=data(),
+        values=lists(integers(), min_size=1),
+        nones=lists(none()),
+        case=sampled_from([(min_nullable, min), (max_nullable, max)]),
+    )
+    def test_main(
+        self,
+        *,
+        data: DataObject,
+        values: list[int],
+        nones: list[None],
+        case: tuple[
+            Callable[[Iterable[int | None]], int], Callable[[Iterable[int]], int]
+        ],
+    ) -> None:
+        func_nullable, func_builtin = case
+        values_use = data.draw(permutations(list(chain(values, nones))))
+        result = func_nullable(values_use)
+        expected = func_builtin(values)
+        assert result == expected
+
+    @mark.parametrize("func", [param(min_nullable), param(max_nullable)])
+    def test_default(self, *, func: Callable[..., int]) -> None:
+        assert func([], default=True) is True
+
+    def test_error_min(self) -> None:
+        with raises(MinNullableError, match=r"Minimum of \[\] is undefined"):
+            _ = min_nullable([])
+
+    def test_error_max(self) -> None:
+        with raises(MaxNullableError, match=r"Maximum of \[\] is undefined"):
+            max_nullable([])

src/tests/core/test_constants.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pytest import mark, param
+
+from utilities.constants import sentinel
+from utilities.core import is_none, is_not_none, is_sentinel
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class TestIsNoneAndIsNotNone:
+    @mark.parametrize(
+        ("func", "obj", "expected"),
+        [
+            param(is_none, None, True),
+            param(is_none, 0, False),
+            param(is_not_none, None, False),
+            param(is_not_none, 0, True),
+        ],
+    )
+    def test_main(
+        self, *, func: Callable[[Any], bool], obj: Any, expected: bool
+    ) -> None:
+        assert func(obj) is expected
+
+
+class TestIsSentinel:
+    @mark.parametrize(("obj", "expected"), [param(None, False), param(sentinel, True)])
+    def test_main(self, *, obj: Any, expected: bool) -> None:
+        assert is_sentinel(obj) is expected