PyPI - hydra-python - Versions diffs - 0.17.1__tar.gz → 0.17.3__tar.gz - Mend

hydra-python 0.17.1tar.gz → 0.17.3tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

{hydra_python-0.17.1 → hydra_python-0.17.3}/.gitignore RENAMED Viewed

@@ -29,6 +29,7 @@ stack.yaml.lock
 gradle.properties
 /packages/hydra-java/build/
 /heads/java/json-driver/build/
+/heads/java/target-driver/build/
 # IDEs
 .bsp/
@@ -73,31 +74,21 @@ docs/reviews/
 docs/work/
 # Package distributions.
-# dist/json/ is the source of truth (tracked). dist/haskell/ is tracked
-# through the 0.15 release to support bootstrapping from a fresh clone.
-# All other target-language trees are regenerated from dist/json/ and
-# not checked in.
-#
-# Exception within the tracked dist/haskell/ tree (#418): the hand-written
-# distribution-package content that sync-haskell.sh OVERLAYS from its canonical
-# home under the top-level overlay/haskell/ tree is NOT committed — it would
-# duplicate the canonical source. (Removing dist/haskell/ from SCM entirely is
-# deferred; see #376.) The canonical copies under overlay/haskell/ ARE tracked.
-#   - hydra umbrella package (entirely copied)
-dist/haskell/hydra/
-#   - hydra-kernel hand-written runtime (copied from overlay/haskell/hydra-kernel/;
-#     relocated to the Hydra.Overlay.Haskell.* namespace in #501)
-dist/haskell/hydra-kernel/src/main/haskell/Hydra/Settings.hs
-dist/haskell/hydra-kernel/src/main/haskell/Hydra/Kernel.hs
-dist/haskell/hydra-kernel/src/main/haskell/Hydra/Overlay/
-#   - hydra-kernel hand-written test bridge (overlaid from overlay/haskell/.../src/test/)
-dist/haskell/hydra-kernel/src/test/haskell/Hydra/Test/TestEnv.hs
-dist/haskell/hydra-kernel/src/test/haskell/Hydra/Test/DefaultImplGraph.hs
-#   - hydra-pg / hydra-typescript hand-written DSL helpers (overlaid from
-#     overlay/haskell/hydra-{pg,typescript}/; relocated to the
-#     Hydra.Overlay.Haskell.* namespace in #501/#556)
-dist/haskell/hydra-pg/src/main/haskell/Hydra/Overlay/
-dist/haskell/hydra-typescript/src/main/haskell/Hydra/Overlay/
+# dist/json/ is the source of truth (tracked). All target-language trees,
+# INCLUDING dist/haskell/ as of #376, are regenerated from dist/json/ and not
+# checked in. dist/haskell/ was tracked from the 0.15 release through #376 to
+# support bootstrapping from a fresh clone before the cold-clone seeder
+# (heads/haskell/json-driver/) existed; that seeder now performs the same
+# role by regenerating dist/haskell/ from the committed dist/json/ using only
+# published Hackage coder packages — see bin/sync.sh's cold-start detection
+# and heads/haskell/json-driver/bin/cold-seed-dist-haskell.sh. The former
+# per-file overlay exceptions under dist/haskell/ (hydra umbrella,
+# hydra-kernel hand-written runtime, hydra-pg/hydra-typescript DSL helpers)
+# are subsumed by this blanket ignore; their canonical copies remain tracked
+# under overlay/haskell/. (Hackage channel staging artifacts — the sdists and
+# Haddock docs that prepare-release.sh / publish-hackage.sh assemble into
+# dist/haskell/ — are likewise covered by this blanket ignore. #589.)
+dist/haskell/
 dist/clojure/
 dist/common-lisp/
@@ -156,3 +147,6 @@ claude-hydra-messages/
 # survey/ff/bootstrap watchers). These are dot-prefixed .sh under claude/;
 # the tracked claude/ content is the .md protocol docs, never dot-.sh scripts.
 claude/.*.sh
+# Backed-up branch plan documents (not release content)
+finalized-task-plans/

hydra_python-0.17.1/README.md → hydra_python-0.17.3/PKG-INFO RENAMED Viewed

@@ -1,3 +1,17 @@
+Metadata-Version: 2.4
+Name: hydra-python
+Version: 0.17.3
+Summary: Python support for Hydra
+Project-URL: Homepage, https://github.com/CategoricalData/hydra
+Project-URL: Repository, https://github.com/CategoricalData/hydra
+Author-email: Joshua Shinavier <josh@fortytwo.net>
+License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.12
+Requires-Dist: hydra-kernel==0.17.3
+Description-Content-Type: text/markdown
 # Hydra-Python
 This package contains the **Python coder DSL sources**: Python modules that describe
