dycw-utilities 0.129.10__py3-none-any.whl → 0.175.17__py3-none-any.whl

utilities/functools.py

@@ -3,40 +3,39 @@ from __future__ import annotations
 from functools import cache as _cache
 from functools import lru_cache as _lru_cache
 from functools import partial as _partial
-from typing import TYPE_CHECKING, Any, TypeVar, cast, overload, override
+from typing import TYPE_CHECKING, Any, cast, overload, override
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from utilities.types import TCallable
 
-_T = TypeVar("_T")
-
-
-def cache(func: TCallable, /) -> TCallable:
+def cache[F: Callable](func: F, /) -> F:
     """Typed version of `cache`."""
-    typed_cache = cast("Callable[[TCallable], TCallable]", _cache)
+    typed_cache = cast("Callable[[F], F]", _cache)
     return typed_cache(func)
 
 
 ##
 
 
+_MAX_SIZE = 128
+
+
 @overload
-def lru_cache(
-    func: TCallable, /, *, max_size: int = ..., typed: bool = ...
-) -> TCallable: ...
+def lru_cache[F: Callable](
+    func: F, /, *, max_size: int = _MAX_SIZE, typed: bool = False
+) -> F: ...
 @overload
-def lru_cache(
-    func: None = None, /, *, max_size: int = ..., typed: bool = ...
-) -> Callable[[TCallable], TCallable]: ...
-def lru_cache(
-    func: TCallable | None = None, /, *, max_size: int = 128, typed: bool = False
-) -> TCallable | Callable[[TCallable], TCallable]:
+def lru_cache[F: Callable](
+    func: None = None, /, *, max_size: int = _MAX_SIZE, typed: bool = False
+) -> Callable[[F], F]: ...
+def lru_cache[F: Callable](
+    func: F | None = None, /, *, max_size: int = _MAX_SIZE, typed: bool = False
+) -> F | Callable[[F], F]:
     """Typed version of `lru_cache`."""
     if func is None:
         result = partial(lru_cache, max_size=max_size, typed=typed)
-        return cast("Callable[[TCallable], TCallable]", result)
+        return cast("Callable[[F], F]", result)
     wrapped = _lru_cache(maxsize=max_size, typed=typed)(func)
     return cast("Any", wrapped)
 
@@ -44,11 +43,11 @@ def lru_cache(
 ##
 
 
-class partial(_partial[_T]):  # noqa: N801
+class partial[T](_partial[T]):  # noqa: N801
     """Partial which accepts Ellipsis for positional arguments."""
 
     @override
-    def __call__(self, *args: Any, **kwargs: Any) -> _T:
+    def __call__(self, *args: Any, **kwargs: Any) -> T:
         iter_args = iter(args)
         head = (next(iter_args) if arg is ... else arg for arg in self.args)
         return self.func(*head, *iter_args, **{**self.keywords, **kwargs})

utilities/git.py

@@ -1,40 +1,19 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 from pathlib import Path
-from re import IGNORECASE, search
-from subprocess import PIPE, CalledProcessError, check_output
-from typing import TYPE_CHECKING, override
+from typing import TYPE_CHECKING
 
-from utilities.pathlib import PWD
-
-if TYPE_CHECKING:
-    from utilities.types import PathLike
+from git import Repo
 
+from utilities.pathlib import to_path
 
-def get_repo_root(*, path: PathLike = PWD) -> Path:
-    """Get the repo root."""
-    try:
-        output = check_output(
-            ["git", "rev-parse", "--show-toplevel"], stderr=PIPE, cwd=path, text=True
-        )
-    except CalledProcessError as error:
-        # newer versions of git report "Not a git repository", whilst older
-        # versions report "not a git repository"
-        if search("fatal: not a git repository", error.stderr, flags=IGNORECASE):
-            raise GetRepoRootError(cwd=path) from error
-        raise  # pragma: no cover
-    else:
-        return Path(output.strip("\n"))
-
+if TYPE_CHECKING:
+    from utilities.types import MaybeCallablePathLike
 
-@dataclass(kw_only=True, slots=True)
-class GetRepoRootError(Exception):
-    cwd: PathLike
 
-    @override
-    def __str__(self) -> str:
-        return f"Path is not part of a `git` repository: {self.cwd}"
+def get_repo(path: MaybeCallablePathLike = Path.cwd, /) -> Repo:
+    """Get the repo object."""
+    return Repo(to_path(path), search_parent_directories=True)
 
 
-__all__ = ["GetRepoRootError", "get_repo_root"]
+__all__ = ["get_repo"]

utilities/grp.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import assert_never
+
+from utilities.os import EFFECTIVE_GROUP_ID
+from utilities.platform import SYSTEM
+
+
+def get_gid_name(gid: int, /) -> str | None:
+    """Get the name of a group."""
+    match SYSTEM:
+        case "windows":  # skipif-not-windows
+            return None
+        case "mac" | "linux":
+            from grp import getgrgid
+
+            return getgrgid(gid).gr_name
+        case never:
+            assert_never(never)
+
+
+ROOT_GROUP_NAME = get_gid_name(0)
+EFFECTIVE_GROUP_NAME = (
+    None if EFFECTIVE_GROUP_ID is None else get_gid_name(EFFECTIVE_GROUP_ID)
+)
+
+
+__all__ = ["EFFECTIVE_GROUP_NAME", "ROOT_GROUP_NAME", "get_gid_name"]

utilities/gzip.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import gzip
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from utilities.atomicwrites import writer
+
+if TYPE_CHECKING:
+    from utilities.types import PathLike
+
+
+def read_binary(path: PathLike, /, *, decompress: bool = False) -> bytes:
+    """Read a byte string from disk."""
+    path = Path(path)
+    if decompress:
+        with gzip.open(path) as gz:
+            return gz.read()
+    else:
+        return path.read_bytes()
+
+
+def write_binary(
+    data: bytes, path: PathLike, /, *, compress: bool = False, overwrite: bool = False
+) -> None:
+    """Write a byte string to disk."""
+    with writer(path, compress=compress, overwrite=overwrite) as temp:
+        _ = temp.write_bytes(data)
+
+
+__all__ = ["read_binary", "write_binary"]

utilities/http.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-from contextlib import contextmanager
 from http.client import HTTPSConnection
 from ipaddress import IPv4Address
 from typing import TYPE_CHECKING
 
+from utilities.contextlib import enhanced_context_manager
+
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
@@ -21,7 +22,7 @@ def get_public_ip(*, timeout: float | None = None) -> IPv4Address:
 ##
 
 
-@contextmanager
+@enhanced_context_manager
 def yield_connection(
     host: str, /, *, timeout: float | None = None
 ) -> Iterator[HTTPSConnection]: