dycw-utilities 0.150.8__tar.gz → 0.150.10__tar.gz

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/PKG-INFO

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

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/pyproject.toml

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

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/src/tests/test_hypothesis.py

@@ -86,6 +86,7 @@ from utilities.hypothesis import (
     triples,
     uint32s,
     uint64s,
+    urls,
     versions,
     year_months,
     zoned_datetimes,
@@ -964,6 +965,49 @@ class TestUInt64s:
         assert max(min_value, MIN_UINT64) <= x <= min(max_value, MAX_UINT64)
 
 
+class TestURLs:
+    @given(
+        data=data(),
+        all_=booleans(),
+        username=booleans(),
+        password=booleans(),
+        host=booleans(),
+        port=booleans(),
+        database=booleans(),
+    )
+    def test_main(
+        self,
+        *,
+        data: DataObject,
+        all_: bool,
+        username: bool,
+        password: bool,
+        host: bool,
+        port: bool,
+        database: bool,
+    ) -> None:
+        url = data.draw(
+            urls(
+                all_=all_,
+                username=username,
+                password=password,
+                host=host,
+                port=port,
+                database=database,
+            )
+        )
+        if all_ or username:
+            assert url.username is not None
+        if all_ or password:
+            assert url.password is not None
+        if all_ or host:
+            assert url.host is not None
+        if all_ or port:
+            assert url.port is not None
+        if all_ or database:
+            assert url.database is not None
+
+
 class TestVersions:
     @given(data=data(), suffix=booleans())
     def test_main(self, *, data: DataObject, suffix: bool) -> None:

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/src/tests/test_postgres.py

@@ -7,14 +7,10 @@ from hypothesis.strategies import DrawFn, booleans, composite, lists, none, samp
 from pytest import raises
 from sqlalchemy import URL, Column, Integer, MetaData, Table
 
-from utilities.hypothesis import integers, temp_paths, text_ascii
+from utilities.hypothesis import integers, temp_paths, text_ascii, urls
 from utilities.postgres import (
     _build_pg_dump,
     _build_pg_restore_or_psql,
-    _extract_url,
-    _ExtractURLDatabaseError,
-    _ExtractURLHostError,
-    _ExtractURLPortError,
     _path_pg_dump,
     _PGDumpFormat,
     _resolve_data_only_and_clean,
@@ -40,30 +36,15 @@ def tables(draw: DrawFn, /) -> list[Table | str]:
     return [draw(sampled_from([n, t])) for n, t in zip(names, tables, strict=True)]
 
 
-@composite
-def urls(draw: DrawFn, /) -> URL:
-    username = draw(text_ascii(min_size=1) | none())
-    password = draw(text_ascii(min_size=1) | none())
-    host = draw(text_ascii(min_size=1))
-    port = draw(integers(min_value=1))
-    database = draw(text_ascii(min_size=1))
-    return URL.create(
-        drivername="postgres",
-        username=username,
-        password=password,
-        host=host,
-        port=port,
-        database=database,
-    )
-
-
 class TestPGDump:
-    @given(url=urls(), path=temp_paths(), logger=text_ascii(min_size=1) | none())
+    @given(
+        url=urls(all_=True), path=temp_paths(), logger=text_ascii(min_size=1) | none()
+    )
     async def test_main(self, *, url: URL, path: Path, logger: str | None) -> None:
         _ = await pg_dump(url, path, dry_run=True, logger=logger)
 
     @given(
-        url=urls(),
+        url=urls(all_=True),
         path=temp_paths(),
         format_=sampled_from(get_literal_elements(_PGDumpFormat)),
         jobs=integers(min_value=0) | none(),
@@ -137,15 +118,16 @@ class TestResolveDataOnlyAndClean:
 
 
 class TestRestore:
-    @given(url=urls(), path=temp_paths(), logger=text_ascii(min_size=1) | none())
+    @given(
+        url=urls(all_=True), path=temp_paths(), logger=text_ascii(min_size=1) | none()
+    )
     async def test_main(self, *, url: URL, path: Path, logger: str | None) -> None:
         _ = await restore(url, path, dry_run=True, logger=logger)
 
     @given(
-        url=urls(),
+        url=urls(all_=True),
         path=temp_paths(),
         psql=booleans(),
-        database=text_ascii(min_size=1) | none(),
         create=booleans(),
         jobs=integers(min_value=0) | none(),
         schema=lists(text_ascii(min_size=1)) | none(),
@@ -160,7 +142,6 @@ class TestRestore:
         url: URL,
         path: Path,
         psql: bool,
-        database: str | None,
         create: bool,
         jobs: int | None,
         schema: list[str] | None,
@@ -173,7 +154,6 @@ class TestRestore:
             url,
             path,
             psql=psql,
-            database=database,
             create=create,
             jobs=jobs,
             schema=schema,
@@ -182,27 +162,3 @@ class TestRestore:
             role=role,
             docker=docker,
         )
-
-
-class TestExtractURL:
-    def test_database(self) -> None:
-        url = URL.create("postgres")
-        with raises(
-            _ExtractURLDatabaseError,
-            match="Expected URL to contain a 'database'; got .*",
-        ):
-            _ = _extract_url(url)
-
-    def test_host(self) -> None:
-        url = URL.create("postgres", database="database")
-        with raises(
-            _ExtractURLHostError, match="Expected URL to contain a 'host'; got .*"
-        ):
-            _ = _extract_url(url)
-
-    def test_port(self) -> None:
-        url = URL.create("postgres", database="database", host="host")
-        with raises(
-            _ExtractURLPortError, match="Expected URL to contain a 'port'; got .*"
-        ):
-            _ = _extract_url(url)

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/src/tests/test_sqlalchemy.py

@@ -9,6 +9,7 @@ from hypothesis import HealthCheck, Phase, assume, given, settings
 from hypothesis.strategies import SearchStrategy, booleans, lists, none, sets, tuples
 from pytest import mark, param, raises
 from sqlalchemy import (
+    URL,
     Boolean,
     Column,
     Engine,
@@ -28,7 +29,7 @@ from sqlalchemy.orm import (
     relationship,
 )
 
-from utilities.hypothesis import int32s, pairs
+from utilities.hypothesis import int32s, pairs, urls
 from utilities.iterables import one
 from utilities.modules import is_installed
 from utilities.sqlalchemy import (
@@ -39,6 +40,11 @@ from utilities.sqlalchemy import (
     TablenameMixin,
     TableOrORMInstOrClass,
     UpsertItemsError,
+    _ExtractURLDatabaseError,
+    _ExtractURLHostError,
+    _ExtractURLPasswordError,
+    _ExtractURLPortError,
+    _ExtractURLUsernameError,
     _get_dialect,
     _get_dialect_max_params,
     _InsertItem,
@@ -69,6 +75,7 @@ from utilities.sqlalchemy import (
     ensure_tables_dropped,
     enum_name,
     enum_values,
+    extract_url,
     get_chunk_size,
     get_column_names,
     get_columns,
@@ -313,6 +320,53 @@ class TestEnumValues:
         assert result == expected
 
 
+class TestExtractURL:
+    @given(url=urls(all_=True))
+    def test_main(self, *, url: URL) -> None:
+        extracted = extract_url(url)
+        assert extracted.username == url.username
+        assert extracted.password == url.password
+        assert extracted.host == url.host
+        assert extracted.port == url.port
+        assert extracted.database == url.database
+
+    @given(url=urls(username=False))
+    def test_username(self, *, url: URL) -> None:
+        with raises(
+            _ExtractURLUsernameError,
+            match="Expected URL to contain a user name; got .*",
+        ):
+            _ = extract_url(url)
+
+    @given(url=urls(username=True, password=False))
+    def test_password(self, *, url: URL) -> None:
+        with raises(
+            _ExtractURLPasswordError, match="Expected URL to contain a password; got .*"
+        ):
+            _ = extract_url(url)
+
+    @given(url=urls(username=True, password=True, host=False))
+    def test_host(self, *, url: URL) -> None:
+        with raises(
+            _ExtractURLHostError, match="Expected URL to contain a host; got .*"
+        ):
+            _ = extract_url(url)
+
+    @given(url=urls(username=True, password=True, host=True, port=False))
+    def test_port(self, *, url: URL) -> None:
+        with raises(
+            _ExtractURLPortError, match="Expected URL to contain a port; got .*"
+        ):
+            _ = extract_url(url)
+
+    @given(url=urls(username=True, password=True, host=True, port=True, database=False))
+    def test_database(self, *, url: URL) -> None:
+        with raises(
+            _ExtractURLDatabaseError, match="Expected URL to contain a database; got .*"
+        ):
+            _ = extract_url(url)
+
+
 class TestGetChunkSize:
     @mark.parametrize(
         ("num_cols", "chunk_size_frac", "expected"),

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/src/tests/test_text.py

@@ -112,6 +112,13 @@ class TestSecretStr:
         assert repr(s) == secret_str._REPR
         assert str(s) == secret_str._REPR
 
+    def test_open(self) -> None:
+        s = secret_str("text")
+        assert isinstance(s.str, str)
+        assert not isinstance(s.str, secret_str)
+        assert repr(s.str) == repr("text")
+        assert str(s.str) == "text"
+
 
 class TestSnakeCase:
     @given(

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.150.8"
+__version__ = "0.150.10"

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/src/utilities/hypothesis.py

@@ -98,6 +98,7 @@ if TYPE_CHECKING:
     from hypothesis.database import ExampleDatabase
     from libcst import Import, ImportFrom
     from numpy.random import RandomState
+    from sqlalchemy import URL
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
     from utilities.types import Number, TimeZoneLike
@@ -1258,6 +1259,41 @@ def uint64s(
 ##
 
 
+@composite
+def urls(
+    draw: DrawFn,
+    /,
+    *,
+    all_: MaybeSearchStrategy[bool] = False,
+    username: MaybeSearchStrategy[bool] = False,
+    password: MaybeSearchStrategy[bool] = False,
+    host: MaybeSearchStrategy[bool] = False,
+    port: MaybeSearchStrategy[bool] = False,
+    database: MaybeSearchStrategy[bool] = False,
+) -> URL:
+    from sqlalchemy import URL
+
+    have_all, have_username, have_password, have_host, have_port, have_database = [
+        draw2(draw, b) for b in [all_, username, password, host, port, database]
+    ]
+    username_use = draw(text_ascii(min_size=1)) if have_all or have_username else None
+    password_use = draw(text_ascii(min_size=1)) if have_all or have_password else None
+    host_use = draw(text_ascii(min_size=1)) if have_all or have_host else None
+    port_use = draw(integers(min_value=1)) if have_all or have_port else None
+    database_use = draw(text_ascii(min_size=1)) if have_all or have_database else None
+    return URL.create(
+        drivername="sqlite",
+        username=username_use,
+        password=password_use,
+        host=host_use,
+        port=port_use,
+        database=database_use,
+    )
+
+
+##
+
+
 @composite
 def versions(draw: DrawFn, /, *, suffix: MaybeSearchStrategy[bool] = False) -> Version:
     """Strategy for generating versions."""
@@ -1392,6 +1428,7 @@ __all__ = [
     "triples",
     "uint32s",
     "uint64s",
+    "urls",
     "versions",
     "year_months",
     "zoned_datetimes",

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/src/utilities/postgres.py

@@ -13,7 +13,7 @@ from utilities.iterables import always_iterable
 from utilities.logging import get_logger
 from utilities.os import temp_environ
 from utilities.pathlib import ensure_suffix
-from utilities.sqlalchemy import get_table_name
+from utilities.sqlalchemy import extract_url, get_table_name
 from utilities.timer import Timer
 from utilities.types import PathLike
 
@@ -124,12 +124,11 @@ def _build_pg_dump(
     role: str | None = None,
     docker: str | None = None,
 ) -> str:
-    database, host, port = _extract_url(url)
+    extracted = extract_url(url)
     path = _path_pg_dump(path, format_=format_)
     parts: list[str] = [
         "pg_dump",
         # general options
-        f"--dbname={database}",
         f"--file={str(path)!r}",
         f"--format={format_}",
         "--verbose",
@@ -139,8 +138,10 @@ def _build_pg_dump(
         "--no-owner",
         "--no-privileges",
         # connection options
-        f"--host={host}",
-        f"--port={port}",
+        f"--dbname={extracted.database}",
+        f"--host={extracted.host}",
+        f"--port={extracted.port}",
+        f"--username={extracted.username}",
         "--no-password",
     ]
     if (format_ == "directory") and (jobs is not None):
@@ -167,8 +168,6 @@ def _build_pg_dump(
         parts.append("--inserts")
     if on_conflict_do_nothing:
         parts.append("--on-conflict-do-nothing")
-    if url.username is not None:
-        parts.append(f"--username={url.username}")
     if role is not None:
         parts.append(f"--role={role}")
     if docker is not None:
@@ -203,7 +202,6 @@ async def restore(
     /,
     *,
     psql: bool = False,
-    database: str | None = None,
     data_only: bool = False,
     clean: bool = False,
     create: bool = False,
@@ -221,7 +219,6 @@ async def restore(
         url,
         path,
         psql=psql,
-        database=database,
         data_only=data_only,
         clean=clean,
         create=create,
@@ -270,7 +267,6 @@ def _build_pg_restore_or_psql(
     /,
     *,
     psql: bool = False,
-    database: str | None = None,
     data_only: bool = False,
     clean: bool = False,
     create: bool = False,
@@ -283,11 +279,10 @@ def _build_pg_restore_or_psql(
 ) -> str:
     path = Path(path)
     if (path.suffix == ".sql") or psql:
-        return _build_psql(url, path, database=database, docker=docker)
+        return _build_psql(url, path, docker=docker)
     return _build_pg_restore(
         url,
         path,
-        database=database,
         data_only=data_only,
         clean=clean,
         create=create,
@@ -305,7 +300,6 @@ def _build_pg_restore(
     path: PathLike,
     /,
     *,
-    database: str | None = None,
     data_only: bool = False,
     clean: bool = False,
     create: bool = False,
@@ -317,12 +311,10 @@ def _build_pg_restore(
     docker: str | None = None,
 ) -> str:
     """Run `pg_restore`."""
-    url_database, host, port = _extract_url(url)
-    database_use = url_database if database is None else database
+    extracted = extract_url(url)
     parts: list[str] = [
         "pg_restore",
         # general options
-        f"--dbname={database_use}",
         "--verbose",
         # restore options
         *_resolve_data_only_and_clean(data_only=data_only, clean=clean),
@@ -330,8 +322,10 @@ def _build_pg_restore(
         "--no-owner",
         "--no-privileges",
         # connection options
-        f"--host={host}",
-        f"--port={port}",
+        f"--host={extracted.host}",
+        f"--port={extracted.port}",
+        f"--username={extracted.username}",
+        f"--dbname={extracted.database}",
         "--no-password",
     ]
     if create:
@@ -344,8 +338,6 @@ def _build_pg_restore(
         parts.extend([f"--exclude-schema={s}" for s in always_iterable(schemas_exc)])
     if tables is not None:
         parts.extend([f"--table={_get_table_name(t)}" for t in always_iterable(tables)])
-    if url.username is not None:
-        parts.append(f"--username={url.username}")
     if role is not None:
         parts.append(f"--role={role}")
     if docker is not None:
@@ -354,29 +346,20 @@ def _build_pg_restore(
     return " ".join(parts)
 
 
-def _build_psql(
-    url: URL,
-    path: PathLike,
-    /,
-    *,
-    database: str | None = None,
-    docker: str | None = None,
-) -> str:
+def _build_psql(url: URL, path: PathLike, /, *, docker: str | None = None) -> str:
     """Run `psql`."""
-    url_database, host, port = _extract_url(url)
-    database_use = url_database if database is None else database
+    extracted = extract_url(url)
     parts: list[str] = [
         "psql",
         # general options
-        f"--dbname={database_use}",
+        f"--dbname={extracted.database}",
         f"--file={str(path)!r}",
         # connection options
-        f"--host={host}",
-        f"--port={port}",
+        f"--host={extracted.host}",
+        f"--port={extracted.port}",
+        f"--username={extracted.username}",
         "--no-password",
     ]
-    if url.username is not None:
-        parts.append(f"--username={url.username}")
     if docker is not None:
         parts = _wrap_docker(parts, docker)
     return " ".join(parts)
@@ -385,42 +368,6 @@ def _build_psql(
 ##
 
 
-def _extract_url(url: URL, /) -> tuple[str, str, int]:
-    if url.database is None:
-        raise _ExtractURLDatabaseError(url=url)
-    if url.host is None:
-        raise _ExtractURLHostError(url=url)
-    if url.port is None:
-        raise _ExtractURLPortError(url=url)
-    return url.database, url.host, url.port
-
-
-@dataclass(kw_only=True, slots=True)
-class ExtractURLError(Exception):
-    url: URL
-
-
-@dataclass(kw_only=True, slots=True)
-class _ExtractURLDatabaseError(ExtractURLError):
-    @override
-    def __str__(self) -> str:
-        return f"Expected URL to contain a 'database'; got {self.url}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _ExtractURLHostError(ExtractURLError):
-    @override
-    def __str__(self) -> str:
-        return f"Expected URL to contain a 'host'; got {self.url}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _ExtractURLPortError(ExtractURLError):
-    @override
-    def __str__(self) -> str:
-        return f"Expected URL to contain a 'port'; got {self.url}"
-
-
 def _get_table_name(obj: TableOrORMInstOrClass | str, /) -> str:
     match obj:
         case Table() | DeclarativeBase() | type() as table_or_orm:
@@ -458,4 +405,4 @@ def _wrap_docker(parts: list[str], container: str, /) -> list[str]:
     return ["docker", "exec", "-it", container, *parts]
 
 
-__all__ = ["ExtractURLError", "pg_dump", "restore"]
+__all__ = ["pg_dump", "restore"]

{dycw_utilities-0.150.8 → dycw_utilities-0.150.10}/src/utilities/sqlalchemy.py

@@ -96,7 +96,7 @@ from utilities.iterables import (
     one,
 )
 from utilities.reprlib import get_repr
-from utilities.text import snake_case
+from utilities.text import secret_str, snake_case
 from utilities.types import MaybeIterable, MaybeType, StrMapping, TupleOrStrMapping
 
 if TYPE_CHECKING:
@@ -378,6 +378,79 @@ def enum_values(enum: type[StrEnum], /) -> list[str]:
 ##
 
 
+@dataclass(kw_only=True, slots=True)
+class ExtractURLOutput:
+    username: str
+    password: secret_str
+    host: str
+    port: int
+    database: str
+
+
+def extract_url(url: URL, /) -> ExtractURLOutput:
+    """Extract the database, host & port from a URL."""
+    if url.username is None:
+        raise _ExtractURLUsernameError(url=url)
+    if url.password is None:
+        raise _ExtractURLPasswordError(url=url)
+    if url.host is None:
+        raise _ExtractURLHostError(url=url)
+    if url.port is None:
+        raise _ExtractURLPortError(url=url)
+    if url.database is None:
+        raise _ExtractURLDatabaseError(url=url)
+    return ExtractURLOutput(
+        username=url.username,
+        password=secret_str(url.password),
+        host=url.host,
+        port=url.port,
+        database=url.database,
+    )
+
+
+@dataclass(kw_only=True, slots=True)
+class ExtractURLError(Exception):
+    url: URL
+
+
+@dataclass(kw_only=True, slots=True)
+class _ExtractURLUsernameError(ExtractURLError):
+    @override
+    def __str__(self) -> str:
+        return f"Expected URL to contain a user name; got {self.url}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _ExtractURLPasswordError(ExtractURLError):
+    @override
+    def __str__(self) -> str:
+        return f"Expected URL to contain a password; got {self.url}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _ExtractURLHostError(ExtractURLError):
+    @override
+    def __str__(self) -> str:
+        return f"Expected URL to contain a host; got {self.url}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _ExtractURLPortError(ExtractURLError):
+    @override
+    def __str__(self) -> str:
+        return f"Expected URL to contain a port; got {self.url}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _ExtractURLDatabaseError(ExtractURLError):
+    @override
+    def __str__(self) -> str:
+        return f"Expected URL to contain a database; got {self.url}"
+
+
+##
+
+
 def get_chunk_size(
     dialect_or_engine_or_conn: DialectOrEngineOrConnectionOrAsync,
     table_or_orm_or_num_cols: TableOrORMInstOrClass | Sized | int,
@@ -1180,6 +1253,8 @@ __all__ = [
     "CheckEngineError",
     "DialectOrEngineOrConnectionOrAsync",
     "EngineOrConnectionOrAsync",
+    "ExtractURLError",
+    "ExtractURLOutput",
     "GetTableError",
     "InsertItemsError",
     "TablenameMixin",
@@ -1193,6 +1268,7 @@ __all__ = [
     "ensure_tables_dropped",
     "enum_name",
     "enum_values",
+    "extract_url",
     "get_chunk_size",
     "get_column_names",
     "get_columns",