@@ -11,6 +25,12 @@ Hydra is a type-aware data transformation toolkit which aims to be highly flexib
 It has its roots in graph databases and type theory, and provides APIs in Haskell, Java, Python, Scala, TypeScript, and Lisp.
 See the main Hydra [README](https://github.com/CategoricalData/hydra) for more details.
+📖 **API documentation:** Sphinx-generated API docs for the Python packages are published at the
+[Hydra Python API index](https://categoricaldata.net/hydra/python/sphinx/)
+(individual packages: [hydra-kernel](https://categoricaldata.net/hydra/python/sphinx/hydra-kernel/),
+[hydra-rdf](https://categoricaldata.net/hydra/python/sphinx/hydra-rdf/),
+[hydra-pg](https://categoricaldata.net/hydra/python/sphinx/hydra-pg/)).
 ## Getting started
 Hydra-Python requires Python 3.12 or later.
@@ -44,7 +64,7 @@ For comprehensive documentation about Hydra's architecture and usage, see:
 - **[Code Organization](https://github.com/CategoricalData/hydra/wiki/Code-organization)** -
   The `packages/`, `heads/`, `dist/` layout
 - **[Testing](https://github.com/CategoricalData/hydra/wiki/Testing)** -
-  Common test suite documentation
+  Hydra-kernel test suite documentation
 - **[Developer Recipes](https://github.com/CategoricalData/hydra/blob/main/docs/recipes/index.md)** -
   Step-by-step guides
 - **[Syncing Hydra-Python](https://github.com/CategoricalData/hydra/blob/main/docs/recipes/syncing-python.md)** -
@@ -52,15 +72,15 @@ For comprehensive documentation about Hydra's architecture and usage, see:
 ## Testing
-Hydra-Python has two types of tests: the **common test suite** (shared across all Hydra implementations)
+Hydra-Python has two types of tests: the **hydra-kernel test suite** (shared across all Hydra implementations)
 and **Python-specific tests**.
 See the [Testing wiki page](https://github.com/CategoricalData/hydra/wiki/Testing)
 for comprehensive documentation.
-### Common test suite
+### Hydra-kernel test suite
-The common test suite (`hydra.test.testSuite`) ensures parity across all Hydra implementations.
-**Passing all common test suite cases is the criterion for a true Hydra implementation.**
+The hydra-kernel test suite (`hydra.test.testSuite`) ensures parity across all Hydra implementations.
+**Passing all hydra-kernel test suite cases is the criterion for a true Hydra implementation.**
 To run all tests (from `heads/python/`):
@@ -68,7 +88,7 @@ To run all tests (from `heads/python/`):
 cd heads/python && pytest
 ```
-To run only the common test suite:
+To run only the hydra-kernel test suite:
 ```bash
 cd heads/python && pytest src/test/python/test_suite_runner.py
@@ -86,7 +106,7 @@ The test suite is generated from Hydra DSL sources and includes:
 ### Python-specific tests
 Python-specific tests validate implementation details and Python-specific functionality.
-These are located in `heads/python/src/test/python/` alongside the common test suite runner.
+These are located in `heads/python/src/test/python/` alongside the hydra-kernel test suite runner.
 To run a specific test file:
@@ -120,10 +140,10 @@ Hydra's Python code is split across three locations
 - **Python kernel overlay** ([`overlay/python/hydra-kernel/src/main/python/`](https://github.com/CategoricalData/hydra/tree/main/overlay/python/hydra-kernel/src/main/python))
   — hand-written Python kernel runtime, overlaid onto `dist/python/hydra-kernel/`
   by `heads/python/bin/copy-kernel-runtime.sh` so the published `hydra-kernel` wheel is self-contained
-  - `hydra/lib/` — primitive function implementations
-  - `hydra/dsl/` — DSL utilities (FrozenDict, Maybe, ...)
-  - `hydra/python/util/` — `ConsList`, `Lazy`, `PersistentMap`, `PersistentSet`
-  - `hydra/sources/libraries.py` — primitive registration
+  - `hydra/overlay/python/lib/` — primitive function implementations
+  - `hydra/overlay/python/dsl/` — DSL utilities (FrozenDict, Maybe, ...)
+  - `hydra/overlay/python/util/` — `ConsList`, `Lazy`, `PersistentMap`, `PersistentSet`
+  - `hydra/overlay/python/sources/libraries.py` — primitive registration
 - **Python head** ([`heads/python/src/main/python/`](https://github.com/CategoricalData/hydra/tree/main/heads/python/src/main/python))
   — bootstrap layer above the kernel (`bootstrap.py`, `generation.py`, the `hydra.python` coder
   package). `pyproject.toml` lives in `heads/python/`.

hydra_python-0.17.1/PKG-INFO → hydra_python-0.17.3/README.md RENAMED Viewed

@@ -1,17 +1,3 @@
-Metadata-Version: 2.4
-Name: hydra-python
-Version: 0.17.1
-Summary: Python support for Hydra
-Project-URL: Homepage, https://github.com/CategoricalData/hydra
-Project-URL: Repository, https://github.com/CategoricalData/hydra
-Author-email: Joshua Shinavier <josh@fortytwo.net>
-License: Apache-2.0
-License-File: LICENSE
-License-File: NOTICE
-Requires-Python: >=3.12
-Requires-Dist: hydra-kernel==0.17.1
-Description-Content-Type: text/markdown
 # Hydra-Python
 This package contains the **Python coder DSL sources**: Python modules that describe
@@ -25,6 +11,12 @@ Hydra is a type-aware data transformation toolkit which aims to be highly flexib
 It has its roots in graph databases and type theory, and provides APIs in Haskell, Java, Python, Scala, TypeScript, and Lisp.
 See the main Hydra [README](https://github.com/CategoricalData/hydra) for more details.
+📖 **API documentation:** Sphinx-generated API docs for the Python packages are published at the
+[Hydra Python API index](https://categoricaldata.net/hydra/python/sphinx/)
+(individual packages: [hydra-kernel](https://categoricaldata.net/hydra/python/sphinx/hydra-kernel/),
+[hydra-rdf](https://categoricaldata.net/hydra/python/sphinx/hydra-rdf/),
+[hydra-pg](https://categoricaldata.net/hydra/python/sphinx/hydra-pg/)).
 ## Getting started
 Hydra-Python requires Python 3.12 or later.
@@ -58,7 +50,7 @@ For comprehensive documentation about Hydra's architecture and usage, see:
 - **[Code Organization](https://github.com/CategoricalData/hydra/wiki/Code-organization)** -
   The `packages/`, `heads/`, `dist/` layout
 - **[Testing](https://github.com/CategoricalData/hydra/wiki/Testing)** -
-  Common test suite documentation
+  Hydra-kernel test suite documentation
 - **[Developer Recipes](https://github.com/CategoricalData/hydra/blob/main/docs/recipes/index.md)** -
   Step-by-step guides
 - **[Syncing Hydra-Python](https://github.com/CategoricalData/hydra/blob/main/docs/recipes/syncing-python.md)** -
@@ -66,15 +58,15 @@ For comprehensive documentation about Hydra's architecture and usage, see:
 ## Testing
-Hydra-Python has two types of tests: the **common test suite** (shared across all Hydra implementations)
+Hydra-Python has two types of tests: the **hydra-kernel test suite** (shared across all Hydra implementations)
 and **Python-specific tests**.
 See the [Testing wiki page](https://github.com/CategoricalData/hydra/wiki/Testing)
 for comprehensive documentation.
-### Common test suite
+### Hydra-kernel test suite
-The common test suite (`hydra.test.testSuite`) ensures parity across all Hydra implementations.
-**Passing all common test suite cases is the criterion for a true Hydra implementation.**
+The hydra-kernel test suite (`hydra.test.testSuite`) ensures parity across all Hydra implementations.
+**Passing all hydra-kernel test suite cases is the criterion for a true Hydra implementation.**
 To run all tests (from `heads/python/`):
@@ -82,7 +74,7 @@ To run all tests (from `heads/python/`):
 cd heads/python && pytest
 ```
-To run only the common test suite:
+To run only the hydra-kernel test suite:
 ```bash
 cd heads/python && pytest src/test/python/test_suite_runner.py
@@ -100,7 +92,7 @@ The test suite is generated from Hydra DSL sources and includes:
 ### Python-specific tests
 Python-specific tests validate implementation details and Python-specific functionality.
-These are located in `heads/python/src/test/python/` alongside the common test suite runner.
+These are located in `heads/python/src/test/python/` alongside the hydra-kernel test suite runner.
 To run a specific test file:
@@ -134,10 +126,10 @@ Hydra's Python code is split across three locations
 - **Python kernel overlay** ([`overlay/python/hydra-kernel/src/main/python/`](https://github.com/CategoricalData/hydra/tree/main/overlay/python/hydra-kernel/src/main/python))
   — hand-written Python kernel runtime, overlaid onto `dist/python/hydra-kernel/`
   by `heads/python/bin/copy-kernel-runtime.sh` so the published `hydra-kernel` wheel is self-contained
-  - `hydra/lib/` — primitive function implementations
-  - `hydra/dsl/` — DSL utilities (FrozenDict, Maybe, ...)
-  - `hydra/python/util/` — `ConsList`, `Lazy`, `PersistentMap`, `PersistentSet`
-  - `hydra/sources/libraries.py` — primitive registration
+  - `hydra/overlay/python/lib/` — primitive function implementations
+  - `hydra/overlay/python/dsl/` — DSL utilities (FrozenDict, Maybe, ...)
+  - `hydra/overlay/python/util/` — `ConsList`, `Lazy`, `PersistentMap`, `PersistentSet`
+  - `hydra/overlay/python/sources/libraries.py` — primitive registration
 - **Python head** ([`heads/python/src/main/python/`](https://github.com/CategoricalData/hydra/tree/main/heads/python/src/main/python))
   — bootstrap layer above the kernel (`bootstrap.py`, `generation.py`, the `hydra.python` coder
   package). `pyproject.toml` lives in `heads/python/`.

{hydra_python-0.17.1 → hydra_python-0.17.3}/build/main/digest.json RENAMED Viewed

@@ -1,40 +1,40 @@
 {
   "digestFormatVersion": 1,
   "moduleFormatVersion": 1,
-  "generator": "fac2cd88719cd8aa",
+  "generator": "983e925152c14e7d",
   "generation": {
-    "generatorId": "fac2cd88719cd8aa",
+    "generatorId": "983e925152c14e7d",
     "mode": "published",
-    "hydraVersion": "0.17.0",
-    "revision": "68f5773dae-dirty",
-    "timestamp": "2026-07-10T23:43:07Z",
+    "hydraVersion": "0.17.2",
+    "revision": "fa099dc0f8",
+    "timestamp": "2026-07-31T15:44:34Z",
     "host": "python"
   },
-  "selfHash": "2e7e5a8f53bbb9198075728dc87c31624a25d245bc3cd02fff6ef77157e90091",
-  "depHash:hydra-kernel": "8067c7a989a8f25c7823410c00e40eba302a0380f864dc28ff303581ac8c100f",
+  "selfHash": "8f12cad96047b0fe5cef599a843cbf5dd50d077d099b2a8462568a9b9064536b",
+  "depHash:hydra-kernel": "331eaf0751864ad00dbe4f2d53a1bf6c95709e006df1c87c98284a5efb306708",
   "inputs": {
-    "hydra.python.coder": { "kind": "Other", "hash": "dc2b9ad0a0fc5cada2f82ff850db14db1368447c62a20e0846c9fca136e84309" },
+    "hydra.python.coder": { "kind": "Other", "hash": "784bf72060179ad7c64e71008b68892b98b081a2826fc337768bf0b0e97cfc6f" },
     "hydra.python.environment": { "kind": "Other", "hash": "e14b76188ef4da15c8f011740ed2751e9b55cd0e13f9d9e9d6917cb644526ac9" },
     "hydra.python.language": { "kind": "Other", "hash": "78fb867a1d0fa6654f46f5d9fd72c2c5607d2934b7c7fbd5f5d830786b4ad91e" },
-    "hydra.python.names": { "kind": "Other", "hash": "85e048a96cf966e2280c6ed8f74d9d801d34e8a983e04de1ab3fb73e168d97f8" },
+    "hydra.python.names": { "kind": "Other", "hash": "f0e81d57cda13bc617185cc2d09240091e816ba9fb2e1c9e6091ef888ea34e22" },
     "hydra.python.pyproject": { "kind": "Other", "hash": "249512648b2b008db234ee348a72056d4d625cfeb0a80d8caacbda95002569a2" },
-    "hydra.python.serde": { "kind": "Other", "hash": "56c35209fc8428472299facbb972ce2d63863a4a970714f9b34d34c2af08159c" },
+    "hydra.python.serde": { "kind": "Other", "hash": "9285fa0296e940da1de51a53465598455c46404851aefc2ce15220fc6ee7efc6" },
     "hydra.python.syntax": { "kind": "Other", "hash": "88a9154b48fd429f06efa0ba8981bdf12af3fed4de5a057b3304fadc623dbc19" },
-    "hydra.python.testing": { "kind": "Other", "hash": "624c33ec2714b57c2d5917c03b590088c210dd5b27b5f3ae78d0476e9f11859b" },
-    "hydra.python.utils": { "kind": "Other", "hash": "3f374ef5605f94725379aded1afcb0b5fe5ea84a4e78dd2b0bbc649d0ec672c6" },
+    "hydra.python.testing": { "kind": "Other", "hash": "a40b949c594c81f8925ba423a89e46964b2b1475d44a486aa07c792c2c7f807b" },
+    "hydra.python.utils": { "kind": "Other", "hash": "d5769b4f1a6952f8786b77a7e9e1699b278eb514879174b5a9dd7b08e4b55686" },
     "jsonContent:hydra/dsl/python/environment.json": { "kind": "Other", "hash": "670d83127f7a308b11a577e3481eb9926d366a1046ab99a5e1578b0bf72159c4" },
     "jsonContent:hydra/dsl/python/names.json": { "kind": "Other", "hash": "244d73ec6a140f89bafcbb87dc8570a09f50151508aa0443708e7070749be876" },
     "jsonContent:hydra/dsl/python/syntax.json": { "kind": "Other", "hash": "a99b94b1f3e542d606da15fd6dafa32d858ce7d71ba02f7b21d8bb4881daa4e3" },
     "jsonContent:hydra/dsl/python/utils.json": { "kind": "Other", "hash": "5464cb8e1db43a03b98327746b668050f4159a90f13ce5334c32e6d7dbbceb4c" },
-    "jsonContent:hydra/python/coder.json": { "kind": "Other", "hash": "08474252a6c6d5f46df96fd8d2800324e65a04eb610572475cadc07aaacd9f58" },
+    "jsonContent:hydra/python/coder.json": { "kind": "Other", "hash": "7bd00830dda91a23bddb7d1fd36ea48e79821a81778b809a50924ac959619b61" },
     "jsonContent:hydra/python/environment.json": { "kind": "Other", "hash": "b5bc63f7d18f47262c90738cb793098f88a97376fd52088b3c8661c1d9ea5cbd" },
     "jsonContent:hydra/python/language.json": { "kind": "Other", "hash": "221e68d68030945db181fdd079be4ff619cb4cd1ad5d4b72b4e70f2aa1bd5230" },
-    "jsonContent:hydra/python/names.json": { "kind": "Other", "hash": "593cbc7e36735c0d92e34df76e17e4adc949e593e84bcf697b3163b2209a7b1a" },
+    "jsonContent:hydra/python/names.json": { "kind": "Other", "hash": "51a59a9f21446bb6cfb128e4830c74e33a42ddaffbe67afddfa55d9fee610fb9" },
     "jsonContent:hydra/python/pyproject.json": { "kind": "Other", "hash": "c94de46f1615e6e82d2f706d01ef04293373f6241a9a42882bb394d51b4f7f53" },
-    "jsonContent:hydra/python/serde.json": { "kind": "Other", "hash": "fc154ee28315726ae77a0036d7c83c6481fed08fa9464138730ff702dd5b0434" },
+    "jsonContent:hydra/python/serde.json": { "kind": "Other", "hash": "648d34f63d2336972d5e0a59d4871332a07bd35c88eb38c28236e16a7fd48601" },
     "jsonContent:hydra/python/syntax.json": { "kind": "Other", "hash": "8dc3a26ac927fa338b273c9deee6317906977a2deec4c2df1e44ff0bbe0a64cd" },
-    "jsonContent:hydra/python/testing.json": { "kind": "Other", "hash": "ea1cbdd469bb2fc8bac0445d75df3d97f832f86ec460bacc06056a6f8f5bfb8a" },
-    "jsonContent:hydra/python/utils.json": { "kind": "Other", "hash": "19fcf00beab2f029d765d9212ae2b8be4327ef84aa54702dc55dbe620eba74dc" },
+    "jsonContent:hydra/python/testing.json": { "kind": "Other", "hash": "9c75b534004194396935b1dd3331bae4d8d5cbb31c3959fa3794dda00960c09a" },
+    "jsonContent:hydra/python/utils.json": { "kind": "Other", "hash": "fea597ac6c71916255914f8196c377b780d32b475b5b81cd1c0a087b8abe87c3" },
     "jsonContent:manifest.json": { "kind": "Other", "hash": "3f94b521766d042381d7bee84596308ea4e35c7e8fb45f8fd8338a8dbe27a0ac" }
   },
   "outputs": {
@@ -42,14 +42,14 @@
     "hydra/dsl/python/names.py": { "kind": "TargetFile", "hash": "3733bed7b32e56239c4c2dd5a748e66ee0f5b9eff629687648a5ebe232508a93" },
     "hydra/dsl/python/syntax.py": { "kind": "TargetFile", "hash": "5fe1c0c739cdac68d1b90d768153e23ebe7c805bafb96ac698a95425e2d7d7b5" },
     "hydra/dsl/python/utils.py": { "kind": "TargetFile", "hash": "fbf8522b1d5c64eb570027d579b512caf7ae3853f010b4e4666746df6d262812" },
-    "hydra/python/coder.py": { "kind": "TargetFile", "hash": "c5761e616bd8efc7c1aff800be8f606b1d4b91f8cd27cf1d5ca376873cedc679" },
+    "hydra/python/coder.py": { "kind": "TargetFile", "hash": "8a2d415e5e026b13d6c7fd620dcce839443f028cc34720a79e6a2de482f06238" },
     "hydra/python/environment.py": { "kind": "TargetFile", "hash": "240979735f3a2d479403834c1a4d7a16f060ad447eb4f3b05fbb2db591d7ad0b" },
     "hydra/python/language.py": { "kind": "TargetFile", "hash": "7ea0c3a6015ec1de92aebeed0963c1af9f3b70c8d57815e477c528c795383604" },
-    "hydra/python/names.py": { "kind": "TargetFile", "hash": "da24e2a2622692b875e55987179397f23d243ceb2311572befada3da95fddd7c" },
+    "hydra/python/names.py": { "kind": "TargetFile", "hash": "09490cd34e878fa3c9ad7940171b86a60843fe7591f78d7bb57eb3c52c4edc2e" },
     "hydra/python/pyproject.py": { "kind": "TargetFile", "hash": "1f9001d8d2273d4783105e099b874c273ce520b58456f9b447cb8d5e9a6a37d7" },
-    "hydra/python/serde.py": { "kind": "TargetFile", "hash": "c8f437960117837fd1c0db1300f343e1defb644e0239d4c8ceba9ee8d5e24eeb" },
+    "hydra/python/serde.py": { "kind": "TargetFile", "hash": "ad1714baddb710cd3f345c339a9e6a55862197660cd065ac84d3736716792cbf" },
     "hydra/python/syntax.py": { "kind": "TargetFile", "hash": "24a72af882b47d80cc930f16f51a3e9c1a71c9d8da47a921829f40e847459fca" },
-    "hydra/python/testing.py": { "kind": "TargetFile", "hash": "f4e37636391d0abc27a7d722554ded2e8ac7ae8a11f513cb24822d7cdbca4fe7" },
-    "hydra/python/utils.py": { "kind": "TargetFile", "hash": "afb0cb6952a26e4be51d8b650e69d793334c37243ab42b910a93c96eaa8ad99b" }
+    "hydra/python/testing.py": { "kind": "TargetFile", "hash": "2b9137ccd1449a8c636c59df9dc5d83662ed1e9547802ba6b8c2c5db5ee29710" },
+    "hydra/python/utils.py": { "kind": "TargetFile", "hash": "05504b0be6dff96d72997295abd89a5510bbc8580b48f85bd25575b313e19645" }
   }
 }

{hydra_python-0.17.1 → hydra_python-0.17.3}/pyproject.toml RENAMED Viewed

@@ -13,7 +13,7 @@
 [project]
 name = "hydra-python"
-version = "0.17.1"
+version = "0.17.3"
 description = "Python support for Hydra"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -22,7 +22,7 @@ authors = [
     { name = "Joshua Shinavier", email = "josh@fortytwo.net" },
 ]
 dependencies = [
-    "hydra-kernel == 0.17.1",
+    "hydra-kernel == 0.17.3",
 ]
 [project.urls]

{hydra_python-0.17.1 → hydra_python-0.17.3}/src/main/python/hydra/python/coder.py RENAMED Viewed

@@ -30,12 +30,14 @@ import hydra.overlay.python.lib.logic
 import hydra.overlay.python.lib.maps
 import hydra.overlay.python.lib.math
 import hydra.overlay.python.lib.optionals
+import hydra.overlay.python.lib.ordering
 import hydra.overlay.python.lib.pairs
 import hydra.overlay.python.lib.sets
 import hydra.overlay.python.lib.strings
 import hydra.names
 import hydra.packaging
 import hydra.predicates
+import hydra.print.core
 import hydra.python.environment
 import hydra.python.names
 import hydra.python.serde
@@ -46,7 +48,6 @@ import hydra.resolution
 import hydra.rewriting
 import hydra.scoping
 import hydra.serialization
-import hydra.show.core
 import hydra.strip
 import hydra.typing
 import hydra.util
@@ -97,7 +98,7 @@ def builder_setter_name(env: hydra.python.environment.PythonEnvironment, fname:
     base = Lazy((lambda : hydra.python.names.encode_field_name(env, fname).value))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.or_(hydra.overlay.python.lib.equality.equal(base(), "build"),
     hydra.overlay.python.lib.logic.or_(hydra.overlay.python.lib.equality.equal(base(), "builder"), hydra.overlay.python.lib.equality.equal(base(), "self"))),
-    (lambda : hydra.overlay.python.lib.strings.cat2(base(), "_")),
+    (lambda : hydra.overlay.python.lib.strings.concat2(base(), "_")),
     (lambda : base()))
 def deconflict_variant_name(is_qualified: bool,
@@ -107,12 +108,12 @@ fname: hydra.core.Name,
 g: hydra.graph.Graph) -> hydra.python.syntax.Name:
     r"""Deconflict a variant name to avoid collisions with type names."""
-    candidate_hydra_name = Lazy((lambda : hydra.core.Name(hydra.overlay.python.lib.strings.cat2(union_name.value, hydra.formatting.capitalize(fname.value)))))
+    candidate_hydra_name = Lazy((lambda : hydra.core.Name(hydra.overlay.python.lib.strings.concat2(union_name.value, hydra.formatting.capitalize(fname.value)))))
     term_collision = Lazy((lambda : hydra.overlay.python.lib.maps.member(candidate_hydra_name(), g.bound_terms)))
     type_collision = Lazy((lambda : hydra.overlay.python.lib.maps.member(candidate_hydra_name(), g.schema_types)))
     collision = Lazy((lambda : hydra.overlay.python.lib.logic.or_(term_collision(), type_collision())))
     return hydra.overlay.python.lib.logic.if_else(collision(),
-    (lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.strings.cat2(hydra.python.names.variant_name(is_qualified, env, union_name, fname).value, "_"))),
+    (lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2(hydra.python.names.variant_name(is_qualified, env, union_name, fname).value, "_"))),
     (lambda : hydra.python.names.variant_name(is_qualified, env, union_name, fname)))
 def eliminate_unit_var(v: hydra.core.Name, term0: hydra.core.Term) -> hydra.core.Term:
@@ -195,7 +196,7 @@ def is_variant_unit_type(row_type: Sequence[hydra.core.FieldType], field_name: h
     r"""Check if a variant field has unit type."""
     mfield = Lazy((lambda : hydra.overlay.python.lib.lists.find((lambda ft: hydra.overlay.python.lib.equality.equal(ft.name, field_name)), row_type)))
-    return hydra.overlay.python.lib.optionals.from_optional((lambda : False),
+    return hydra.overlay.python.lib.optionals.with_default((lambda : False),
     hydra.overlay.python.lib.optionals.map((lambda ft: hydra.predicates.is_unit_type(hydra.strip.deannotate_type(ft.type))), mfield()))
 def class_variant_pattern_unit(py_variant_name: hydra.python.syntax.Name) -> hydra.python.syntax.ClosedPattern:
@@ -331,7 +332,7 @@ def deduplicate_case_variables(cases_: Sequence[hydra.core.CaseAlternative]) ->
                 (lambda : (hydra.overlay.python.lib.maps.insert(v, 1, count_by_name()), hydra.overlay.python.lib.lists.cons(field, done()))),
                 (lambda count: (
                   count2 := Lazy((lambda : hydra.overlay.python.lib.math.add(count, 1))),
-                  v2 := Lazy((lambda : hydra.core.Name(hydra.overlay.python.lib.strings.cat2(v.value, hydra.overlay.python.lib.literals.show_int32(count2.get()))))),
+                  v2 := Lazy((lambda : hydra.core.Name(hydra.overlay.python.lib.strings.concat2(v.value, hydra.overlay.python.lib.literals.show_int32(count2.get()))))),
                   new_body := Lazy((lambda : hydra.reduction.alpha_convert(v, v2.get(), body))),
                   new_lam := Lazy((lambda : hydra.core.Lambda(v2.get(), mdom, new_body.get()))),
                   new_term := Lazy((lambda : cast(hydra.core.Term, hydra.core.TermLambda(new_lam.get())))),
@@ -795,7 +796,7 @@ def encode_function_type(env: hydra.python.environment.PythonEnvironment, ft: hy
 def encode_type(env: hydra.python.environment.PythonEnvironment, typ: hydra.core.Type) -> Either[T0, hydra.python.syntax.Expression]:
     r"""Encode a Hydra type to a Python type expression."""
-    dflt = Lazy((lambda : Right(hydra.python.utils.double_quoted_string(hydra.overlay.python.lib.strings.cat2("type = ", hydra.show.core.type(hydra.strip.deannotate_type(typ)))))))
+    dflt = Lazy((lambda : Right(hydra.python.utils.double_quoted_string(hydra.overlay.python.lib.strings.concat2("type = ", hydra.print.core.type(hydra.strip.deannotate_type(typ)))))))
     match hydra.strip.deannotate_type(typ):
         case hydra.core.TypeApplication(value=at):
             return encode_application_type(env, at)
@@ -876,7 +877,7 @@ def lazy_dot_get(expr: hydra.python.syntax.Expression) -> hydra.python.syntax.Ex
 def make_simple_lambda(arity: int, lhs: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
     r"""Wrap a bare reference to a polymorphic function in an uncurried lambda."""
-    args = Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.cat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
+    args = Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
     hydra.overlay.python.lib.math.range_(1, arity))))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(arity, 0),
     (lambda : lhs),
@@ -936,7 +937,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       (lambda : (
         num_remaining := Lazy((lambda : hydra.overlay.python.lib.math.sub(prim_arity.get(), hydra.overlay.python.lib.lists.length(args)))),
         (
-          remaining_params := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.cat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
+          remaining_params := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
           hydra.overlay.python.lib.math.range_(1, num_remaining.get())))),
           (
             remaining_exprs := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda n: cast(hydra.python.syntax.Expression,
@@ -969,7 +970,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
     (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_binding(g(), name),
     (lambda : hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, tc_metadata),
     (lambda : Left(cast(hydra.errors.Error,
-    hydra.errors.ErrorOther(hydra.errors.OtherError(hydra.overlay.python.lib.strings.cat2("Unknown variable: ", name.value)))))),
+    hydra.errors.ErrorOther(hydra.errors.OtherError(hydra.overlay.python.lib.strings.concat2("Unknown variable: ", name.value)))))),
     (lambda _: Right(as_function_call())))),
     (lambda el: (
       el_trivial1 := Lazy((lambda : hydra.predicates.is_trivial_term(el.term))),
@@ -1125,7 +1126,7 @@ def term_arity_with_primitives(graph: hydra.graph.Graph, term: hydra.core.Term)
     match hydra.strip.deannotate_and_detype_term(term):
         case hydra.core.TermApplication(value=app):
-            return hydra.overlay.python.lib.math.max(0, hydra.overlay.python.lib.math.sub(term_arity_with_primitives(graph, app.function), 1))
+            return hydra.overlay.python.lib.ordering.max(0, hydra.overlay.python.lib.math.sub(term_arity_with_primitives(graph, app.function), 1))
         case hydra.core.TermLambda(value=lam):
             return hydra.overlay.python.lib.math.add(1, term_arity_with_primitives(graph, lam.body))
@@ -1156,7 +1157,7 @@ def encode_application(cx: hydra.typing.InferenceContext, env: hydra.python.envi
     fun = Lazy((lambda : hydra.overlay.python.lib.pairs.first(gathered())))
     args = Lazy((lambda : hydra.overlay.python.lib.pairs.second(gathered())))
     known_arity = Lazy((lambda : term_arity_with_primitives(g(), fun())))
-    arity = Lazy((lambda : hydra.overlay.python.lib.math.max(known_arity(), hydra.overlay.python.lib.lists.length(args()))))
+    arity = Lazy((lambda : hydra.overlay.python.lib.ordering.max(known_arity(), hydra.overlay.python.lib.lists.length(args()))))
     return hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map_list((lambda t: encode_term_inline(cx, env, False, t)), args()),
     (lambda pargs: (
       hargs := Lazy((lambda : hydra.overlay.python.lib.lists.take(arity(), pargs))),
@@ -1177,7 +1178,7 @@ hargs: Sequence[hydra.python.syntax.Expression],
 rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, tuple[hydra.python.syntax.Expression, Sequence[hydra.python.syntax.Expression]]]:
     r"""Inner helper for encodeApplication."""
-    first_arg = Lazy((lambda : hydra.overlay.python.lib.optionals.from_optional((lambda : hydra.python.utils.py_name_to_py_expression(hydra.python.syntax.Name(""))), hydra.overlay.python.lib.lists.maybe_head(hargs))))
+    first_arg = Lazy((lambda : hydra.overlay.python.lib.optionals.with_default((lambda : hydra.python.utils.py_name_to_py_expression(hydra.python.syntax.Name(""))), hydra.overlay.python.lib.lists.head(hargs))))
     rest_args = Lazy((lambda : hydra.overlay.python.lib.lists.drop(1, hargs)))
     def with_rest(e: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
         return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(rest_args()),
@@ -1218,7 +1219,7 @@ rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, t
             (lambda : hydra.overlay.python.lib.eithers.bind(encode_variable(cx, env, name, hargs), (lambda expr: Right((expr, rargs))))),
             (lambda ts: (
               el_arity := Lazy((lambda : hydra.arity.type_scheme_arity(ts))),
-              consume_count := Lazy((lambda : hydra.overlay.python.lib.math.min(el_arity.get(), hydra.overlay.python.lib.lists.length(all_args())))),
+              consume_count := Lazy((lambda : hydra.overlay.python.lib.ordering.min(el_arity.get(), hydra.overlay.python.lib.lists.length(all_args())))),
               consumed_args := Lazy((lambda : hydra.overlay.python.lib.lists.take(consume_count.get(), all_args()))),
               remaining_args := Lazy((lambda : hydra.overlay.python.lib.lists.drop(consume_count.get(), all_args()))),
               hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(consumed_args.get()),
@@ -1557,7 +1558,7 @@ tname: hydra.core.Name) -> Either[T1, Sequence[hydra.python.syntax.CaseBlock]]:
     return hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.cases(mdflt,
     (lambda : Right(hydra.overlay.python.lib.logic.if_else(is_full,
     (lambda : hydra.python.utils.raise_assertion_error("Unreachable: all variants handled")),
-    (lambda : hydra.python.utils.raise_type_error(hydra.overlay.python.lib.strings.cat2("Unsupported ", hydra.names.local_name_of(tname))))))),
+    (lambda : hydra.python.utils.raise_type_error(hydra.overlay.python.lib.strings.concat2("Unsupported ", hydra.names.local_name_of(tname))))))),
     (lambda d: hydra.overlay.python.lib.eithers.bind(term_to_expr(d), (lambda pyexpr: Right(hydra.python.utils.return_single(pyexpr)))))),
     (lambda stmt: (
       patterns := Lazy((lambda : hydra.python.utils.py_closed_pattern_to_py_patterns(cast(hydra.python.syntax.ClosedPattern, hydra.python.syntax.ClosedPatternWildcard())))),
@@ -1576,7 +1577,7 @@ def is_cases_full(row_type: Sequence[T0], cases_: Sequence[T1]) -> bool:
     num_cases = Lazy((lambda : hydra.overlay.python.lib.lists.length(cases_)))
     num_fields = Lazy((lambda : hydra.overlay.python.lib.lists.length(row_type)))
-    return hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.equality.lt(num_cases(), num_fields()))
+    return hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.ordering.lt(num_cases(), num_fields()))
 def encode_term_multiline_t_c_o(cx: hydra.typing.InferenceContext,
 env: hydra.python.environment.PythonEnvironment,
@@ -1610,7 +1611,7 @@ term: hydra.core.Term) -> Either[hydra.errors.Error, Sequence[hydra.python.synta
           body2 := Lazy((lambda : hydra.overlay.python.lib.pairs.second(gathered2.get()))),
           hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(args2.get()), 1),
           (lambda : (
-            arg := Lazy((lambda : hydra.overlay.python.lib.optionals.from_optional((lambda : cast(hydra.core.Term, hydra.core.TermUnit())), hydra.overlay.python.lib.lists.maybe_head(args2.get())))),
+            arg := Lazy((lambda : hydra.overlay.python.lib.optionals.with_default((lambda : cast(hydra.core.Term, hydra.core.TermUnit())), hydra.overlay.python.lib.lists.head(args2.get())))),
             (
               _hoist_arg_body_1 := Lazy((lambda : (lambda v1: (lambda cs: (
                 tname := Lazy((lambda : cs.type_name)),
@@ -1715,7 +1716,7 @@ def is_case_statement_application(term: hydra.core.Term) -> Optional[tuple[hydra
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(args()), 1)),
     (lambda : None_()),
     (lambda : (
-      arg := Lazy((lambda : hydra.overlay.python.lib.optionals.from_optional((lambda : cast(hydra.core.Term, hydra.core.TermUnit())), hydra.overlay.python.lib.lists.maybe_head(args())))),
+      arg := Lazy((lambda : hydra.overlay.python.lib.optionals.with_default((lambda : cast(hydra.core.Term, hydra.core.TermUnit())), hydra.overlay.python.lib.lists.head(args())))),
       (
         _hoist_arg_body_1 := Lazy((lambda : (lambda v1: (lambda cs: Given((cs.type_name, (cs.default, (cs.cases, arg.get())))))(v1.value) if isinstance(v1, hydra.core.TermCases) else None_()))),
         _hoist_arg_body_1.get()(hydra.strip.deannotate_and_detype_term(body())))[1])[1]))
@@ -1741,7 +1742,7 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
               mcs := Lazy((lambda : extract_case_elimination(term1))),
               hydra.overlay.python.lib.optionals.cases(mcs.get(),
               (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_multiline(cx, env, term1),
-              (lambda stmts: hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.maybe_head(stmts),
+              (lambda stmts: hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.head(stmts),
               (lambda : Left(cast(hydra.errors.Error, hydra.errors.ErrorOther(hydra.errors.OtherError("encodeTermMultiline returned no statements"))))),
               (lambda x: Right(x)))))),
               (lambda cs: (
@@ -1777,7 +1778,7 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
               mcs := Lazy((lambda : extract_case_elimination(term1))),
               hydra.overlay.python.lib.optionals.cases(mcs.get(),
               (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_multiline(cx, env, term1),
-              (lambda stmts: hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.maybe_head(stmts),
+              (lambda stmts: hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.head(stmts),
               (lambda : Left(cast(hydra.errors.Error, hydra.errors.ErrorOther(hydra.errors.OtherError("encodeTermMultiline returned no statements"))))),
               (lambda x: Right(x)))))),
               (lambda cs: (
@@ -1822,8 +1823,8 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
                       (lambda rt: (
                         is_enum := Lazy((lambda : hydra.predicates.is_enum_row_type(rt))),
                         is_full := Lazy((lambda : is_cases_full(rt, cases_.get()))),
-                        captured_var_names := Lazy((lambda : hydra.overlay.python.lib.optionals.from_optional((lambda : ConsList.of()), hydra.overlay.python.lib.lists.maybe_init(lambda_params.get())))),
-                        match_lambda_param := Lazy((lambda : hydra.overlay.python.lib.optionals.from_optional((lambda : hydra.core.Name("")), hydra.overlay.python.lib.lists.maybe_last(lambda_params.get())))),
+                        captured_var_names := Lazy((lambda : hydra.overlay.python.lib.optionals.with_default((lambda : ConsList.of()), hydra.overlay.python.lib.lists.init(lambda_params.get())))),
+                        match_lambda_param := Lazy((lambda : hydra.overlay.python.lib.optionals.with_default((lambda : hydra.core.Name("")), hydra.overlay.python.lib.lists.last(lambda_params.get())))),
                         captured_params := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda n: hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, n), None_()),
                         None_())),
                         captured_var_names.get()))),
@@ -1914,7 +1915,7 @@ def encode_term_multiline(cx: hydra.typing.InferenceContext, env: hydra.python.e
     body = Lazy((lambda : hydra.overlay.python.lib.pairs.second(gathered())))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(args()), 1),
     (lambda : (
-      arg := Lazy((lambda : hydra.overlay.python.lib.optionals.from_optional((lambda : cast(hydra.core.Term, hydra.core.TermUnit())), hydra.overlay.python.lib.lists.maybe_head(args())))),
+      arg := Lazy((lambda : hydra.overlay.python.lib.optionals.with_default((lambda : cast(hydra.core.Term, hydra.core.TermUnit())), hydra.overlay.python.lib.lists.head(args())))),
       (
         _hoist_arg_body_1 := Lazy((lambda : (lambda v1: (lambda cs: (
           tname := Lazy((lambda : cs.type_name)),
@@ -2048,7 +2049,7 @@ def record_builder_setter(env: hydra.python.environment.PythonEnvironment, field
     fname = field_type.name
     setter_name = Lazy((lambda : builder_setter_name(env, fname)))
     param_name = hydra.python.syntax.Name(setter_name())
-    storage_name = Lazy((lambda : hydra.overlay.python.lib.strings.cat2("_", hydra.python.names.encode_field_name(env, field_type.name).value)))
+    storage_name = Lazy((lambda : hydra.overlay.python.lib.strings.concat2("_", hydra.python.names.encode_field_name(env, field_type.name).value)))
     kwarg = Lazy((lambda : cast(hydra.python.syntax.KwargOrStarred,
     hydra.python.syntax.KwargOrStarredKwarg(hydra.python.syntax.Kwarg(hydra.python.syntax.Name(storage_name()), hydra.python.utils.py_name_to_py_expression(param_name))))))
     return cast(hydra.python.syntax.Statement,
@@ -2080,7 +2081,7 @@ record_args: Optional[hydra.python.syntax.Args]) -> Either[T0, Sequence[hydra.py
     return hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map_list((lambda ft: hydra.overlay.python.lib.eithers.map((lambda py_type: hydra.python.utils.py_assignment_to_py_statement(cast(hydra.python.syntax.Assignment,
     hydra.python.syntax.AssignmentTyped(hydra.python.syntax.TypedAssignment(cast(hydra.python.syntax.SingleTarget,
-    hydra.python.syntax.SingleTargetName(hydra.python.syntax.Name(hydra.overlay.python.lib.strings.cat2("_", hydra.python.names.encode_field_name(env, ft.name).value)))),
+    hydra.python.syntax.SingleTargetName(hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("_", hydra.python.names.encode_field_name(env, ft.name).value)))),
     py_type,
     Given(cast(hydra.python.syntax.AnnotatedRhs,
     hydra.python.syntax.AnnotatedRhsStar(ConsList.of(cast(hydra.python.syntax.StarExpression,
@@ -2093,7 +2094,7 @@ record_args: Optional[hydra.python.syntax.Args]) -> Either[T0, Sequence[hydra.py
       build_kwargs := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda ft: cast(hydra.python.syntax.KwargOrStarred,
       hydra.python.syntax.KwargOrStarredKwarg(hydra.python.syntax.Kwarg(hydra.python.syntax.Name(hydra.python.names.encode_field_name(env, ft.name).value),
       hydra.python.utils.project_from_expression(hydra.python.utils.py_name_to_py_expression(hydra.python.syntax.Name("self")),
-      hydra.python.syntax.Name(hydra.overlay.python.lib.strings.cat2("_", hydra.python.names.encode_field_name(env, ft.name).value))))))),
+      hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("_", hydra.python.names.encode_field_name(env, ft.name).value))))))),
       row_type))),
       ctor_call := Lazy((lambda : hydra.python.utils.py_primary_to_py_expression(hydra.python.utils.primary_with_rhs(hydra.python.utils.py_name_to_py_primary(py_name.get()),
       cast(hydra.python.syntax.PrimaryRhs,
@@ -2115,7 +2116,7 @@ record_args: Optional[hydra.python.syntax.Args]) -> Either[T0, Sequence[hydra.py
       ConsList.of(hydra.overlay.python.lib.lists.concat(ConsList.of(builder_fields, setters.get(), ConsList.of(build_method.get()))))))),
       builder_decs := Lazy((lambda : Given(hydra.python.syntax.Decorators(ConsList.of(dataclass_decorator()))))),
       builder_class := Lazy((lambda : hydra.python.utils.py_class_definition_to_py_statement(hydra.python.syntax.ClassDefinition(builder_decs.get(), hydra.python.syntax.Name("Builder"), ConsList.of(), record_args, builder_body.get())))),
-      qualified_builder_name := Lazy((lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.strings.cat2(py_name.get().value, ".Builder")))),
+      qualified_builder_name := Lazy((lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2(py_name.get().value, ".Builder")))),
       builder_call := Lazy((lambda : hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(qualified_builder_name.get()), ConsList.of()))),
       factory_method := Lazy((lambda : cast(hydra.python.syntax.Statement,
       hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement,
@@ -2136,7 +2137,7 @@ def record_with_method(env: hydra.python.environment.PythonEnvironment, field_ty
     fname = field_type.name
     snake = Lazy((lambda : hydra.python.names.encode_field_name(env, fname).value))
-    method_name = Lazy((lambda : hydra.overlay.python.lib.strings.cat2("with_", snake())))
+    method_name = Lazy((lambda : hydra.overlay.python.lib.strings.concat2("with_", snake())))
     kwarg_key = hydra.python.syntax.Name(snake())
     param_snake = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(snake(), "self"), (lambda : "_self"), (lambda : snake()))))
     param_name = hydra.python.syntax.Name(param_snake())
@@ -2248,7 +2249,7 @@ def find_type_params(env: hydra.python.environment.PythonEnvironment, typ: hydra
 def variant_args(ptype: hydra.python.syntax.Expression, tparams: Sequence[hydra.core.Name]) -> hydra.python.syntax.Args:
     r"""Create args for variant (Node[type], Generic[tparams])."""
-    return hydra.python.utils.py_expressions_to_py_args(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(hydra.python.utils.py_primary_to_py_expression(hydra.python.utils.primary_with_expression_slices(cast(hydra.python.syntax.Primary,
+    return hydra.python.utils.py_expressions_to_py_args(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(hydra.python.utils.py_primary_to_py_expression(hydra.python.utils.primary_with_expression_slices(cast(hydra.python.syntax.Primary,
     hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("Node"))))),
     ConsList.of(ptype)))),
     generic_arg(tparams))))
@@ -3180,9 +3181,9 @@ def module_standard_imports(meta: hydra.python.environment.PythonModuleMetadata)
       cond_import_symbol("TypeAlias", meta.uses_type_alias),
       cond_import_symbol("TypeVar", meta.uses_type_var),
       cond_import_symbol("cast", meta.uses_cast))))))
-    simplified = Lazy((lambda : hydra.overlay.python.lib.optionals.cat(hydra.overlay.python.lib.lists.map((lambda p: (
+    simplified = Lazy((lambda : hydra.overlay.python.lib.optionals.givens(hydra.overlay.python.lib.lists.map((lambda p: (
       mod_name := Lazy((lambda : hydra.overlay.python.lib.pairs.first(p))),
-      symbols := Lazy((lambda : hydra.overlay.python.lib.optionals.cat(hydra.overlay.python.lib.pairs.second(p)))),
+      symbols := Lazy((lambda : hydra.overlay.python.lib.optionals.givens(hydra.overlay.python.lib.pairs.second(p)))),
       hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(symbols.get()), (lambda : None_()), (lambda : Given((mod_name.get(), symbols.get())))))[2]),
     pairs()))))
     return hydra.overlay.python.lib.lists.map((lambda p: standard_import_statement(hydra.overlay.python.lib.pairs.first(p), hydra.overlay.python.lib.pairs.second(p))), simplified())
@@ -3245,7 +3246,7 @@ body: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
     bindings = Lazy((lambda : (
       _hoist_bindings_1 := Lazy((lambda : (lambda v1: (lambda td: Given(hydra.core.Binding(td.name, td.body, hydra.overlay.python.lib.optionals.map((lambda sig: hydra.scoping.term_signature_to_type_scheme(sig)), td.signature))))(v1.value) if isinstance(v1, hydra.packaging.DefinitionTerm) else (lambda _: None_())(v1.value) if isinstance(v1, hydra.packaging.DefinitionType) else None_()))),
-      hydra.overlay.python.lib.optionals.cat(hydra.overlay.python.lib.lists.map((lambda def_: _hoist_bindings_1.get()(def_)), defs)))[1]))
+      hydra.overlay.python.lib.optionals.givens(hydra.overlay.python.lib.lists.map((lambda def_: _hoist_bindings_1.get()(def_)), defs)))[1]))
     dummy_let = Lazy((lambda : hydra.core.Let(bindings(), cast(hydra.core.Term, hydra.core.TermLiteral(cast(hydra.core.Literal, hydra.core.LiteralString("dummy")))))))
     return with_let(env, dummy_let(), body)

{hydra_python-0.17.1 → hydra_python-0.17.3}/src/main/python/hydra/python/names.py RENAMED Viewed

@@ -33,7 +33,7 @@ def encode_constant_for_field_name(env: T0, tname: T1, fname: hydra.core.Name) -
     return hydra.python.syntax.Name(hydra.formatting.convert_case(hydra.util.CaseConvention.CAMEL,
     hydra.util.CaseConvention.UPPER_SNAKE,
-    hydra.overlay.python.lib.strings.intercalate("_", hydra.overlay.python.lib.strings.split_on("-", fname.value))))
+    hydra.overlay.python.lib.strings.join("_", hydra.overlay.python.lib.strings.split_on("-", fname.value))))
 def encode_constant_for_type_name(env: T0, tname: T1) -> hydra.python.syntax.Name:
     r"""Generate a constant name for a type definition."""
@@ -49,7 +49,7 @@ def overlay_python_module_aliases() -> Mapping[hydra.packaging.ModuleName, str]:
 def encode_namespace_string_with_overrides(ns_val: hydra.packaging.ModuleName) -> str:
     r"""Convert a ModuleName to its Python dotted import string, routing overlay modules to hydra.overlay.python.*."""
-    return hydra.overlay.python.lib.optionals.from_optional((lambda : hydra.overlay.python.lib.strings.intercalate(".",
+    return hydra.overlay.python.lib.optionals.with_default((lambda : hydra.overlay.python.lib.strings.join(".",
     hydra.overlay.python.lib.lists.map((lambda v1: hydra.formatting.convert_case(hydra.util.CaseConvention.CAMEL, hydra.util.CaseConvention.LOWER_SNAKE, v1)),
     hydra.overlay.python.lib.strings.split_on(".", ns_val.value)))),
     hydra.overlay.python.lib.maps.lookup(ns_val, overlay_python_module_aliases()))
@@ -84,7 +84,7 @@ name: hydra.core.Name) -> hydra.python.syntax.Name:
     (lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.logic.if_else(use_future_annotations, (lambda : py_local()), (lambda : hydra.python.serde.escape_python_string(True, py_local()))))),
     (lambda : hydra.overlay.python.lib.optionals.cases(mns,
     (lambda : hydra.python.syntax.Name(py_local())),
-    (lambda ns_val: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.cat2(py_ns(ns_val), hydra.overlay.python.lib.strings.cat2(".", py_local())))))))),
+    (lambda ns_val: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2(py_ns(ns_val), hydra.overlay.python.lib.strings.concat2(".", py_local())))))))),
     (lambda n: n))),
     (lambda : hydra.python.syntax.Name(py_local())))
@@ -115,7 +115,7 @@ def encode_name_qualified(env: hydra.python.environment.PythonEnvironment, name:
     (lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.logic.if_else(use_future_annotations, (lambda : local), (lambda : hydra.python.serde.escape_python_string(True, local))))),
     (lambda : hydra.overlay.python.lib.optionals.cases(mns,
     (lambda : hydra.python.syntax.Name(sanitize_python_name(local))),
-    (lambda ns_val: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.cat2(py_ns(ns_val), hydra.overlay.python.lib.strings.cat2(".", sanitize_python_name(local))))))))),
+    (lambda ns_val: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2(py_ns(ns_val), hydra.overlay.python.lib.strings.concat2(".", sanitize_python_name(local))))))))),
     (lambda n: n))
 def encode_namespace(ns_val: hydra.packaging.ModuleName) -> hydra.python.syntax.DottedName:
@@ -192,4 +192,4 @@ def variant_name(is_qualified: bool, env: hydra.python.environment.PythonEnviron
     return encode_name(is_qualified,
     hydra.util.CaseConvention.PASCAL,
     env,
-    hydra.core.Name(hydra.overlay.python.lib.strings.cat2(tname.value, hydra.formatting.capitalize(fname.value))))
+    hydra.core.Name(hydra.overlay.python.lib.strings.concat2(tname.value, hydra.formatting.capitalize(fname.value))))

{hydra_python-0.17.1 → hydra_python-0.17.3}/src/main/python/hydra/python/serde.py RENAMED Viewed

@@ -18,9 +18,9 @@ import hydra.overlay.python.lib.optionals
 import hydra.overlay.python.lib.strings
 import hydra.names
 import hydra.packaging
+import hydra.print.docs
 import hydra.python.syntax
 import hydra.serialization
-import hydra.show.docs
 def compare_op_to_string(op: hydra.python.syntax.CompareOp) -> str:
     r"""Render a Python comparison operator to its source-code form."""
@@ -90,7 +90,7 @@ def number_to_expr(num: hydra.python.syntax.Number) -> hydra.ast.Expr:
             return hydra.serialization.cst(python_float_literal_text(hydra.overlay.python.lib.literals.show_float64(f)))
         case hydra.python.syntax.NumberImaginary(value=f2):
-            return hydra.serialization.cst(hydra.overlay.python.lib.strings.cat2(python_float_literal_text(hydra.overlay.python.lib.literals.show_float64(f2)), "j"))
+            return hydra.serialization.cst(hydra.overlay.python.lib.strings.concat2(python_float_literal_text(hydra.overlay.python.lib.literals.show_float64(f2)), "j"))
         case hydra.python.syntax.NumberInteger(value=i):
             return hydra.serialization.cst(hydra.overlay.python.lib.literals.show_bigint(i))
@@ -102,7 +102,7 @@ def escape_python_string(double_quoted: bool, s: str) -> str:
     r"""Escape special characters in a Python string and wrap in quotes."""
     def replace(old: str, new: str, str: str) -> str:
-        return hydra.overlay.python.lib.strings.intercalate(new, hydra.overlay.python.lib.strings.split_on(old, str))
+        return hydra.overlay.python.lib.strings.join(new, hydra.overlay.python.lib.strings.split_on(old, str))
     s1 = Lazy((lambda : replace("\\", "\\\\", s)))
     s2 = Lazy((lambda : replace("\x00", "\\x00", s1())))
     s3 = Lazy((lambda : replace("\n", "\\n", s2())))
@@ -110,7 +110,7 @@ def escape_python_string(double_quoted: bool, s: str) -> str:
     s5 = Lazy((lambda : replace("\r", "\\r", s4())))
     escaped = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(double_quoted, (lambda : replace("\"", "\\\"", s5())), (lambda : replace("'", "\\'", s5())))))
     quote = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(double_quoted, (lambda : "\""), (lambda : "'"))))
-    return hydra.overlay.python.lib.strings.cat2(quote(), hydra.overlay.python.lib.strings.cat2(escaped(), quote()))
+    return hydra.overlay.python.lib.strings.concat2(quote(), hydra.overlay.python.lib.strings.concat2(escaped(), quote()))
 def string_prefix_to_text(p: hydra.python.syntax.StringPrefix) -> str:
     r"""Serialize a Python string prefix to its source-form characters."""
@@ -139,18 +139,18 @@ def string_to_expr(s: hydra.python.syntax.String) -> hydra.ast.Expr:
     style = s.quote_style
     match style:
         case hydra.python.syntax.QuoteStyle.SINGLE:
-            return hydra.serialization.cst(hydra.overlay.python.lib.strings.cat2(prefix(), escape_python_string(False, content)))
+            return hydra.serialization.cst(hydra.overlay.python.lib.strings.concat2(prefix(), escape_python_string(False, content)))
         case hydra.python.syntax.QuoteStyle.DOUBLE:
-            return hydra.serialization.cst(hydra.overlay.python.lib.strings.cat2(prefix(), escape_python_string(True, content)))
+            return hydra.serialization.cst(hydra.overlay.python.lib.strings.concat2(prefix(), escape_python_string(True, content)))
         case hydra.python.syntax.QuoteStyle.TRIPLE_SINGLE:
-            return hydra.serialization.no_sep(ConsList.of(hydra.serialization.cst(hydra.overlay.python.lib.strings.cat2(prefix(), "'''")),
+            return hydra.serialization.no_sep(ConsList.of(hydra.serialization.cst(hydra.overlay.python.lib.strings.concat2(prefix(), "'''")),
             hydra.serialization.cst(content),
             hydra.serialization.cst("'''")))
         case hydra.python.syntax.QuoteStyle.TRIPLE_DOUBLE:
-            return hydra.serialization.no_sep(ConsList.of(hydra.serialization.cst(hydra.overlay.python.lib.strings.cat2(prefix(), "\"\"\"")),
+            return hydra.serialization.no_sep(ConsList.of(hydra.serialization.cst(hydra.overlay.python.lib.strings.concat2(prefix(), "\"\"\"")),
             hydra.serialization.cst(content),
             hydra.serialization.cst("\"\"\"")))
@@ -243,7 +243,7 @@ def bitwise_and_to_expr(band: hydra.python.syntax.BitwiseAnd) -> hydra.ast.Expr:
     lhs = band.lhs
     rhs = band.rhs
-    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda l: hydra.serialization.space_sep(ConsList.of(bitwise_and_to_expr(l), hydra.serialization.cst("&")))), lhs),
+    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda l: hydra.serialization.space_sep(ConsList.of(bitwise_and_to_expr(l), hydra.serialization.cst("&")))), lhs),
     Given(shift_expression_to_expr(rhs)))))
 def bitwise_or_to_expr(bor: hydra.python.syntax.BitwiseOr) -> hydra.ast.Expr:
@@ -251,7 +251,7 @@ def bitwise_or_to_expr(bor: hydra.python.syntax.BitwiseOr) -> hydra.ast.Expr:
     lhs = bor.lhs
     rhs = bor.rhs
-    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda l: hydra.serialization.space_sep(ConsList.of(bitwise_or_to_expr(l), hydra.serialization.cst("|")))), lhs),
+    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda l: hydra.serialization.space_sep(ConsList.of(bitwise_or_to_expr(l), hydra.serialization.cst("|")))), lhs),
     Given(bitwise_xor_to_expr(rhs)))))
 def bitwise_xor_to_expr(bxor: hydra.python.syntax.BitwiseXor) -> hydra.ast.Expr:
@@ -259,7 +259,7 @@ def bitwise_xor_to_expr(bxor: hydra.python.syntax.BitwiseXor) -> hydra.ast.Expr:
     lhs = bxor.lhs
     rhs = bxor.rhs
-    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda l: hydra.serialization.space_sep(ConsList.of(bitwise_xor_to_expr(l), hydra.serialization.cst("^")))), lhs),
+    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda l: hydra.serialization.space_sep(ConsList.of(bitwise_xor_to_expr(l), hydra.serialization.cst("^")))), lhs),
     Given(bitwise_and_to_expr(rhs)))))
 def compare_op_bitwise_or_pair_to_expr(pair: hydra.python.syntax.CompareOpBitwiseOrPair) -> hydra.ast.Expr:
@@ -467,7 +467,7 @@ def power_to_expr(p: hydra.python.syntax.Power) -> hydra.ast.Expr:
     lhs = p.lhs
     rhs = p.rhs
-    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(await_primary_to_expr(lhs)),
+    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(await_primary_to_expr(lhs)),
     hydra.overlay.python.lib.optionals.map((lambda r: hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("**"), factor_to_expr(r)))), rhs))))
 def primary_rhs_to_expr(rhs: hydra.python.syntax.PrimaryRhs) -> hydra.ast.Expr:
@@ -585,11 +585,11 @@ def tuple_to_expr(t: hydra.python.syntax.Tuple) -> hydra.ast.Expr:
     r"""Serialize a Python tuple."""
     es = t.value
-    return hydra.overlay.python.lib.optionals.from_optional((lambda : hydra.serialization.paren_list_adaptive(hydra.overlay.python.lib.lists.map((lambda x1: star_named_expression_to_expr(x1)), es))),
+    return hydra.overlay.python.lib.optionals.with_default((lambda : hydra.serialization.paren_list_adaptive(hydra.overlay.python.lib.lists.map((lambda x1: star_named_expression_to_expr(x1)), es))),
     hydra.overlay.python.lib.optionals.map((lambda first_es: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(es), 1),
     (lambda : hydra.serialization.parens(hydra.serialization.no_sep(ConsList.of(star_named_expression_to_expr(first_es), hydra.serialization.cst(","))))),
     (lambda : hydra.serialization.paren_list_adaptive(hydra.overlay.python.lib.lists.map((lambda x1: star_named_expression_to_expr(x1)), es))))),
-    hydra.overlay.python.lib.lists.maybe_head(es)))
+    hydra.overlay.python.lib.lists.head(es)))
 def star_expression_to_expr(se: hydra.python.syntax.StarExpression) -> hydra.ast.Expr:
     r"""Serialize a star expression."""
@@ -641,7 +641,7 @@ def typed_assignment_to_expr(ta: hydra.python.syntax.TypedAssignment) -> hydra.a
     lhs = ta.lhs
     typ = ta.type
     rhs = ta.rhs
-    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(hydra.serialization.no_sep(ConsList.of(single_target_to_expr(lhs), hydra.serialization.cst(":")))),
+    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(hydra.serialization.no_sep(ConsList.of(single_target_to_expr(lhs), hydra.serialization.cst(":")))),
     Given(expression_to_expr(typ)),
     hydra.overlay.python.lib.optionals.map((lambda x1: annotated_rhs_to_expr(x1)), rhs))))
@@ -748,7 +748,7 @@ def assignment_to_expr(a: hydra.python.syntax.Assignment) -> hydra.ast.Expr:
 def dotted_name_to_expr(dn: hydra.python.syntax.DottedName) -> hydra.ast.Expr:
     r"""Serialize a dotted name (e.g., module.submodule)."""
-    return hydra.serialization.cst(hydra.overlay.python.lib.strings.intercalate(".", hydra.overlay.python.lib.lists.map((lambda n: n.value), dn.value)))
+    return hydra.serialization.cst(hydra.overlay.python.lib.strings.join(".", hydra.overlay.python.lib.lists.map((lambda n: n.value), dn.value)))
 def import_from_as_name_to_expr(ifan: hydra.python.syntax.ImportFromAsName) -> hydra.ast.Expr:
     r"""Serialize an import from as name."""
@@ -796,7 +796,7 @@ def import_from_to_expr(if_: hydra.python.syntax.ImportFrom) -> hydra.ast.Expr:
     prefixes = if_.prefixes
     name = if_.dotted_name
     targets = if_.targets
-    lhs = Lazy((lambda : hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.cat(hydra.overlay.python.lib.lists.concat(ConsList.of(hydra.overlay.python.lib.lists.map((lambda p: Given(relative_import_prefix_to_expr(p))), prefixes),
+    lhs = Lazy((lambda : hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.givens(hydra.overlay.python.lib.lists.concat(ConsList.of(hydra.overlay.python.lib.lists.map((lambda p: Given(relative_import_prefix_to_expr(p))), prefixes),
     ConsList.of(hydra.overlay.python.lib.optionals.map((lambda x1: dotted_name_to_expr(x1)), name))))))))
     return hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("from"), lhs(), hydra.serialization.cst("import"), import_from_targets_to_expr(targets)))
@@ -805,7 +805,7 @@ def dotted_as_name_to_expr(dan: hydra.python.syntax.DottedAsName) -> hydra.ast.E
     name = dan.name
     alias = dan.as_
-    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(dotted_name_to_expr(name)),
+    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(dotted_name_to_expr(name)),
     hydra.overlay.python.lib.optionals.map((lambda a: hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("as"), name_to_expr(a)))), alias))))
 def import_name_to_expr(in_: hydra.python.syntax.ImportName) -> hydra.ast.Expr:
@@ -832,13 +832,13 @@ def raise_expression_to_expr(re: hydra.python.syntax.RaiseExpression) -> hydra.a
     expr = re.expression
     from_ = re.from_
-    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(expression_to_expr(expr)),
+    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(expression_to_expr(expr)),
     hydra.overlay.python.lib.optionals.map((lambda f: hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("from"), expression_to_expr(f)))), from_))))
 def raise_statement_to_expr(rs: hydra.python.syntax.RaiseStatement) -> hydra.ast.Expr:
     r"""Serialize a raise statement."""
-    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(hydra.serialization.cst("raise")), hydra.overlay.python.lib.optionals.map((lambda x1: raise_expression_to_expr(x1)), rs.value))))
+    return hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(hydra.serialization.cst("raise")), hydra.overlay.python.lib.optionals.map((lambda x1: raise_expression_to_expr(x1)), rs.value))))
 def return_statement_to_expr(rs: hydra.python.syntax.ReturnStatement) -> hydra.ast.Expr:
     r"""Serialize a return statement."""
@@ -873,7 +873,7 @@ def type_alias_to_expr(ta: hydra.python.syntax.TypeAlias) -> hydra.ast.Expr:
     name = ta.name
     tparams = ta.type_params
     expr = ta.expression
-    alias = Lazy((lambda : hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(name_to_expr(name)),
+    alias = Lazy((lambda : hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(name_to_expr(name)),
     hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(tparams),
     (lambda : None_()),
     (lambda : Given(hydra.serialization.bracket_list(hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: type_parameter_to_expr(x1)), tparams))))))))))
@@ -941,7 +941,7 @@ def param_to_expr(p: hydra.python.syntax.Param) -> hydra.ast.Expr:
     name = p.name
     ann = p.annotation
-    return hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(name_to_expr(name)), hydra.overlay.python.lib.optionals.map((lambda x1: annotation_to_expr(x1)), ann))))
+    return hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(name_to_expr(name)), hydra.overlay.python.lib.optionals.map((lambda x1: annotation_to_expr(x1)), ann))))
 def param_no_default_to_expr(pnd: hydra.python.syntax.ParamNoDefault) -> hydra.ast.Expr:
     r"""Serialize a parameter without default."""
@@ -1006,7 +1006,7 @@ def class_pattern_to_expr(cp: hydra.python.syntax.ClassPattern) -> hydra.ast.Exp
     noa = cp.name_or_attribute
     pos = cp.positional_patterns
     kw = cp.keyword_patterns
-    return hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(name_or_attribute_to_expr(noa)),
+    return hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(name_or_attribute_to_expr(noa)),
     Given(hydra.serialization.cst("(")),
     hydra.overlay.python.lib.optionals.map((lambda x1: positional_patterns_to_expr(x1)), pos),
     hydra.overlay.python.lib.optionals.map((lambda x1: keyword_patterns_to_expr(x1)), kw),
@@ -1110,13 +1110,13 @@ def python_doc_entity_ref(ref: hydra.packaging.EntityReference) -> str:
     def _hoist_hydra_python_serde_python_doc_entity_ref_1(v1):
         match v1:
             case hydra.packaging.DefinitionReferencePrimitive(value=n):
-                return hydra.overlay.python.lib.strings.cat2(":func:`", hydra.overlay.python.lib.strings.cat2(hydra.names.local_name_of(n), "`"))
+                return hydra.overlay.python.lib.strings.concat2(":func:`", hydra.overlay.python.lib.strings.concat2(hydra.names.local_name_of(n), "`"))
             case hydra.packaging.DefinitionReferenceTerm(value=n):
-                return hydra.overlay.python.lib.strings.cat2(":func:`", hydra.overlay.python.lib.strings.cat2(hydra.names.local_name_of(n), "`"))
+                return hydra.overlay.python.lib.strings.concat2(":func:`", hydra.overlay.python.lib.strings.concat2(hydra.names.local_name_of(n), "`"))
             case hydra.packaging.DefinitionReferenceType(value=n):
-                return hydra.overlay.python.lib.strings.cat2(":class:`", hydra.overlay.python.lib.strings.cat2(hydra.names.local_name_of(n), "`"))
+                return hydra.overlay.python.lib.strings.concat2(":class:`", hydra.overlay.python.lib.strings.concat2(hydra.names.local_name_of(n), "`"))
             case _:
                 raise AssertionError("Unreachable: all variants handled")
