dycw-utilities 0.136.4__tar.gz → 0.136.5__tar.gz

{dycw_utilities-0.136.4 → dycw_utilities-0.136.5}/PKG-INFO

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

{dycw_utilities-0.136.4 → dycw_utilities-0.136.5}/pyproject.toml

@@ -41,7 +41,7 @@ fpdf2 = ["fpdf2 >= 2.8.3, < 2.9"]
 hashlib-test = ["orjson"]
 http-test = ["orjson"]
 hypothesis = ["hypothesis >= 6.135.2, < 6.136"]
-hypothesis-test = ["luigi", "pathvalidate", "numpy", "pytest-rerunfailures"]
+hypothesis-test = ["libcst", "luigi", "pathvalidate", "numpy", "pytest-rerunfailures"]
 inflect = ["inflect >= 7.5.0, < 7.6"]
 jupyter-test = ["pandas", "polars"]
 libcst = ["libcst >= 1.8.0, < 1.9"]
@@ -105,7 +105,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.136.4"
+version = "0.136.5"
 
 [project.optional-dependencies]
 logging = [
@@ -133,7 +133,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.136.4"
+current_version = "0.136.5"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.136.4 → dycw_utilities-0.136.5}/src/tests/test_hypothesis.py

@@ -21,6 +21,7 @@ from hypothesis.strategies import (
     sets,
     timezones,
 )
+from libcst import Import, ImportFrom
 from luigi import Task
 from numpy import inf, int64, isfinite, isinf, isnan, ravel, rint
 from pathvalidate import validate_filepath
@@ -55,6 +56,8 @@ from utilities.hypothesis import (
     freqs,
     git_repos,
     hashables,
+    import_froms,
+    imports,
     int32s,
     int64s,
     int_arrays,
@@ -88,6 +91,8 @@ from utilities.hypothesis import (
     versions,
     zoned_datetimes,
 )
+from utilities.iterables import one
+from utilities.libcst import parse_import
 from utilities.math import (
     MAX_FLOAT32,
     MAX_FLOAT64,
@@ -514,6 +519,36 @@ class TestHashables:
         _ = hash(x)
 
 
+class TestImports:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_depth = data.draw(integers(0, 10) | none())
+        max_depth = data.draw(integers(0, 10) | none())
+        with assume_does_not_raise(InvalidArgument):
+            imp = data.draw(imports(min_depth=min_depth, max_depth=max_depth))
+        assert isinstance(imp, Import)
+        parsed = one(parse_import(imp))
+        if min_depth is not None:
+            assert len(parsed.module.split(".")) >= min_depth
+        if max_depth is not None:
+            assert len(parsed.module.split(".")) <= max_depth
+
+
+class TestImportFroms:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_depth = data.draw(integers(0, 10) | none())
+        max_depth = data.draw(integers(0, 10) | none())
+        with assume_does_not_raise(InvalidArgument):
+            imp = data.draw(import_froms(min_depth=min_depth, max_depth=max_depth))
+        assert isinstance(imp, ImportFrom)
+        parsed = one(parse_import(imp))
+        if min_depth is not None:
+            assert len(parsed.module.split(".")) >= min_depth
+        if max_depth is not None:
+            assert len(parsed.module.split(".")) <= max_depth
+
+
 class TestIntArrays:
     @given(
         data=data(),
@@ -648,10 +683,17 @@ class TestPairs:
 class TestPaths:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        path = data.draw(paths())
+        min_depth = data.draw(integers(0, 10) | none())
+        max_depth = data.draw(integers(0, 10) | none())
+        with assume_does_not_raise(InvalidArgument):
+            path = data.draw(paths(min_depth=min_depth, max_depth=max_depth))
         assert isinstance(path, Path)
         assert not path.is_absolute()
         validate_filepath(str(path))
+        if min_depth is not None:
+            assert len(path.parts) >= min_depth
+        if max_depth is not None:
+            assert len(path.parts) <= max_depth
 
 
 class TestPlainDateTimes:

{dycw_utilities-0.136.4 → dycw_utilities-0.136.5}/src/tests/test_libcst.py

@@ -25,8 +25,8 @@ from utilities.libcst import (
     _ParseImportAliasError,
     _ParseImportEmptyModuleError,
     generate_f_string,
-    generate_from_import,
     generate_import,
+    generate_import_from,
     join_dotted_str,
     parse_import,
     render_module,
@@ -42,22 +42,6 @@ class TestGenerateFString:
         assert result == expected
 
 
-class TestGenerateFromImport:
-    @given(
-        case=sampled_from([
-            ("foo", "bar", None, "from foo import bar"),
-            ("foo", "bar", "bar2", "from foo import bar as bar2"),
-            ("foo.bar", "baz", None, "from foo.bar import baz"),
-            ("foo.bar", "baz", "baz2", "from foo.bar import baz as baz2"),
-        ])
-    )
-    def test_main(self, *, case: tuple[str, str, str | None, str]) -> None:
-        module, name, asname, expected = case
-        imp = generate_from_import(module, name, asname=asname)
-        result = Module([SimpleStatementLine([imp])]).code.strip("\n")
-        assert result == expected
-
-
 class TestGenerateImport:
     @given(
         case=sampled_from([
@@ -74,6 +58,22 @@ class TestGenerateImport:
         assert result == expected
 
 
+class TestGenerateImportFrom:
+    @given(
+        case=sampled_from([
+            ("foo", "bar", None, "from foo import bar"),
+            ("foo", "bar", "bar2", "from foo import bar as bar2"),
+            ("foo.bar", "baz", None, "from foo.bar import baz"),
+            ("foo.bar", "baz", "baz2", "from foo.bar import baz as baz2"),
+        ])
+    )
+    def test_main(self, *, case: tuple[str, str, str | None, str]) -> None:
+        module, name, asname, expected = case
+        imp = generate_import_from(module, name, asname=asname)
+        result = Module([SimpleStatementLine([imp])]).code.strip("\n")
+        assert result == expected
+
+
 class TestParseImport:
     def test_import_one_name(self) -> None:
         imp = Import(names=[ImportAlias(Name("foo"))])

{dycw_utilities-0.136.4 → dycw_utilities-0.136.5}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.136.4"
+__version__ = "0.136.5"

{dycw_utilities-0.136.4 → dycw_utilities-0.136.5}/src/utilities/hypothesis.py

@@ -106,6 +106,7 @@ if TYPE_CHECKING:
     from collections.abc import Collection, Hashable, Iterable, Iterator
 
     from hypothesis.database import ExampleDatabase
+    from libcst import Import, ImportFrom
     from numpy.random import RandomState
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
@@ -555,6 +556,59 @@ def hashables() -> SearchStrategy[Hashable]:
 ##
 
 
+@composite
+def import_froms(
+    draw: DrawFn,
+    /,
+    *,
+    min_depth: MaybeSearchStrategy[int | None] = None,
+    max_depth: MaybeSearchStrategy[int | None] = None,
+) -> ImportFrom:
+    """Strategy for generating import-froms."""
+    from utilities.libcst import generate_import_from
+
+    min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
+    path = draw(
+        paths(
+            min_depth=1 if min_depth_ is None else max(min_depth_, 1),
+            max_depth=max_depth_,
+        )
+    )
+    module = ".".join(path.parts)
+    name = draw(text_ascii(min_size=1))
+    asname = draw(text_ascii(min_size=1) | none())
+    return generate_import_from(module, name, asname=asname)
+
+
+##
+
+
+@composite
+def imports(
+    draw: DrawFn,
+    /,
+    *,
+    min_depth: MaybeSearchStrategy[int | None] = None,
+    max_depth: MaybeSearchStrategy[int | None] = None,
+) -> Import:
+    """Strategy for generating imports."""
+    from utilities.libcst import generate_import
+
+    min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
+    path = draw(
+        paths(
+            min_depth=1 if min_depth_ is None else max(min_depth_, 1),
+            max_depth=max_depth_,
+        )
+    )
+    module = ".".join(path.parts)
+    asname = draw(text_ascii(min_size=1) | none())
+    return generate_import(module, asname=asname)
+
+
+##
+
+
 @composite
 def int_arrays(
     draw: DrawFn,
@@ -746,11 +800,32 @@ def _pairs_map[T](elements: list[T], /) -> tuple[T, T]:
 ##
 
 
-def paths() -> SearchStrategy[Path]:
+@composite
+def paths(
+    draw: DrawFn,
+    /,
+    *,
+    min_depth: MaybeSearchStrategy[int | None] = None,
+    max_depth: MaybeSearchStrategy[int | None] = None,
+) -> Path:
     """Strategy for generating `Path`s."""
+    min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
+    parts = draw(
+        lists(
+            _path_parts(),
+            min_size=0 if min_depth_ is None else min_depth_,
+            max_size=max_depth_,
+        )
+    )
+    return Path(*parts)
+
+
+@composite
+def _path_parts(draw: DrawFn, /) -> str:
+    part = draw(text_ascii(min_size=1, max_size=10))
     reserved = {"AUX", "NUL"}
-    strategy = text_ascii(min_size=1, max_size=10).filter(lambda x: x not in reserved)
-    return lists(strategy, max_size=10).map(lambda parts: Path(*parts))
+    _ = assume(part not in reserved)
+    return part
 
 
 ##
@@ -1292,6 +1367,8 @@ __all__ = [
     "freqs",
     "git_repos",
     "hashables",
+    "import_froms",
+    "imports",
     "int32s",
     "int64s",
     "int_arrays",

{dycw_utilities-0.136.4 → dycw_utilities-0.136.5}/src/utilities/libcst.py

@@ -23,16 +23,6 @@ from libcst import (
 from utilities.errors import ImpossibleCaseError
 
 
-def generate_from_import(
-    module: str, name: str, /, *, asname: str | None = None
-) -> ImportFrom:
-    """Generate an `ImportFrom` object."""
-    alias = ImportAlias(
-        name=Name(name), asname=AsName(Name(asname)) if asname else None
-    )
-    return ImportFrom(module=split_dotted_str(module), names=[alias])
-
-
 def generate_f_string(var: str, suffix: str, /) -> FormattedString:
     """Generate an f-string."""
     return FormattedString([
@@ -49,6 +39,16 @@ def generate_import(module: str, /, *, asname: str | None = None) -> Import:
     return Import(names=[alias])
 
 
+def generate_import_from(
+    module: str, name: str, /, *, asname: str | None = None
+) -> ImportFrom:
+    """Generate an `ImportFrom` object."""
+    alias = ImportAlias(
+        name=Name(name), asname=AsName(Name(asname)) if asname else None
+    )
+    return ImportFrom(module=split_dotted_str(module), names=[alias])
+
+
 ##
 
 
@@ -170,8 +170,8 @@ def render_module(source: str | Module, /) -> str:
 __all__ = [
     "ParseImportError",
     "generate_f_string",
-    "generate_from_import",
     "generate_import",
+    "generate_import_from",
     "join_dotted_str",
     "parse_import",
     "render_module",