dycw-utilities 0.153.5__tar.gz → 0.153.7__tar.gz

{dycw_utilities-0.153.5 → dycw_utilities-0.153.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.153.5
+Version: 0.153.7
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.153.5 → dycw_utilities-0.153.7}/pyproject.toml

@@ -229,7 +229,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.153.5"
+version = "0.153.7"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -262,7 +262,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.153.5"
+current_version = "0.153.7"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.153.5 → dycw_utilities-0.153.7}/src/tests/test_functions.py

@@ -6,6 +6,8 @@ from functools import cache, cached_property, lru_cache, partial, wraps
 from itertools import chain
 from operator import neg
 from pathlib import Path
+from subprocess import check_output
+from sys import executable
 from types import NoneType
 from typing import TYPE_CHECKING, Any, ClassVar, cast
 
@@ -22,7 +24,7 @@ from hypothesis.strategies import (
     permutations,
     sampled_from,
 )
-from pytest import raises
+from pytest import mark, param, raises
 
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import (
@@ -95,6 +97,7 @@ from utilities.functions import (
     yield_object_properties,
 )
 from utilities.sentinel import sentinel
+from utilities.text import parse_bool, strip_and_dedent
 from utilities.whenever import NOW_UTC, ZERO_TIME, get_now, get_today
 
 if TYPE_CHECKING:
@@ -131,40 +134,40 @@ class TestApplyDecorators:
         assert counter == 1
 
 
-class TestEnsureBytes:
-    @given(case=sampled_from([(b"", False), (b"", True), (None, True)]))
-    def test_main(self, *, case: tuple[bytes | None, bool]) -> None:
+class TestEnsureBool:
+    @given(case=sampled_from([(True, False), (True, True), (None, True)]))
+    def test_main(self, *, case: tuple[bool | None, bool]) -> None:
         obj, nullable = case
-        _ = ensure_bytes(obj, nullable=nullable)
+        _ = ensure_bool(obj, nullable=nullable)
 
     @given(
         case=sampled_from([
-            (False, "Object '.*' of type '.*' must be a byte string"),
-            (True, "Object '.*' of type '.*' must be a byte string or None"),
+            (False, "Object '.*' of type '.*' must be a boolean"),
+            (True, "Object '.*' of type '.*' must be a boolean or None"),
         ])
     )
     def test_error(self, *, case: tuple[bool, str]) -> None:
         nullable, match = case
-        with raises(EnsureBytesError, match=match):
-            _ = ensure_bytes(sentinel, nullable=nullable)
+        with raises(EnsureBoolError, match=match):
+            _ = ensure_bool(sentinel, nullable=nullable)
 
 
-class TestEnsureBool:
-    @given(case=sampled_from([(True, False), (True, True), (None, True)]))
-    def test_main(self, *, case: tuple[bool | None, bool]) -> None:
+class TestEnsureBytes:
+    @given(case=sampled_from([(b"", False), (b"", True), (None, True)]))
+    def test_main(self, *, case: tuple[bytes | None, bool]) -> None:
         obj, nullable = case
-        _ = ensure_bool(obj, nullable=nullable)
+        _ = ensure_bytes(obj, nullable=nullable)
 
     @given(
         case=sampled_from([
-            (False, "Object '.*' of type '.*' must be a boolean"),
-            (True, "Object '.*' of type '.*' must be a boolean or None"),
+            (False, "Object '.*' of type '.*' must be a byte string"),
+            (True, "Object '.*' of type '.*' must be a byte string or None"),
         ])
     )
     def test_error(self, *, case: tuple[bool, str]) -> None:
         nullable, match = case
-        with raises(EnsureBoolError, match=match):
-            _ = ensure_bool(sentinel, nullable=nullable)
+        with raises(EnsureBytesError, match=match):
+            _ = ensure_bytes(sentinel, nullable=nullable)
 
 
 class TestEnsureClass:
@@ -915,6 +918,31 @@ class TestSecond:
         assert second(pair) == y
 
 
+class TestSkipIfOptimize:
+    @mark.parametrize("optimize", [param(True), param(False)])
+    def test_main(self, *, optimize: bool) -> None:
+        code = strip_and_dedent("""
+            from utilities.functions import skip_if_optimize
+
+            is_run = False
+
+            @skip_if_optimize
+            def func() -> None:
+                global is_run
+                is_run = True
+
+            func()
+            print(is_run)
+        """)
+
+        args = [executable]
+        if optimize:
+            args.append("-O")
+        args.extend(["-c", code])
+        is_run = parse_bool(check_output(args, text=True))
+        assert is_run is not optimize
+
+
 class TestYieldObjectAttributes:
     @given(n=integers())
     def test_main(self, *, n: int) -> None:

{dycw_utilities-0.153.5 → dycw_utilities-0.153.7}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.153.5"
+__version__ = "0.153.7"

{dycw_utilities-0.153.5 → dycw_utilities-0.153.7}/src/utilities/functions.py

@@ -935,6 +935,21 @@ def second[U](pair: tuple[Any, U], /) -> U:
 ##
 
 
+def skip_if_optimize[**P](func: Callable[P, None], /) -> Callable[P, None]:
+    """Skip a function if we are in the optimized mode."""
+    if __debug__:
+        return func
+
+    @wraps(func)
+    def wrapped(*args: P.args, **kwargs: P.kwargs) -> None:
+        _ = (args, kwargs)
+
+    return wrapped
+
+
+##
+
+
 def yield_object_attributes(
     obj: Any,
     /,
@@ -1043,6 +1058,7 @@ __all__ = [
     "min_nullable",
     "not_func",
     "second",
+    "skip_if_optimize",
     "yield_object_attributes",
     "yield_object_cached_properties",
     "yield_object_properties",

{dycw_utilities-0.153.5 → dycw_utilities-0.153.7}/src/utilities/postgres.py

@@ -54,7 +54,7 @@ async def pg_dump(
     docker: str | None = None,
     dry_run: bool = False,
     logger: LoggerLike | None = None,
-) -> None:
+) -> bool:
     """Run `pg_dump`."""
     path = _path_pg_dump(path, format_=format_)
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -80,7 +80,7 @@ async def pg_dump(
     if dry_run:
         if logger is not None:
             to_logger(logger).info("Would run:\n\t%r", str(cmd))
-        return
+        return True
     with temp_environ(PGPASSWORD=url.password), Timer() as timer:  # pragma: no cover
         try:
             output = await stream_command(cmd)
@@ -90,22 +90,20 @@ async def pg_dump(
                     "Cancelled backup to %r after %s", str(path), timer
                 )
             rmtree(path, ignore_errors=True)
-        else:
-            match output.return_code:
-                case 0:
-                    if logger is not None:
-                        to_logger(logger).info(
-                            "Backup to %r finished after %s", str(path), timer
-                        )
-                case _:
-                    if logger is not None:
-                        to_logger(logger).exception(
-                            "Backup to %r failed after %s\nstderr:\n%s",
-                            str(path),
-                            timer,
-                            output.stderr,
-                        )
-                    rmtree(path, ignore_errors=True)
+            return False
+        if output.return_code != 0:
+            if logger is not None:
+                to_logger(logger).exception(
+                    "Backup to %r failed after %s\nstderr:\n%s",
+                    str(path),
+                    timer,
+                    output.stderr,
+                )
+            rmtree(path, ignore_errors=True)
+            return False
+    if logger is not None:  # pragma: no cover
+        to_logger(logger).info("Backup to %r finished after %s", str(path), timer)
+    return True  # pragma: no cover
 
 
 def _build_pg_dump(
@@ -218,7 +216,7 @@ async def restore(
     docker: str | None = None,
     dry_run: bool = False,
     logger: LoggerLike | None = None,
-) -> None:
+) -> bool:
     """Run `pg_restore`/`psql`."""
     cmd = _build_pg_restore_or_psql(
         url,
@@ -237,7 +235,7 @@ async def restore(
     if dry_run:
         if logger is not None:
             to_logger(logger).info("Would run:\n\t%r", str(cmd))
-        return
+        return True
     with temp_environ(PGPASSWORD=url.password), Timer() as timer:  # pragma: no cover
         try:
             output = await stream_command(cmd)
@@ -246,21 +244,19 @@ async def restore(
                 to_logger(logger).info(
                     "Cancelled restore from %r after %s", str(path), timer
                 )
-        else:
-            match output.return_code:
-                case 0:
-                    if logger is not None:
-                        to_logger(logger).info(
-                            "Restore from %r finished after %s", str(path), timer
-                        )
-                case _:
-                    if logger is not None:
-                        to_logger(logger).exception(
-                            "Restore from %r failed after %s\nstderr:\n%s",
-                            str(path),
-                            timer,
-                            output.stderr,
-                        )
+            return False
+        if output.return_code != 0:
+            if logger is not None:
+                to_logger(logger).exception(
+                    "Restore from %r failed after %s\nstderr:\n%s",
+                    str(path),
+                    timer,
+                    output.stderr,
+                )
+            return False
+    if logger is not None:  # pragma: no cover
+        to_logger(logger).info("Restore from %r finished after %s", str(path), timer)
+    return True  # pragma: no cover
 
 
 ##