@@ -1125,16 +1125,16 @@ def python_doc_entity_ref(ref: hydra.packaging.EntityReference) -> str:
             return _hoist_hydra_python_serde_python_doc_entity_ref_1(d)
         case hydra.packaging.EntityReferenceModule(value=m):
-            return hydra.overlay.python.lib.strings.cat2("", m.value)
+            return hydra.overlay.python.lib.strings.concat2("", m.value)
         case hydra.packaging.EntityReferencePackage(value=p):
-            return hydra.overlay.python.lib.strings.cat2("", p.value)
+            return hydra.overlay.python.lib.strings.concat2("", p.value)
         case hydra.packaging.EntityReferenceTermExpr(value=s):
-            return hydra.overlay.python.lib.strings.cat2("``", hydra.overlay.python.lib.strings.cat2(s, "``"))
+            return hydra.overlay.python.lib.strings.concat2("``", hydra.overlay.python.lib.strings.concat2(s, "``"))
         case hydra.packaging.EntityReferenceTypeExpr(value=s2):
-            return hydra.overlay.python.lib.strings.cat2("``", hydra.overlay.python.lib.strings.cat2(s2, "``"))
+            return hydra.overlay.python.lib.strings.concat2("``", hydra.overlay.python.lib.strings.concat2(s2, "``"))
         case _:
             raise AssertionError("Unreachable: all variants handled")
@@ -1144,9 +1144,9 @@ def to_python_comments(doc_: str) -> str:
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(doc_, ""),
     (lambda : ""),
-    (lambda : hydra.overlay.python.lib.strings.intercalate("\n",
-    hydra.overlay.python.lib.lists.map((lambda line: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(line, ""), (lambda : "#"), (lambda : hydra.overlay.python.lib.strings.cat2("# ", line)))),
-    hydra.overlay.python.lib.strings.lines(hydra.show.docs.render_doc_string_with((lambda x1: python_doc_entity_ref(x1)), doc_))))))
+    (lambda : hydra.overlay.python.lib.strings.join("\n",
+    hydra.overlay.python.lib.lists.map((lambda line: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(line, ""), (lambda : "#"), (lambda : hydra.overlay.python.lib.strings.concat2("# ", line)))),
+    hydra.overlay.python.lib.strings.lines(hydra.print.docs.render_doc_string_with((lambda x1: python_doc_entity_ref(x1)), doc_))))))
 def annotated_statement_to_expr(as_: hydra.python.syntax.AnnotatedStatement) -> hydra.ast.Expr:
     r"""Serialize an annotated statement (with optional doc comment)."""
@@ -1174,7 +1174,7 @@ def case_block_to_expr(cb: hydra.python.syntax.CaseBlock) -> hydra.ast.Expr:
     patterns = cb.patterns
     guard = cb.guard
     body = cb.body
-    return hydra.serialization.newline_sep(ConsList.of(hydra.serialization.no_sep(ConsList.of(hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(hydra.serialization.cst("case")),
+    return hydra.serialization.newline_sep(ConsList.of(hydra.serialization.no_sep(ConsList.of(hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(hydra.serialization.cst("case")),
     Given(patterns_to_expr(patterns)),
     hydra.overlay.python.lib.optionals.map((lambda x1: guard_to_expr(x1)), guard)))),
     hydra.serialization.cst(":"))),
@@ -1189,8 +1189,8 @@ def class_definition_to_expr(cd: hydra.python.syntax.ClassDefinition) -> hydra.a
     body = cd.body
     arg_part = Lazy((lambda : hydra.overlay.python.lib.optionals.map((lambda a: hydra.serialization.no_sep(ConsList.of(hydra.serialization.cst("("), args_to_expr(a), hydra.serialization.cst(")")))),
     args)))
-    return hydra.serialization.newline_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda x1: decorators_to_expr(x1)), decs),
-    Given(hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("class"), name_to_expr(name)))),
+    return hydra.serialization.newline_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda x1: decorators_to_expr(x1)), decs),
+    Given(hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("class"), name_to_expr(name)))),
     arg_part(),
     Given(hydra.serialization.cst(":")))))),
     Given(block_to_expr(body)))))
@@ -1241,9 +1241,9 @@ def function_def_raw_to_expr(fdr: hydra.python.syntax.FunctionDefRaw) -> hydra.a
     (lambda : Given(hydra.serialization.bracket_list(hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: type_parameter_to_expr(x1)), tparams)))))))
     param_part = Lazy((lambda : hydra.overlay.python.lib.optionals.map((lambda x1: parameters_to_expr(x1)), params)))
     ret_part = Lazy((lambda : hydra.overlay.python.lib.optionals.map((lambda t: hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("->"), expression_to_expr(t)))), ret_type)))
-    return hydra.serialization.newline_sep(ConsList.of(hydra.serialization.no_sep(ConsList.of(hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(async_kw(),
+    return hydra.serialization.newline_sep(ConsList.of(hydra.serialization.no_sep(ConsList.of(hydra.serialization.space_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(async_kw(),
     Given(hydra.serialization.cst("def")),
-    Given(hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(name_to_expr(name)),
+    Given(hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(name_to_expr(name)),
     tparam_part(),
     Given(hydra.serialization.cst("(")),
     param_part(),
@@ -1257,7 +1257,7 @@ def function_definition_to_expr(fd: hydra.python.syntax.FunctionDefinition) -> h
     decs = fd.decorators
     raw = fd.raw
-    return hydra.serialization.newline_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda x1: decorators_to_expr(x1)), decs), Given(function_def_raw_to_expr(raw)))))
+    return hydra.serialization.newline_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(hydra.overlay.python.lib.optionals.map((lambda x1: decorators_to_expr(x1)), decs), Given(function_def_raw_to_expr(raw)))))
 def match_statement_to_expr(ms: hydra.python.syntax.MatchStatement) -> hydra.ast.Expr:
     r"""Serialize a match statement."""
@@ -1290,7 +1290,7 @@ def while_statement_to_expr(ws: hydra.python.syntax.WhileStatement) -> hydra.ast
     cond = ws.condition
     body = ws.body
     else_ = ws.else_
-    return hydra.serialization.newline_sep(hydra.overlay.python.lib.optionals.cat(ConsList.of(Given(hydra.serialization.newline_sep(ConsList.of(hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("while"),
+    return hydra.serialization.newline_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(hydra.serialization.newline_sep(ConsList.of(hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("while"),
     hydra.serialization.no_sep(ConsList.of(named_expression_to_expr(cond), hydra.serialization.cst(":"))))),
     block_to_expr(body)))),
     hydra.overlay.python.lib.optionals.map((lambda eb: hydra.serialization.newline_sep(ConsList.of(hydra.serialization.cst("else:"), block_to_expr(eb)))), else_))))

{hydra_python-0.17.1 → hydra_python-0.17.3}/src/main/python/hydra/python/testing.py RENAMED Viewed

@@ -27,16 +27,16 @@ def build_python_test_module(test_module: T0, test_group: hydra.testing.TestGrou
     r"""Build the complete Python test module content."""
     group_name_ = test_group.name
-    header = Lazy((lambda : hydra.overlay.python.lib.strings.cat(ConsList.of(hydra.overlay.python.lib.strings.cat2("# ", hydra.constants.warning_auto_generated_file),
+    header = Lazy((lambda : hydra.overlay.python.lib.strings.concat(ConsList.of(hydra.overlay.python.lib.strings.concat2("# ", hydra.constants.warning_auto_generated_file),
     "\n",
-    hydra.overlay.python.lib.strings.cat2("# ", group_name_),
+    hydra.overlay.python.lib.strings.concat2("# ", group_name_),
     "\n\n"))))
-    return hydra.overlay.python.lib.strings.cat(ConsList.of(header(), test_body, "\n"))
+    return hydra.overlay.python.lib.strings.concat(ConsList.of(header(), test_body, "\n"))
 def format_python_test_name(name: str) -> str:
     r"""Format a test name for Python (snake_case with test_ prefix)."""
-    return hydra.overlay.python.lib.strings.cat2("test_",
+    return hydra.overlay.python.lib.strings.concat2("test_",
     hydra.overlay.python.lib.strings.from_list(hydra.overlay.python.lib.lists.map((lambda c: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.chars.is_alpha_num(c), (lambda : hydra.overlay.python.lib.chars.to_lower(c)), (lambda : 95))),
     hydra.overlay.python.lib.strings.to_list(name))))
@@ -51,10 +51,10 @@ def generate_python_test_case(group_path: Sequence[str], tcm: hydra.testing.Test
             expected_ = Lazy((lambda : ucase.expected(None)))
             full_name = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(group_path),
             (lambda : name_),
-            (lambda : hydra.overlay.python.lib.strings.intercalate("__", hydra.overlay.python.lib.lists.concat2(group_path, ConsList.of(name_)))))))
+            (lambda : hydra.overlay.python.lib.strings.join("__", hydra.overlay.python.lib.lists.concat2(group_path, ConsList.of(name_)))))))
             formatted_name = Lazy((lambda : format_python_test_name(full_name())))
-            return Right(ConsList.of(hydra.overlay.python.lib.strings.cat(ConsList.of("def ", formatted_name(), "():")),
-            hydra.overlay.python.lib.strings.cat(ConsList.of("    assert (", actual_(), ") == (", expected_(), ")"))))
+            return Right(ConsList.of(hydra.overlay.python.lib.strings.concat(ConsList.of("def ", formatted_name(), "():")),
+            hydra.overlay.python.lib.strings.concat(ConsList.of("    assert (", actual_(), ") == (", expected_(), ")"))))
         case _:
             raise TypeError("Unsupported TestCase")
@@ -67,14 +67,14 @@ def generate_python_test_group_hierarchy(group_path: Sequence[str], test_group:
     return hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map_list((lambda tc: generate_python_test_case(group_path, tc)), cases_),
     (lambda test_case_lines: hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map_list((lambda subgroup: (
       group_name := Lazy((lambda : subgroup.name)),
-      header := Lazy((lambda : hydra.overlay.python.lib.strings.cat2("# ", group_name.get()))),
-      hydra.overlay.python.lib.eithers.map((lambda content: hydra.overlay.python.lib.strings.cat(ConsList.of(header.get(), "\n\n", content))),
+      header := Lazy((lambda : hydra.overlay.python.lib.strings.concat2("# ", group_name.get()))),
+      hydra.overlay.python.lib.eithers.map((lambda content: hydra.overlay.python.lib.strings.concat(ConsList.of(header.get(), "\n\n", content))),
       generate_python_test_group_hierarchy(hydra.overlay.python.lib.lists.concat2(group_path, ConsList.of(group_name.get())), subgroup)))[2]),
     subgroups),
     (lambda subgroup_blocks: (
-      test_cases_str := Lazy((lambda : hydra.overlay.python.lib.strings.intercalate("\n\n", hydra.overlay.python.lib.lists.concat(test_case_lines)))),
-      subgroups_str := Lazy((lambda : hydra.overlay.python.lib.strings.intercalate("\n\n", subgroup_blocks))),
-      Right(hydra.overlay.python.lib.strings.cat(ConsList.of(test_cases_str.get(),
+      test_cases_str := Lazy((lambda : hydra.overlay.python.lib.strings.join("\n\n", hydra.overlay.python.lib.lists.concat(test_case_lines)))),
+      subgroups_str := Lazy((lambda : hydra.overlay.python.lib.strings.join("\n\n", subgroup_blocks))),
+      Right(hydra.overlay.python.lib.strings.concat(ConsList.of(test_cases_str.get(),
       hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.or_(hydra.overlay.python.lib.equality.equal(test_cases_str.get(), ""), hydra.overlay.python.lib.equality.equal(subgroups_str.get(), "")),
       (lambda : ""),
       (lambda : "\n\n")),
@@ -87,9 +87,9 @@ def generate_test_file_with_python_codec(test_module: hydra.packaging.Module, te
       test_module_content := Lazy((lambda : build_python_test_module(test_module, test_group, test_body))),
       ns_ := Lazy((lambda : test_module.name)),
       parts := Lazy((lambda : hydra.overlay.python.lib.strings.split_on(".", ns_.get().value))),
-      dir_parts := Lazy((lambda : hydra.overlay.python.lib.optionals.from_optional((lambda : ConsList.of()), hydra.overlay.python.lib.lists.maybe_init(parts.get())))),
-      file_name := Lazy((lambda : hydra.overlay.python.lib.strings.cat(ConsList.of("test_", hydra.overlay.python.lib.optionals.from_optional((lambda : ""), hydra.overlay.python.lib.lists.maybe_last(parts.get())), ".py")))),
-      file_path := Lazy((lambda : hydra.overlay.python.lib.strings.cat(ConsList.of(hydra.overlay.python.lib.strings.intercalate("/", dir_parts.get()), "/", file_name.get())))),
+      dir_parts := Lazy((lambda : hydra.overlay.python.lib.optionals.with_default((lambda : ConsList.of()), hydra.overlay.python.lib.lists.init(parts.get())))),
+      file_name := Lazy((lambda : hydra.overlay.python.lib.strings.concat(ConsList.of("test_", hydra.overlay.python.lib.optionals.with_default((lambda : ""), hydra.overlay.python.lib.lists.last(parts.get())), ".py")))),
+      file_path := Lazy((lambda : hydra.overlay.python.lib.strings.concat(ConsList.of(hydra.overlay.python.lib.strings.join("/", dir_parts.get()), "/", file_name.get())))),
       (file_path.get(), test_module_content.get()))[6]),
     generate_python_test_group_hierarchy(ConsList.of(), test_group))

{hydra_python-0.17.1 → hydra_python-0.17.3}/src/main/python/hydra/python/utils.py RENAMED Viewed

@@ -96,7 +96,7 @@ def py_expression_to_py_slice(expr: hydra.python.syntax.Expression) -> hydra.pyt
 def primary_with_expression_slices(prim: hydra.python.syntax.Primary, exprs: Sequence[hydra.python.syntax.Expression]) -> hydra.python.syntax.Primary:
     r"""Create a Primary with expression slices."""
-    return hydra.overlay.python.lib.optionals.from_optional((lambda : prim),
+    return hydra.overlay.python.lib.optionals.with_default((lambda : prim),
     hydra.overlay.python.lib.optionals.map((lambda p: primary_with_slices(prim,
     py_expression_to_py_slice(hydra.overlay.python.lib.pairs.first(p)),
     hydra.overlay.python.lib.lists.map((lambda e: cast(hydra.python.syntax.SliceOrStarredExpression,
@@ -258,7 +258,7 @@ def decode_py_conjunction_to_py_primary(c: hydra.python.syntax.Conjunction) -> O
     inversions = c.value
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(inversions), 1),
-    (lambda : hydra.overlay.python.lib.optionals.bind(hydra.overlay.python.lib.lists.maybe_head(inversions), (lambda i: decode_py_inversion_to_py_primary(i)))),
+    (lambda : hydra.overlay.python.lib.optionals.bind(hydra.overlay.python.lib.lists.head(inversions), (lambda i: decode_py_inversion_to_py_primary(i)))),
     (lambda : None_()))
 def decode_py_expression_to_py_primary(e: hydra.python.syntax.Expression) -> Optional[hydra.python.syntax.Primary]:
@@ -268,7 +268,7 @@ def decode_py_expression_to_py_primary(e: hydra.python.syntax.Expression) -> Opt
         case hydra.python.syntax.ExpressionSimple(value=disj):
             conjunctions = disj.value
             return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(conjunctions), 1),
-            (lambda : hydra.overlay.python.lib.optionals.bind(hydra.overlay.python.lib.lists.maybe_head(conjunctions), (lambda c2: decode_py_conjunction_to_py_primary(c2)))),
+            (lambda : hydra.overlay.python.lib.optionals.bind(hydra.overlay.python.lib.lists.head(conjunctions), (lambda c2: decode_py_conjunction_to_py_primary(c2)))),
             (lambda : None_()))
         case _:
@@ -546,7 +546,7 @@ extra_stmts: Sequence[hydra.python.syntax.Statement]) -> Sequence[hydra.python.s
     r"""Generate a subscriptable union class for Python 3.10."""
     name_str = name.value
-    meta_name = Lazy((lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.strings.cat2(hydra.overlay.python.lib.strings.cat2("_", name_str), "Meta"))))
+    meta_name = Lazy((lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2(hydra.overlay.python.lib.strings.concat2("_", name_str), "Meta"))))
     doc_string = Lazy((lambda : hydra.serialization.print_expr(hydra.python.serde.expression_to_expr(tyexpr))))
     return_object = Lazy((lambda : py_simple_statement_to_py_statement(cast(hydra.python.syntax.SimpleStatement,
     hydra.python.syntax.SimpleStatementReturn(hydra.python.syntax.ReturnStatement(ConsList.of(cast(hydra.python.syntax.StarExpression,