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

hydra-python 0.17.3tar.gz → 0.17.4tar.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 (21) hide show

{hydra_python-0.17.3 → hydra_python-0.17.4}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hydra-python
-Version: 0.17.3
+Version: 0.17.4
 Summary: Python support for Hydra
 Project-URL: Homepage, https://github.com/CategoricalData/hydra
 Project-URL: Repository, https://github.com/CategoricalData/hydra
@@ -9,7 +9,7 @@ License: Apache-2.0
 License-File: LICENSE
 License-File: NOTICE
 Requires-Python: >=3.12
-Requires-Dist: hydra-kernel==0.17.3
+Requires-Dist: hydra-kernel==0.17.4
 Description-Content-Type: text/markdown
 # Hydra-Python

hydra_python-0.17.4/build/main/digest.json ADDED Viewed

@@ -0,0 +1,123 @@
+{
+  "digestFormatVersion": 2,
+  "moduleFormatVersion": 1,
+  "generator": "2c0ecf5e44272577",
+  "generation": {
+    "generatorId": "2c0ecf5e44272577",
+    "mode": "published",
+    "host": "python",
+    "hydraVersion": "0.17.3",
+    "revision": "39f38e98ce",
+    "timestamp": "2026-08-10T00:06:14Z"},
+  "selfHash": "979ad9fa2784665ae8639c0a37ac80ed296d12c8524c0766c21cd7a8802e2965",
+  "dependencyHashes": [{"key": "hydra-kernel", "value": "2af6a4dff2fbf02f4859ca5f0c222c44c9ab9ce5345d26abcf7c6e39f90b5bcb"}],
+  "inputs": [
+    {
+      "key": "hydra.python.coder",
+      "value": {"kind": "other", "hash": "33c5deb31968c9c0d41834301852b38d617cdcf7453d0115b75e693c8683401a"}},
+    {
+      "key": "hydra.python.environment",
+      "value": {"kind": "other", "hash": "663b02271ddd4a6ad9ab8a2bdc152a64802a675a59280909f605d6dedcc4017e"}},
+    {
+      "key": "hydra.python.language",
+      "value": {"kind": "other", "hash": "78fb867a1d0fa6654f46f5d9fd72c2c5607d2934b7c7fbd5f5d830786b4ad91e"}},
+    {
+      "key": "hydra.python.names",
+      "value": {"kind": "other", "hash": "87bfa00de69547fcb4a14b69a56be98d3f612dcd52b76063153365c375ce91e4"}},
+    {
+      "key": "hydra.python.pyproject",
+      "value": {"kind": "other", "hash": "249512648b2b008db234ee348a72056d4d625cfeb0a80d8caacbda95002569a2"}},
+    {
+      "key": "hydra.python.serde",
+      "value": {"kind": "other", "hash": "9285fa0296e940da1de51a53465598455c46404851aefc2ce15220fc6ee7efc6"}},
+    {
+      "key": "hydra.python.syntax",
+      "value": {"kind": "other", "hash": "88a9154b48fd429f06efa0ba8981bdf12af3fed4de5a057b3304fadc623dbc19"}},
+    {
+      "key": "hydra.python.testing",
+      "value": {"kind": "other", "hash": "a40b949c594c81f8925ba423a89e46964b2b1475d44a486aa07c792c2c7f807b"}},
+    {
+      "key": "hydra.python.utils",
+      "value": {"kind": "other", "hash": "b026355e1174d4573e14ee1a932a17e1d28cef3559f2f85a330d279b543598a3"}},
+    {
+      "key": "jsonContent:hydra/dsl/python/environment.json",
+      "value": {"kind": "other", "hash": "684965cea67ad57d492b50f408c6575f679b073c5de5e76826fb0941da86ec21"}},
+    {
+      "key": "jsonContent:hydra/dsl/python/names.json",
+      "value": {"kind": "other", "hash": "2118b0194fde923feeda9877728e6a50813601ad5892dc122f3cf577e35bff6f"}},
+    {
+      "key": "jsonContent:hydra/dsl/python/syntax.json",
+      "value": {"kind": "other", "hash": "a99b94b1f3e542d606da15fd6dafa32d858ce7d71ba02f7b21d8bb4881daa4e3"}},
+    {
+      "key": "jsonContent:hydra/dsl/python/utils.json",
+      "value": {"kind": "other", "hash": "7a3b84d522c420db0db03a77f9e54635b33544f73eb49ed67cdc3a4d5dac04ae"}},
+    {
+      "key": "jsonContent:hydra/python/coder.json",
+      "value": {"kind": "other", "hash": "ec4263eccf7a8dd826d44cea6aa4fc112cf7a6eda6c4d1ffd54cda0387e60729"}},
+    {
+      "key": "jsonContent:hydra/python/environment.json",
+      "value": {"kind": "other", "hash": "889380dd3664c763437475b2e5146b38f865f4a20a308332633a33a4d038fce1"}},
+    {
+      "key": "jsonContent:hydra/python/language.json",
+      "value": {"kind": "other", "hash": "221e68d68030945db181fdd079be4ff619cb4cd1ad5d4b72b4e70f2aa1bd5230"}},
+    {
+      "key": "jsonContent:hydra/python/names.json",
+      "value": {"kind": "other", "hash": "7af58464067c990f8acdeb9399a217ee8b345e712927619b163eb18a1fd18a4a"}},
+    {
+      "key": "jsonContent:hydra/python/pyproject.json",
+      "value": {"kind": "other", "hash": "c94de46f1615e6e82d2f706d01ef04293373f6241a9a42882bb394d51b4f7f53"}},
+    {
+      "key": "jsonContent:hydra/python/serde.json",
+      "value": {"kind": "other", "hash": "648d34f63d2336972d5e0a59d4871332a07bd35c88eb38c28236e16a7fd48601"}},
+    {
+      "key": "jsonContent:hydra/python/syntax.json",
+      "value": {"kind": "other", "hash": "8dc3a26ac927fa338b273c9deee6317906977a2deec4c2df1e44ff0bbe0a64cd"}},
+    {
+      "key": "jsonContent:hydra/python/testing.json",
+      "value": {"kind": "other", "hash": "9c75b534004194396935b1dd3331bae4d8d5cbb31c3959fa3794dda00960c09a"}},
+    {
+      "key": "jsonContent:hydra/python/utils.json",
+      "value": {"kind": "other", "hash": "9fe5863fa3b3fb7b87b97041336ac5ff947f69e9bc7a8c2667f0bfc217bed724"}},
+    {
+      "key": "jsonContent:manifest.json",
+      "value": {"kind": "other", "hash": "3f94b521766d042381d7bee84596308ea4e35c7e8fb45f8fd8338a8dbe27a0ac"}}],
+  "outputs": [
+    {
+      "key": "hydra/dsl/python/environment.py",
+      "value": {"kind": "targetFile", "hash": "17b22fcaf759f776c959d41a749f506ff3c302815791e189a506c3f1af344f2c"}},
+    {
+      "key": "hydra/dsl/python/names.py",
+      "value": {"kind": "targetFile", "hash": "c571b01c5d149d3e6f587ef4524c5b065dae0ffba1b44617197f68fc1a6122fb"}},
+    {
+      "key": "hydra/dsl/python/syntax.py",
+      "value": {"kind": "targetFile", "hash": "5fe1c0c739cdac68d1b90d768153e23ebe7c805bafb96ac698a95425e2d7d7b5"}},
+    {
+      "key": "hydra/dsl/python/utils.py",
+      "value": {"kind": "targetFile", "hash": "3fed9996a3f875a53675b6c8620884949adf7d155b0e68cacfba9007d5d07b29"}},
+    {
+      "key": "hydra/python/coder.py",
+      "value": {"kind": "targetFile", "hash": "5dc0e92942be490ab049f187918a038b39c40ded8975445966c626eae6f32753"}},
+    {
+      "key": "hydra/python/environment.py",
+      "value": {"kind": "targetFile", "hash": "1036eb9d285ba3e98c85095820f2e77900334340c9f0223fd4dfd6b3e847f4df"}},
+    {
+      "key": "hydra/python/language.py",
+      "value": {"kind": "targetFile", "hash": "7ea0c3a6015ec1de92aebeed0963c1af9f3b70c8d57815e477c528c795383604"}},
+    {
+      "key": "hydra/python/names.py",
+      "value": {"kind": "targetFile", "hash": "13c7f477a13848ed7636bf773aac098599466964c2db5c35472f53b1152b05a2"}},
+    {
+      "key": "hydra/python/pyproject.py",
+      "value": {"kind": "targetFile", "hash": "1f9001d8d2273d4783105e099b874c273ce520b58456f9b447cb8d5e9a6a37d7"}},
+    {
+      "key": "hydra/python/serde.py",
+      "value": {"kind": "targetFile", "hash": "43864d35b843e14c2ee78fc5ee22e88f61d049ace6d9e951d34dbdfa242662f9"}},
+    {
+      "key": "hydra/python/syntax.py",
+      "value": {"kind": "targetFile", "hash": "24a72af882b47d80cc930f16f51a3e9c1a71c9d8da47a921829f40e847459fca"}},
+    {
+      "key": "hydra/python/testing.py",
+      "value": {"kind": "targetFile", "hash": "069c706253e0c41695c8becd42c27c84b7f6ac54b14be14975757ff09416ba92"}},
+    {
+      "key": "hydra/python/utils.py",
+      "value": {"kind": "targetFile", "hash": "7264b5ca536314e0523ccf46f069ab06dea099d68b2c3459d58ab2c989dc51c6"}}]}

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

@@ -13,7 +13,7 @@
 [project]
 name = "hydra-python"
-version = "0.17.3"
+version = "0.17.4"
 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.3",
+    "hydra-kernel == 0.17.4",
 ]
 [project.urls]

{hydra_python-0.17.3 → hydra_python-0.17.4}/src/main/python/hydra/dsl/python/environment.py RENAMED Viewed

@@ -68,7 +68,8 @@ graph: hydra.typed.TypedTerm[hydra.graph.Graph],
 nullary_bindings: hydra.typed.TypedTerm[Set[hydra.core.Name]],
 version: hydra.typed.TypedTerm[hydra.python.environment.PythonVersion],
 skip_casts: hydra.typed.TypedTerm[bool],
-inline_variables: hydra.typed.TypedTerm[Set[hydra.core.Name]]) -> hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment]:
+inline_variables: hydra.typed.TypedTerm[Set[hydra.core.Name]],
+overlay_subs: hydra.typed.TypedTerm[Set[str]]) -> hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment]:
     r"""DSL constructor for hydra.python.environment.PythonEnvironment."""
     return hydra.typed.TypedTerm(cast(hydra.core.Term,
@@ -79,7 +80,8 @@ inline_variables: hydra.typed.TypedTerm[Set[hydra.core.Name]]) -> hydra.typed.Ty
     hydra.core.Field(hydra.core.Name("nullaryBindings"), nullary_bindings.value),
     hydra.core.Field(hydra.core.Name("version"), version.value),
     hydra.core.Field(hydra.core.Name("skipCasts"), skip_casts.value),
-    hydra.core.Field(hydra.core.Name("inlineVariables"), inline_variables.value))))))
+    hydra.core.Field(hydra.core.Name("inlineVariables"), inline_variables.value),
+    hydra.core.Field(hydra.core.Name("overlaySubs"), overlay_subs.value))))))
 def python_environment_bound_type_variables(x: hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment]) -> hydra.typed.TypedTerm[tuple[Sequence[hydra.core.Name], Mapping[hydra.core.Name, hydra.python.syntax.Name]]]:
     r"""DSL accessor for the boundTypeVariables field of hydra.python.environment.PythonEnvironment."""
@@ -121,6 +123,14 @@ def python_environment_nullary_bindings(x: hydra.typed.TypedTerm[hydra.python.en
     hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("nullaryBindings")))),
     x.value))))
+def python_environment_overlay_subs(x: hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment]) -> hydra.typed.TypedTerm[Set[str]]:
+    r"""DSL accessor for the overlaySubs field of hydra.python.environment.PythonEnvironment."""
+    return hydra.typed.TypedTerm(cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("overlaySubs")))),
+    x.value))))
 # DSL name token for hydra.python.environment.PythonEnvironment.
 python_environment_python_environment = hydra.typed.TypedName(hydra.core.Name("hydra.python.environment.PythonEnvironment"))
@@ -176,6 +186,11 @@ new_val: hydra.typed.TypedTerm[tuple[Sequence[hydra.core.Name], Mapping[hydra.co
     cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("inlineVariables")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("overlaySubs"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("overlaySubs")))),
     original.value)))))))))
 def python_environment_with_graph(original: hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment],
@@ -214,6 +229,11 @@ new_val: hydra.typed.TypedTerm[hydra.graph.Graph]) -> hydra.typed.TypedTerm[hydr
     cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("inlineVariables")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("overlaySubs"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("overlaySubs")))),
     original.value)))))))))
 def python_environment_with_inline_variables(original: hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment],
@@ -252,7 +272,12 @@ new_val: hydra.typed.TypedTerm[Set[hydra.core.Name]]) -> hydra.typed.TypedTerm[h
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("skipCasts")))),
     original.value)))),
-    hydra.core.Field(hydra.core.Name("inlineVariables"), new_val.value))))))
+    hydra.core.Field(hydra.core.Name("inlineVariables"), new_val.value),
+    hydra.core.Field(hydra.core.Name("overlaySubs"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("overlaySubs")))),
+    original.value)))))))))
 def python_environment_with_namespaces(original: hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment],
 new_val: hydra.typed.TypedTerm[hydra.util.ModuleNames[hydra.python.syntax.DottedName]]) -> hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment]:
@@ -290,6 +315,11 @@ new_val: hydra.typed.TypedTerm[hydra.util.ModuleNames[hydra.python.syntax.Dotted
     cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("inlineVariables")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("overlaySubs"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("overlaySubs")))),
     original.value)))))))))
 def python_environment_with_nullary_bindings(original: hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment],
@@ -328,8 +358,55 @@ new_val: hydra.typed.TypedTerm[Set[hydra.core.Name]]) -> hydra.typed.TypedTerm[h
     cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("inlineVariables")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("overlaySubs"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("overlaySubs")))),
     original.value)))))))))
+def python_environment_with_overlay_subs(original: hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment], new_val: hydra.typed.TypedTerm[Set[str]]) -> hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment]:
+    r"""DSL updater for the overlaySubs field of hydra.python.environment.PythonEnvironment."""
+    return hydra.typed.TypedTerm(cast(hydra.core.Term,
+    hydra.core.TermRecord(hydra.core.Record(hydra.core.Name("hydra.python.environment.PythonEnvironment"),
+    ConsList.of(hydra.core.Field(hydra.core.Name("namespaces"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("namespaces")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("boundTypeVariables"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("boundTypeVariables")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("graph"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("graph")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("nullaryBindings"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("nullaryBindings")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("version"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("version")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("skipCasts"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("skipCasts")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("inlineVariables"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("inlineVariables")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("overlaySubs"), new_val.value))))))
 def python_environment_with_skip_casts(original: hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment], new_val: hydra.typed.TypedTerm[bool]) -> hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment]:
     r"""DSL updater for the skipCasts field of hydra.python.environment.PythonEnvironment."""
@@ -365,6 +442,11 @@ def python_environment_with_skip_casts(original: hydra.typed.TypedTerm[hydra.pyt
     cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("inlineVariables")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("overlaySubs"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("overlaySubs")))),
     original.value)))))))))
 def python_environment_with_version(original: hydra.typed.TypedTerm[hydra.python.environment.PythonEnvironment],
@@ -403,6 +485,11 @@ new_val: hydra.typed.TypedTerm[hydra.python.environment.PythonVersion]) -> hydra
     cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("inlineVariables")))),
+    original.value)))),
+    hydra.core.Field(hydra.core.Name("overlaySubs"),
+    cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermProject(hydra.core.Projection(hydra.core.Name("hydra.python.environment.PythonEnvironment"), hydra.core.Name("overlaySubs")))),
     original.value)))))))))
 def python_module_metadata(namespaces: hydra.typed.TypedTerm[hydra.util.ModuleNames[hydra.python.syntax.DottedName]],

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

@@ -3,9 +3,9 @@
 r"""DSL functions for hydra.python.names."""
 from __future__ import annotations
-from collections.abc import Callable, Mapping
+from collections.abc import Callable, Mapping, Set
 from functools import lru_cache
-from hydra.overlay.python.util import Lazy, PersistentMap
+from hydra.overlay.python.util import Lazy, PersistentMap, PersistentSet
 from typing import TypeVar, cast
 import hydra.core
 import hydra.typed
@@ -78,19 +78,23 @@ def encode_namespace(arg0: hydra.typed.TypedTerm[hydra.packaging.ModuleName]) ->
     return hydra.typed.TypedTerm(cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term, hydra.core.TermVariable(hydra.core.Name("hydra.python.names.encodeNamespace"))), arg0.value))))
-def encode_namespace_string_with_overrides(arg0: hydra.typed.TypedTerm[hydra.packaging.ModuleName]) -> hydra.typed.TypedTerm[str]:
+def encode_namespace_string_with_overrides(arg0: hydra.typed.TypedTerm[Set[str]], arg1: hydra.typed.TypedTerm[hydra.packaging.ModuleName]) -> hydra.typed.TypedTerm[str]:
     r"""DSL reference to hydra.python.names.encodeNamespaceStringWithOverrides."""
     return hydra.typed.TypedTerm(cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term, hydra.core.TermVariable(hydra.core.Name("hydra.python.names.encodeNamespaceStringWithOverrides"))),
-    arg0.value))))
+    arg0.value))),
+    arg1.value))))
-def encode_namespace_with_overrides(arg0: hydra.typed.TypedTerm[hydra.packaging.ModuleName]) -> hydra.typed.TypedTerm[hydra.python.syntax.DottedName]:
+def encode_namespace_with_overrides(arg0: hydra.typed.TypedTerm[Set[str]], arg1: hydra.typed.TypedTerm[hydra.packaging.ModuleName]) -> hydra.typed.TypedTerm[hydra.python.syntax.DottedName]:
     r"""DSL reference to hydra.python.names.encodeNamespaceWithOverrides."""
     return hydra.typed.TypedTerm(cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term, hydra.core.TermVariable(hydra.core.Name("hydra.python.names.encodeNamespaceWithOverrides"))),
-    arg0.value))))
+    arg0.value))),
+    arg1.value))))
 def encode_type_variable(arg0: hydra.typed.TypedTerm[hydra.core.Name]) -> hydra.typed.TypedTerm[hydra.python.syntax.Name]:
     r"""DSL reference to hydra.python.names.encodeTypeVariable."""

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

@@ -3,10 +3,10 @@
 r"""DSL functions for hydra.python.utils."""
 from __future__ import annotations
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Sequence, Set
 from functools import lru_cache
 from hydra.overlay.python.dsl.python import Optional
-from hydra.overlay.python.util import ConsList, Lazy
+from hydra.overlay.python.util import ConsList, Lazy, PersistentSet
 from typing import TypeVar, cast
 import hydra.core
 import hydra.typed
@@ -113,14 +113,17 @@ def double_quoted_string(arg0: hydra.typed.TypedTerm[str]) -> hydra.typed.TypedT
     return hydra.typed.TypedTerm(cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term, hydra.core.TermVariable(hydra.core.Name("hydra.python.utils.doubleQuotedString"))), arg0.value))))
-def find_namespaces(arg0: hydra.typed.TypedTerm[hydra.packaging.ModuleName],
-arg1: hydra.typed.TypedTerm[Sequence[hydra.packaging.Definition]]) -> hydra.typed.TypedTerm[hydra.util.ModuleNames[hydra.python.syntax.DottedName]]:
+def find_namespaces(arg0: hydra.typed.TypedTerm[Set[str]],
+arg1: hydra.typed.TypedTerm[hydra.packaging.ModuleName],
+arg2: hydra.typed.TypedTerm[Sequence[hydra.packaging.Definition]]) -> hydra.typed.TypedTerm[hydra.util.ModuleNames[hydra.python.syntax.DottedName]]:
     r"""DSL reference to hydra.python.utils.findNamespaces."""
     return hydra.typed.TypedTerm(cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
+    hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term,
     hydra.core.TermApplication(hydra.core.Application(cast(hydra.core.Term, hydra.core.TermVariable(hydra.core.Name("hydra.python.utils.findNamespaces"))), arg0.value))),
-    arg1.value))))
+    arg1.value))),
+    arg2.value))))
 def function_call(arg0: hydra.typed.TypedTerm[hydra.python.syntax.Primary],
 arg1: hydra.typed.TypedTerm[Sequence[hydra.python.syntax.Expression]]) -> hydra.typed.TypedTerm[hydra.python.syntax.Expression]:

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

@@ -22,6 +22,7 @@ import hydra.file
 import hydra.formatting
 import hydra.graph
 import hydra.lexical
+import hydra.names
 import hydra.overlay.python.lib.eithers
 import hydra.overlay.python.lib.equality
 import hydra.overlay.python.lib.lists
@@ -34,7 +35,6 @@ 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
@@ -80,7 +80,14 @@ def python_environment_get_graph(env: hydra.python.environment.PythonEnvironment
 def python_environment_set_graph(tc: hydra.graph.Graph, env: hydra.python.environment.PythonEnvironment) -> hydra.python.environment.PythonEnvironment:
     r"""Set the Graph in a PythonEnvironment."""
-    return hydra.python.environment.PythonEnvironment(env.namespaces, env.bound_type_variables, tc, env.nullary_bindings, env.version, env.skip_casts, env.inline_variables)
+    return hydra.python.environment.PythonEnvironment(env.namespaces,
+    env.bound_type_variables,
+    tc,
+    env.nullary_bindings,
+    env.version,
+    env.skip_casts,
+    env.inline_variables,
+    env.overlay_subs)
 def analyze_python_function(cx: hydra.typing.InferenceContext, env: hydra.python.environment.PythonEnvironment, term: hydra.core.Term) -> Either[T0, hydra.typing.FunctionStructure[hydra.python.environment.PythonEnvironment]]:
     r"""Analyze a function term with Python-specific Graph management."""
@@ -156,7 +163,8 @@ def eliminate_unit_var(v: hydra.core.Name, term0: hydra.core.Term) -> hydra.core
             case hydra.core.TermMap(value=m):
                 return cast(hydra.core.Term,
-                hydra.core.TermMap(hydra.overlay.python.lib.maps.from_list(hydra.overlay.python.lib.lists.map((lambda kv: (recurse(hydra.overlay.python.lib.pairs.first(kv)), recurse(hydra.overlay.python.lib.pairs.second(kv)))), hydra.overlay.python.lib.maps.to_list(m)))))
+                hydra.core.TermMap(hydra.overlay.python.lib.maps.from_list(hydra.overlay.python.lib.lists.map((lambda kv: (recurse(hydra.overlay.python.lib.pairs.first(kv)), recurse(hydra.overlay.python.lib.pairs.second(kv)))),
+                hydra.overlay.python.lib.maps.to_list(m)))))
             case hydra.core.TermRecord(value=rec):
                 return cast(hydra.core.Term,
@@ -172,7 +180,8 @@ def eliminate_unit_var(v: hydra.core.Name, term0: hydra.core.Term) -> hydra.core
                 return cast(hydra.core.Term, hydra.core.TermOptional(hydra.overlay.python.lib.optionals.map(recurse, mt)))
             case hydra.core.TermPair(value=p):
-                return cast(hydra.core.Term, hydra.core.TermPair((recurse(hydra.overlay.python.lib.pairs.first(p)), recurse(hydra.overlay.python.lib.pairs.second(p)))))
+                return cast(hydra.core.Term,
+                hydra.core.TermPair((recurse(hydra.overlay.python.lib.pairs.first(p)), recurse(hydra.overlay.python.lib.pairs.second(p)))))
             case hydra.core.TermWrap(value=wt):
                 return cast(hydra.core.Term, hydra.core.TermWrap(hydra.core.WrappedTerm(wt.type_name, recurse(wt.body))))
@@ -285,7 +294,9 @@ def collect_type_variables(initial: Set[hydra.core.Name], typ: hydra.core.Type)
             case hydra.core.TypeForall(value=ft):
                 return (
                   v := Lazy((lambda : ft.parameter)),
-                  (body := Lazy((lambda : ft.body)), collect_type_variables(hydra.overlay.python.lib.sets.insert(v.get(), initial), body.get()))[1])[1]
+                  (
+                    body := Lazy((lambda : ft.body)),
+                    collect_type_variables(hydra.overlay.python.lib.sets.insert(v.get(), initial), body.get()))[1])[1]
             case _:
                 return (
@@ -337,7 +348,9 @@ def deduplicate_case_variables(cases_: Sequence[hydra.core.CaseAlternative]) ->
                   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())))),
                   new_field := Lazy((lambda : hydra.core.CaseAlternative(fname, new_term.get()))),
-                  (hydra.overlay.python.lib.maps.insert(v, count2.get(), count_by_name()), hydra.overlay.python.lib.lists.cons(new_field.get(), done())))[6]))
+                  (
+                    hydra.overlay.python.lib.maps.insert(v, count2.get(), count_by_name()),
+                    hydra.overlay.python.lib.lists.cons(new_field.get(), done())))[6]))
             case _:
                 return (count_by_name(), hydra.overlay.python.lib.lists.cons(field, done()))
@@ -514,7 +527,8 @@ def encode_literal(lit: hydra.core.Literal) -> Either[T0, hydra.python.syntax.Ex
             hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("bytes"))))),
             ConsList.of(hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom,
             hydra.python.syntax.AtomList(hydra.python.utils.py_list(hydra.overlay.python.lib.lists.map((lambda byte_val: hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom,
-            hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberInteger(hydra.overlay.python.lib.literals.int32_to_bigint(byte_val))))))),
+            hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number,
+            hydra.python.syntax.NumberInteger(hydra.overlay.python.lib.literals.int32_to_bigint(byte_val))))))),
             byte_values()))))))))
         case hydra.core.LiteralBoolean(value=b):
@@ -882,7 +896,10 @@ def make_simple_lambda(arity: int, lhs: hydra.python.syntax.Expression) -> hydra
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(arity, 0),
     (lambda : lhs),
     (lambda : cast(hydra.python.syntax.Expression,
-    hydra.python.syntax.ExpressionLambda(hydra.python.syntax.Lambda(hydra.python.syntax.LambdaParameters(None_(), hydra.overlay.python.lib.lists.map((lambda a: hydra.python.syntax.LambdaParamNoDefault(a)), args()), ConsList.of(), None_()),
+    hydra.python.syntax.ExpressionLambda(hydra.python.syntax.Lambda(hydra.python.syntax.LambdaParameters(None_(),
+    hydra.overlay.python.lib.lists.map((lambda a: hydra.python.syntax.LambdaParamNoDefault(a)), args()),
+    ConsList.of(),
+    None_()),
     hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(lhs),
     hydra.overlay.python.lib.lists.map((lambda a: cast(hydra.python.syntax.Expression,
     hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction(ConsList.of(hydra.python.syntax.Conjunction(ConsList.of(cast(hydra.python.syntax.Inversion,
@@ -904,7 +921,10 @@ def make_uncurried_lambda(params: Sequence[hydra.python.syntax.Name], body: hydr
     r"""Create an uncurried lambda with multiple parameters."""
     return cast(hydra.python.syntax.Expression,
-    hydra.python.syntax.ExpressionLambda(hydra.python.syntax.Lambda(hydra.python.syntax.LambdaParameters(None_(), hydra.overlay.python.lib.lists.map((lambda p: hydra.python.syntax.LambdaParamNoDefault(p)), params), ConsList.of(), None_()),
+    hydra.python.syntax.ExpressionLambda(hydra.python.syntax.Lambda(hydra.python.syntax.LambdaParameters(None_(),
+    hydra.overlay.python.lib.lists.map((lambda p: hydra.python.syntax.LambdaParamNoDefault(p)), params),
+    ConsList.of(),
+    None_()),
     body)))
 def encode_variable(cx: T0,
@@ -976,7 +996,8 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       el_trivial1 := Lazy((lambda : hydra.predicates.is_trivial_term(el.term))),
       hydra.overlay.python.lib.optionals.cases(el.type_scheme,
       (lambda : Right(as_variable())),
-      (lambda ts: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.arity.type_scheme_arity(ts), 0), hydra.predicates.is_complex_binding(tc, el)),
+      (lambda ts: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.arity.type_scheme_arity(ts), 0),
+      hydra.predicates.is_complex_binding(tc, el)),
       hydra.overlay.python.lib.logic.not_(el_trivial1.get())),
       (lambda : Right(as_function_call())),
       (lambda : (
@@ -1015,7 +1036,8 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
     (lambda el: (
       el_trivial := Lazy((lambda : hydra.predicates.is_trivial_term(el.term))),
       hydra.overlay.python.lib.optionals.cases(el.type_scheme,
-      (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.arity.type_arity(typ), 0), hydra.overlay.python.lib.logic.not_(el_trivial.get())),
+      (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.arity.type_arity(typ), 0),
+      hydra.overlay.python.lib.logic.not_(el_trivial.get())),
       (lambda : Right(as_function_call())),
       (lambda : (
         as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.null(hydra.variables.free_variables_in_type(typ))),
@@ -1092,7 +1114,8 @@ body: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
       inner_env.nullary_bindings,
       inner_env.version,
       inner_env.skip_casts,
-      hydra.overlay.python.lib.sets.union(inline_vars(), inner_env.inline_variables)))),
+      hydra.overlay.python.lib.sets.union(inline_vars(), inner_env.inline_variables),
+      inner_env.overlay_subs))),
       body(updated_env.get()))[1]))
 def with_type_lambda(v1: hydra.python.environment.PythonEnvironment,
@@ -1178,7 +1201,8 @@ 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.with_default((lambda : hydra.python.utils.py_name_to_py_expression(hydra.python.syntax.Name(""))), hydra.overlay.python.lib.lists.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()),
@@ -1320,7 +1344,8 @@ def encode_term_inline(cx: hydra.typing.InferenceContext, env: hydra.python.envi
               inner_env0.get().nullary_bindings,
               inner_env0.get().version,
               inner_env0.get().skip_casts,
-              hydra.overlay.python.lib.sets.union(hydra.overlay.python.lib.sets.from_list(binding_names.get()), inner_env0.get().inline_variables)))),
+              hydra.overlay.python.lib.sets.union(hydra.overlay.python.lib.sets.from_list(binding_names.get()), inner_env0.get().inline_variables),
+              inner_env0.get().overlay_subs))),
               hydra.overlay.python.lib.eithers.bind(encode_term_inline(cx, inner_env.get(), False, inner_body.get()),
               (lambda pbody: (
                 pparams := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda v1: hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, inner_env.get(), v1)),
@@ -1592,7 +1617,8 @@ term: hydra.core.Term) -> Either[hydra.errors.Error, Sequence[hydra.python.synta
     gather_fun = Lazy((lambda : hydra.overlay.python.lib.pairs.second(gathered())))
     stripped_fun = Lazy((lambda : hydra.strip.deannotate_and_detype_term(gather_fun())))
     is_self_call = Lazy((lambda : (lambda n: hydra.overlay.python.lib.equality.equal(n, func_name))(stripped_fun().value) if isinstance(stripped_fun(), hydra.core.TermVariable) else False))
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(is_self_call(), hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(gather_args()), hydra.overlay.python.lib.lists.length(param_names))),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(is_self_call(),
+    hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(gather_args()), hydra.overlay.python.lib.lists.length(param_names))),
     (lambda : hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map_list((lambda a: encode_term_inline(cx, env, False, a)), gather_args()),
     (lambda py_args: (
       assignments := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda pair: (
@@ -1962,7 +1988,8 @@ prefixes: Sequence[hydra.python.syntax.Statement]) -> Either[hydra.errors.Error,
     (lambda py_args: (
       py_params := Lazy((lambda : cast(hydra.python.syntax.Parameters,
       hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters(py_args, ConsList.of(), None_()))))),
-      is_t_c_o := Lazy((lambda : hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(args)), hydra.analysis.is_self_tail_recursive(name, body)))),
+      is_t_c_o := Lazy((lambda : hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(args)),
+      hydra.analysis.is_self_tail_recursive(name, body)))),
       hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.logic.if_else(is_t_c_o.get(),
       (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_multiline_t_c_o(cx, env, name, args, body),
       (lambda tco_stmts: (
@@ -2368,7 +2395,8 @@ def extend_env_with_type_var(env: hydra.python.environment.PythonEnvironment, va
     env.nullary_bindings,
     env.version,
     env.skip_casts,
-    env.inline_variables)
+    env.inline_variables,
+    env.overlay_subs)
 def encode_type_assignment_inner(cx: T0,
 env: hydra.python.environment.PythonEnvironment,
@@ -3074,10 +3102,10 @@ def set_meta_uses_type_var(m: hydra.python.environment.PythonModuleMetadata, b:
     m.uses_right,
     b)
-def gather_metadata(focus_ns: hydra.packaging.ModuleName, defs: Sequence[hydra.packaging.Definition]) -> hydra.python.environment.PythonModuleMetadata:
+def gather_metadata(overlay_subs: Set[str], focus_ns: hydra.packaging.ModuleName, defs: Sequence[hydra.packaging.Definition]) -> hydra.python.environment.PythonModuleMetadata:
     r"""Gather metadata from definitions."""
-    start = Lazy((lambda : empty_metadata(hydra.python.utils.find_namespaces(focus_ns, defs))))
+    start = Lazy((lambda : empty_metadata(hydra.python.utils.find_namespaces(overlay_subs, focus_ns, defs))))
     def add_def(meta: hydra.python.environment.PythonModuleMetadata, def_: hydra.packaging.Definition) -> hydra.python.environment.PythonModuleMetadata:
         match def_:
             case hydra.packaging.DefinitionTerm(value=term_def):
@@ -3103,8 +3131,8 @@ def gather_metadata(focus_ns: hydra.packaging.ModuleName, defs: Sequence[hydra.p
 # The target Python version for code generation.
 target_python_version = hydra.python.utils.target_python_version
-def initial_environment(namespaces: hydra.util.ModuleNames[hydra.python.syntax.DottedName], tcontext: hydra.graph.Graph) -> hydra.python.environment.PythonEnvironment:
-    r"""Create an initial Python environment for code generation."""
+def initial_environment(namespaces: hydra.util.ModuleNames[hydra.python.syntax.DottedName], tcontext: hydra.graph.Graph, overlay_subs: Set[str]) -> hydra.python.environment.PythonEnvironment:
+    r"""Create an initial Python environment for code generation, given the on-disk overlay-existence set (#630) driving emission-time primitive-reference redirects."""
     return hydra.python.environment.PythonEnvironment(namespaces,
     (ConsList.of(), hydra.overlay.python.lib.maps.empty()),
@@ -3112,7 +3140,8 @@ def initial_environment(namespaces: hydra.util.ModuleNames[hydra.python.syntax.D
     hydra.overlay.python.lib.sets.empty(),
     target_python_version,
     True,
-    hydra.overlay.python.lib.sets.empty())
+    hydra.overlay.python.lib.sets.empty(),
+    overlay_subs)
 def is_type_module_check(defs: Sequence[hydra.packaging.Definition]) -> bool:
     r"""Check whether a list of definitions contains any type definitions."""
@@ -3184,9 +3213,12 @@ def module_standard_imports(meta: hydra.python.environment.PythonModuleMetadata)
     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.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]),
+      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())
+    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())
 def module_imports(namespaces: hydra.util.ModuleNames[hydra.python.syntax.DottedName], meta: hydra.python.environment.PythonModuleMetadata) -> Sequence[hydra.python.syntax.Statement]:
     r"""Generate all import statements for a Python module."""
@@ -3245,30 +3277,35 @@ body: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
     r"""Execute a computation with definitions in scope."""
     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_()))),
+      _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.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)
-def encode_python_module(cx: hydra.typing.InferenceContext,
+def encode_python_module(overlay_subs: Set[str],
+cx: hydra.typing.InferenceContext,
 g: hydra.graph.Graph,
 mod: hydra.packaging.Module,
 defs0: Sequence[hydra.packaging.Definition]) -> Either[hydra.errors.Error, hydra.python.syntax.Module]:
-    r"""Encode a Hydra module to a Python module AST."""
+    r"""Encode a Hydra module to a Python module AST, given the on-disk overlay-existence set (#630) driving emission-time primitive-reference redirects."""
     defs = Lazy((lambda : hydra.environment.reorder_defs(defs0)))
-    meta0 = Lazy((lambda : gather_metadata(mod.name, defs())))
+    meta0 = Lazy((lambda : gather_metadata(overlay_subs, mod.name, defs())))
     namespaces0 = meta0().namespaces
-    env0 = Lazy((lambda : initial_environment(namespaces0, g)))
+    env0 = Lazy((lambda : initial_environment(namespaces0, g, overlay_subs)))
     is_type_mod = Lazy((lambda : is_type_module_check(defs0)))
     return with_definitions(env0(),
     defs(),
-    (lambda env: hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map((lambda xs: hydra.overlay.python.lib.lists.concat(xs)), hydra.overlay.python.lib.eithers.map_list((lambda d: encode_definition(cx, env, d)), defs())),
+    (lambda env: hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map((lambda xs: hydra.overlay.python.lib.lists.concat(xs)),
+    hydra.overlay.python.lib.eithers.map_list((lambda d: encode_definition(cx, env, d)), defs())),
     (lambda def_stmts: (
       meta2 := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(is_type_mod()), use_inline_type_params()),
       (lambda : set_meta_uses_type_var(meta0(), False)),
       (lambda : meta0())))),
-      meta := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(is_type_mod(), hydra.overlay.python.lib.equality.equal(target_python_version, hydra.python.environment.PythonVersion.PYTHON310)),
+      meta := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(is_type_mod(),
+      hydra.overlay.python.lib.equality.equal(target_python_version, hydra.python.environment.PythonVersion.PYTHON310)),
       (lambda : set_meta_uses_type_alias(meta2.get(), True)),
       (lambda : meta2.get())))),
       namespaces := Lazy((lambda : meta0().namespaces)),
@@ -3279,7 +3316,8 @@ defs0: Sequence[hydra.packaging.Definition]) -> Either[hydra.errors.Error, hydra
       tvars := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.or_(is_type_mod(), hydra.overlay.python.lib.logic.not_(use_inline_type_params())),
       (lambda : meta.get().type_variables),
       (lambda : hydra.overlay.python.lib.sets.empty())))),
-      tvar_stmts := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda tv: tvar_statement(hydra.python.names.encode_type_variable(tv))), hydra.overlay.python.lib.sets.to_list(tvars.get())))),
+      tvar_stmts := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda tv: tvar_statement(hydra.python.names.encode_type_variable(tv))),
+      hydra.overlay.python.lib.sets.to_list(tvars.get())))),
       body := Lazy((lambda : hydra.overlay.python.lib.lists.filter((lambda group: hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(group))),
       hydra.overlay.python.lib.lists.concat(ConsList.of(ConsList.of(comment_stmts.get(), import_stmts.get(), tvar_stmts.get()), def_stmts))))),
       Right(hydra.python.syntax.Module(body.get())))[8]))))
@@ -3314,7 +3352,9 @@ def extend_meta_for_types(types: Sequence[hydra.core.Type], meta: hydra.python.e
     names = Lazy((lambda : hydra.overlay.python.lib.sets.unions(hydra.overlay.python.lib.lists.map((lambda t: hydra.dependencies.type_dependency_names(False, t)), types))))
     current_ns = meta.namespaces
-    updated_ns = Lazy((lambda : hydra.analysis.add_names_to_module_names((lambda x1: hydra.python.names.encode_namespace_with_overrides(x1)), names(), current_ns)))
+    updated_ns = Lazy((lambda : hydra.analysis.add_names_to_module_names((lambda v1: hydra.python.names.encode_namespace_with_overrides(hydra.overlay.python.lib.sets.empty(), v1)),
+    names(),
+    current_ns)))
     meta1 = Lazy((lambda : set_meta_namespaces(updated_ns(), meta)))
     return hydra.overlay.python.lib.lists.foldl((lambda m, t: extend_meta_for_type(True, False, t, m)), meta1(), types)
@@ -3360,13 +3400,14 @@ def make_thunk(pbody: hydra.python.syntax.Expression) -> hydra.python.syntax.Exp
     ConsList.of(py_int(1)))),
     ConsList.of(wrap_in_nullary_lambda(pbody)))
-def module_to_python(mod: hydra.packaging.Module,
+def module_to_python(overlay_subs: Set[str],
+mod: hydra.packaging.Module,
 defs: Sequence[hydra.packaging.Definition],
 cx: hydra.typing.InferenceContext,
 g: hydra.graph.Graph) -> Either[hydra.errors.Error, Mapping[str, str]]:
     r"""Convert a Hydra module to Python source files."""
-    return hydra.overlay.python.lib.eithers.bind(encode_python_module(cx, g, mod, defs),
+    return hydra.overlay.python.lib.eithers.bind(encode_python_module(overlay_subs, cx, g, mod, defs),
     (lambda file: (
       s := Lazy((lambda : hydra.serialization.print_expr(hydra.serialization.parenthesize(hydra.python.serde.module_to_expr(file))))),
       path := Lazy((lambda : hydra.names.module_name_to_file_path(hydra.util.CaseConvention.LOWER_SNAKE, hydra.file.FileExtension("py"), mod.name))),

{hydra_python-0.17.3 → hydra_python-0.17.4}/src/main/python/hydra/python/environment.py RENAMED Viewed

@@ -34,6 +34,7 @@ class PythonEnvironment:
     version: Annotated[PythonVersion, "Target Python version"]
     skip_casts: Annotated[bool, "When True, skip generating cast() calls for reduced memory usage"]
     inline_variables: Annotated[Set[hydra.core.Name], "Variables that are inline let bindings (walrus operators)"]
+    overlay_subs: Annotated[Set[str], "hydra.lib.<sub> sub-namespaces that have an overlay implementation on this host (#630) -- the on-disk existence signal driving emission-time redirect of primitive references to hydra.overlay.python.lib.<sub>"]
     TYPE_ = hydra.core.Name("hydra.python.environment.PythonEnvironment")
     NAMESPACES = hydra.core.Name("namespaces")
@@ -43,6 +44,7 @@ class PythonEnvironment:
     VERSION = hydra.core.Name("version")
     SKIP_CASTS = hydra.core.Name("skipCasts")
     INLINE_VARIABLES = hydra.core.Name("inlineVariables")
+    OVERLAY_SUBS = hydra.core.Name("overlaySubs")
     def with_namespaces(self, namespaces):
         return replace(self, namespaces=namespaces)
@@ -58,6 +60,8 @@ class PythonEnvironment:
         return replace(self, skip_casts=skip_casts)
     def with_inline_variables(self, inline_variables):
         return replace(self, inline_variables=inline_variables)
+    def with_overlay_subs(self, overlay_subs):
+        return replace(self, overlay_subs=overlay_subs)
     @staticmethod
     def builder():
@@ -71,6 +75,7 @@ class PythonEnvironment:
         _version: PythonVersion = None
         _skip_casts: bool = None
         _inline_variables: Set[hydra.core.Name] = None
+        _overlay_subs: Set[str] = None
         def namespaces(self, namespaces):
             return replace(self, _namespaces=namespaces)
         def bound_type_variables(self, bound_type_variables):
@@ -85,6 +90,8 @@ class PythonEnvironment:
             return replace(self, _skip_casts=skip_casts)
         def inline_variables(self, inline_variables):
             return replace(self, _inline_variables=inline_variables)
+        def overlay_subs(self, overlay_subs):
+            return replace(self, _overlay_subs=overlay_subs)
         def build(self):
             return PythonEnvironment(namespaces=self._namespaces,
             bound_type_variables=self._bound_type_variables,
@@ -92,7 +99,8 @@ class PythonEnvironment:
             nullary_bindings=self._nullary_bindings,
             version=self._version,
             skip_casts=self._skip_casts,
-            inline_variables=self._inline_variables)
+            inline_variables=self._inline_variables,
+            overlay_subs=self._overlay_subs)
 @dataclass(frozen=True)
 class PythonModuleMetadata:

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

@@ -3,21 +3,22 @@
 r"""Python naming utilities: encoding Hydra names as Python names."""
 from __future__ import annotations
-from collections.abc import Callable, Mapping, Sequence
+from collections.abc import Callable, Mapping, Sequence, Set
 from functools import lru_cache
 from hydra.overlay.python.dsl.python import Given, None_
-from hydra.overlay.python.util import ConsList, Lazy, PersistentMap
+from hydra.overlay.python.util import ConsList, Lazy, PersistentMap, PersistentSet
 from typing import TypeVar, cast
 import hydra.core
 import hydra.formatting
+import hydra.names
 import hydra.overlay.python.lib.equality
 import hydra.overlay.python.lib.lists
 import hydra.overlay.python.lib.logic
 import hydra.overlay.python.lib.maps
 import hydra.overlay.python.lib.optionals
 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.python.environment
 import hydra.python.language
@@ -46,13 +47,22 @@ def overlay_python_module_aliases() -> Mapping[hydra.packaging.ModuleName, str]:
     return hydra.overlay.python.lib.maps.from_list(ConsList.of((hydra.packaging.ModuleName("hydra.test.testEnv"), "hydra.overlay.python.test_env")))
-def encode_namespace_string_with_overrides(ns_val: hydra.packaging.ModuleName) -> str:
+def encode_namespace_string_with_overrides(overlay_subs: Set[str], 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.with_default((lambda : hydra.overlay.python.lib.strings.join(".",
+    return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(hydra.overlay.python.lib.strings.split_on(".", ns_val.value)), 3),
+    hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.take(2, hydra.overlay.python.lib.strings.split_on(".", ns_val.value)),
+    ConsList.of("hydra", "lib"))),
+    hydra.overlay.python.lib.sets.member(hydra.overlay.python.lib.strings.join(".", hydra.overlay.python.lib.lists.drop(2, hydra.overlay.python.lib.strings.split_on(".", ns_val.value))),
+    overlay_subs)),
+    (lambda : Given(hydra.overlay.python.lib.strings.concat2("hydra.overlay.python.lib.",
+    hydra.overlay.python.lib.strings.join(".", hydra.overlay.python.lib.lists.drop(2, hydra.overlay.python.lib.strings.split_on(".", ns_val.value)))))),
+    (lambda : None_())),
+    (lambda : 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()))
+    hydra.overlay.python.lib.maps.lookup(ns_val, overlay_python_module_aliases()))),
+    (lambda redirected: redirected))
 def sanitize_python_name(v1: str) -> str:
     r"""Sanitize a string to be a valid Python name."""
@@ -77,7 +87,7 @@ name: hydra.core.Name) -> hydra.python.syntax.Name:
     local = qual_name().local
     py_local = Lazy((lambda : sanitize_python_name(hydra.formatting.convert_case(hydra.util.CaseConvention.CAMEL, conv, local))))
     def py_ns(ns_val: hydra.packaging.ModuleName) -> str:
-        return encode_namespace_string_with_overrides(ns_val)
+        return encode_namespace_string_with_overrides(env.overlay_subs, ns_val)
     return hydra.overlay.python.lib.logic.if_else(is_qualified,
     (lambda : hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, bound_vars()),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(mns, Given(focus_ns())),
@@ -109,7 +119,7 @@ def encode_name_qualified(env: hydra.python.environment.PythonEnvironment, name:
     mns = qual_name().module_name
     local = qual_name().local
     def py_ns(ns_val: hydra.packaging.ModuleName) -> str:
-        return encode_namespace_string_with_overrides(ns_val)
+        return encode_namespace_string_with_overrides(env.overlay_subs, ns_val)
     return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, bound_vars()),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(mns, Given(focus_ns())),
     (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))))),
@@ -124,11 +134,11 @@ def encode_namespace(ns_val: hydra.packaging.ModuleName) -> hydra.python.syntax.
     return hydra.python.syntax.DottedName(hydra.overlay.python.lib.lists.map((lambda part: hydra.python.syntax.Name(hydra.formatting.convert_case(hydra.util.CaseConvention.CAMEL, hydra.util.CaseConvention.LOWER_SNAKE, part))),
     hydra.overlay.python.lib.strings.split_on(".", ns_val.value)))
-def encode_namespace_with_overrides(ns_val: hydra.packaging.ModuleName) -> hydra.python.syntax.DottedName:
+def encode_namespace_with_overrides(overlay_subs: Set[str], ns_val: hydra.packaging.ModuleName) -> hydra.python.syntax.DottedName:
     r"""Encode a namespace as a Python dotted name, routing overlay modules to their hydra.overlay.python.* paths."""
     return hydra.python.syntax.DottedName(hydra.overlay.python.lib.lists.map((lambda part: hydra.python.syntax.Name(part)),
-    hydra.overlay.python.lib.strings.split_on(".", encode_namespace_string_with_overrides(ns_val))))
+    hydra.overlay.python.lib.strings.split_on(".", encode_namespace_string_with_overrides(overlay_subs, ns_val))))
 def encode_type_variable(name: hydra.core.Name) -> hydra.python.syntax.Name:
     r"""Encode a type variable name (capitalized)."""

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

@@ -10,13 +10,13 @@ from hydra.overlay.python.util import ConsList, Lazy
 from typing import cast
 import hydra.constants
 import hydra.core
+import hydra.names
 import hydra.overlay.python.lib.equality
 import hydra.overlay.python.lib.lists
 import hydra.overlay.python.lib.literals
 import hydra.overlay.python.lib.logic
 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
@@ -73,7 +73,8 @@ def lambda_parameters_to_expr(lp: hydra.python.syntax.LambdaParameters) -> hydra
     r"""Serialize lambda parameters."""
     nodef = lp.param_no_default
-    return hydra.serialization.comma_sep(hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: lambda_param_no_default_to_expr(x1)), nodef))
+    return hydra.serialization.comma_sep(hydra.serialization.inline_style,
+    hydra.overlay.python.lib.lists.map((lambda x1: lambda_param_no_default_to_expr(x1)), nodef))
 def python_float_literal_text(s: str) -> str:
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(s, "NaN"),
@@ -303,7 +304,9 @@ def dict_to_expr(d: hydra.python.syntax.Dict) -> hydra.ast.Expr:
 def disjunction_to_expr(d: hydra.python.syntax.Disjunction) -> hydra.ast.Expr:
     r"""Serialize a disjunction (or expression)."""
-    return hydra.serialization.symbol_sep("or", hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: conjunction_to_expr(x1)), d.value))
+    return hydra.serialization.symbol_sep("or",
+    hydra.serialization.inline_style,
+    hydra.overlay.python.lib.lists.map((lambda x1: conjunction_to_expr(x1)), d.value))
 def double_starred_kvpair_to_expr(dskv: hydra.python.syntax.DoubleStarredKvpair) -> hydra.ast.Expr:
     r"""Serialize a double-starred key-value pair."""
@@ -727,7 +730,8 @@ def untyped_assignment_to_expr(ua: hydra.python.syntax.UntypedAssignment) -> hyd
     targets = ua.targets
     rhs = ua.rhs
-    return hydra.serialization.space_sep(hydra.overlay.python.lib.lists.concat(ConsList.of(hydra.overlay.python.lib.lists.map((lambda x1: star_target_to_expr(x1)), targets), ConsList.of(annotated_rhs_to_expr(rhs)))))
+    return hydra.serialization.space_sep(hydra.overlay.python.lib.lists.concat(ConsList.of(hydra.overlay.python.lib.lists.map((lambda x1: star_target_to_expr(x1)), targets),
+    ConsList.of(annotated_rhs_to_expr(rhs)))))
 def assignment_to_expr(a: hydra.python.syntax.Assignment) -> hydra.ast.Expr:
     r"""Serialize an assignment."""
@@ -764,11 +768,13 @@ def import_from_targets_to_expr(t: hydra.python.syntax.ImportFromTargets) -> hyd
     match t:
         case hydra.python.syntax.ImportFromTargetsSimple(value=names):
-            return hydra.serialization.comma_sep(hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: import_from_as_name_to_expr(x1)), names))
+            return hydra.serialization.comma_sep(hydra.serialization.inline_style,
+            hydra.overlay.python.lib.lists.map((lambda x1: import_from_as_name_to_expr(x1)), names))
         case hydra.python.syntax.ImportFromTargetsParens(value=names2):
             return hydra.serialization.no_sep(ConsList.of(hydra.serialization.cst("("),
-            hydra.serialization.comma_sep(hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: import_from_as_name_to_expr(x1)), names2)),
+            hydra.serialization.comma_sep(hydra.serialization.inline_style,
+            hydra.overlay.python.lib.lists.map((lambda x1: import_from_as_name_to_expr(x1)), names2)),
             hydra.serialization.cst(")")))
         case hydra.python.syntax.ImportFromTargetsStar():
@@ -838,7 +844,8 @@ def raise_expression_to_expr(re: hydra.python.syntax.RaiseExpression) -> hydra.a
 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.givens(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."""
@@ -1058,7 +1065,9 @@ def keyword_patterns_to_expr(kp: hydra.python.syntax.KeywordPatterns) -> hydra.a
 def or_pattern_to_expr(op: hydra.python.syntax.OrPattern) -> hydra.ast.Expr:
     r"""Serialize an or pattern."""
-    return hydra.serialization.symbol_sep("|", hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: closed_pattern_to_expr(x1)), op.value))
+    return hydra.serialization.symbol_sep("|",
+    hydra.serialization.inline_style,
+    hydra.overlay.python.lib.lists.map((lambda x1: closed_pattern_to_expr(x1)), op.value))
 def pattern_to_expr(p: hydra.python.syntax.Pattern) -> hydra.ast.Expr:
     r"""Serialize a pattern."""
@@ -1145,7 +1154,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.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.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:
@@ -1160,7 +1171,8 @@ def block_to_expr(b: hydra.python.syntax.Block) -> hydra.ast.Expr:
     match b:
         case hydra.python.syntax.BlockIndented(value=groups):
-            return hydra.serialization.tab_indent_double_space(hydra.overlay.python.lib.lists.map((lambda stmts: hydra.serialization.newline_sep(hydra.overlay.python.lib.lists.map((lambda x1: statement_to_expr(x1)), stmts))), groups))
+            return hydra.serialization.tab_indent_double_space(hydra.overlay.python.lib.lists.map((lambda stmts: hydra.serialization.newline_sep(hydra.overlay.python.lib.lists.map((lambda x1: statement_to_expr(x1)), stmts))),
+            groups))
         case hydra.python.syntax.BlockSimple(value=ss):
             return hydra.serialization.semicolon_sep(hydra.overlay.python.lib.lists.map((lambda x1: simple_statement_to_expr(x1)), ss))

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

@@ -75,7 +75,8 @@ def generate_python_test_group_hierarchy(group_path: Sequence[str], test_group:
       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(), "")),
+      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")),
       subgroups_str.get()))))[2]))))
@@ -88,7 +89,9 @@ def generate_test_file_with_python_codec(test_module: hydra.packaging.Module, te
       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.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_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.3 → hydra_python-0.17.4}/src/main/python/hydra/python/utils.py RENAMED Viewed

@@ -3,10 +3,10 @@
 r"""Python utilities for constructing Python syntax trees."""
 from __future__ import annotations
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Sequence, Set
 from functools import lru_cache
 from hydra.overlay.python.dsl.python import Given, None_, Optional
-from hydra.overlay.python.util import ConsList, Lazy
+from hydra.overlay.python.util import ConsList, Lazy, PersistentSet
 from typing import TypeVar, cast
 import hydra.analysis
 import hydra.core
@@ -285,14 +285,15 @@ def dotted_assignment_statement(obj: hydra.python.syntax.Name, attr: hydra.pytho
     return py_assignment_to_py_statement(cast(hydra.python.syntax.Assignment,
     hydra.python.syntax.AssignmentUntyped(hydra.python.syntax.UntypedAssignment(ConsList.of(target()), py_expression_to_py_annotated_rhs(expr), None_()))))
-def find_namespaces(focus_ns: hydra.packaging.ModuleName, defs: Sequence[hydra.packaging.Definition]) -> hydra.util.ModuleNames[hydra.python.syntax.DottedName]:
-    r"""Find all namespaces referenced by a list of definitions, plus the core namespace."""
+def find_namespaces(overlay_subs: Set[str], focus_ns: hydra.packaging.ModuleName, defs: Sequence[hydra.packaging.Definition]) -> hydra.util.ModuleNames[hydra.python.syntax.DottedName]:
+    r"""Find all namespaces referenced by a list of definitions, plus the core namespace (#630: overlaySubs drives emission-time hydra.lib.<sub> redirect for these namespace refs)."""
     core_ns = hydra.packaging.ModuleName("hydra.core")
-    namespaces = Lazy((lambda : hydra.analysis.module_names_for_definitions((lambda x1: hydra.python.names.encode_namespace_with_overrides(x1)), focus_ns, defs)))
+    namespaces = Lazy((lambda : hydra.analysis.module_names_for_definitions((lambda v1: hydra.python.names.encode_namespace_with_overrides(overlay_subs, v1)), focus_ns, defs)))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.pairs.first(namespaces().focus).value, core_ns.value),
     (lambda : namespaces()),
-    (lambda : hydra.util.ModuleNames(namespaces().focus, hydra.overlay.python.lib.maps.insert(core_ns, hydra.python.names.encode_namespace(core_ns), namespaces().mapping))))
+    (lambda : hydra.util.ModuleNames(namespaces().focus,
+    hydra.overlay.python.lib.maps.insert(core_ns, hydra.python.names.encode_namespace(core_ns), namespaces().mapping))))
 @lru_cache(1)
 def get_item_params() -> hydra.python.syntax.Parameters:
@@ -306,7 +307,8 @@ def indented_block(mcomment: Optional[str], stmts: Sequence[Sequence[hydra.pytho
     r"""Create an indented block with optional comment."""
     comment_group = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(mcomment, (lambda : ConsList.of()), (lambda s: ConsList.of(comment_statement(s))))))
-    groups = Lazy((lambda : hydra.overlay.python.lib.lists.filter((lambda g: hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(g))), hydra.overlay.python.lib.lists.cons(comment_group(), stmts))))
+    groups = Lazy((lambda : hydra.overlay.python.lib.lists.filter((lambda g: hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(g))),
+    hydra.overlay.python.lib.lists.cons(comment_group(), stmts))))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(groups()),
     (lambda : cast(hydra.python.syntax.Block,
     hydra.python.syntax.BlockIndented(ConsList.of(ConsList.of(cast(hydra.python.syntax.Statement,

hydra_python-0.17.3/build/main/digest.json DELETED Viewed

@@ -1,55 +0,0 @@
-{
-  "digestFormatVersion": 1,
-  "moduleFormatVersion": 1,
-  "generator": "983e925152c14e7d",
-  "generation": {
-    "generatorId": "983e925152c14e7d",
-    "mode": "published",
-    "hydraVersion": "0.17.2",
-    "revision": "fa099dc0f8",
-    "timestamp": "2026-07-31T15:44:34Z",
-    "host": "python"
-  },
-  "selfHash": "8f12cad96047b0fe5cef599a843cbf5dd50d077d099b2a8462568a9b9064536b",
-  "depHash:hydra-kernel": "331eaf0751864ad00dbe4f2d53a1bf6c95709e006df1c87c98284a5efb306708",
-  "inputs": {
-    "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": "f0e81d57cda13bc617185cc2d09240091e816ba9fb2e1c9e6091ef888ea34e22" },
-    "hydra.python.pyproject": { "kind": "Other", "hash": "249512648b2b008db234ee348a72056d4d625cfeb0a80d8caacbda95002569a2" },
-    "hydra.python.serde": { "kind": "Other", "hash": "9285fa0296e940da1de51a53465598455c46404851aefc2ce15220fc6ee7efc6" },
-    "hydra.python.syntax": { "kind": "Other", "hash": "88a9154b48fd429f06efa0ba8981bdf12af3fed4de5a057b3304fadc623dbc19" },
-    "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": "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": "51a59a9f21446bb6cfb128e4830c74e33a42ddaffbe67afddfa55d9fee610fb9" },
-    "jsonContent:hydra/python/pyproject.json": { "kind": "Other", "hash": "c94de46f1615e6e82d2f706d01ef04293373f6241a9a42882bb394d51b4f7f53" },
-    "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": "9c75b534004194396935b1dd3331bae4d8d5cbb31c3959fa3794dda00960c09a" },
-    "jsonContent:hydra/python/utils.json": { "kind": "Other", "hash": "fea597ac6c71916255914f8196c377b780d32b475b5b81cd1c0a087b8abe87c3" },
-    "jsonContent:manifest.json": { "kind": "Other", "hash": "3f94b521766d042381d7bee84596308ea4e35c7e8fb45f8fd8338a8dbe27a0ac" }
-  },
-  "outputs": {
-    "hydra/dsl/python/environment.py": { "kind": "TargetFile", "hash": "b209619140e3be5a139672944bed98f4de87b6ca48ab93981722d158fde1f424" },
-    "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": "8a2d415e5e026b13d6c7fd620dcce839443f028cc34720a79e6a2de482f06238" },
-    "hydra/python/environment.py": { "kind": "TargetFile", "hash": "240979735f3a2d479403834c1a4d7a16f060ad447eb4f3b05fbb2db591d7ad0b" },
-    "hydra/python/language.py": { "kind": "TargetFile", "hash": "7ea0c3a6015ec1de92aebeed0963c1af9f3b70c8d57815e477c528c795383604" },
-    "hydra/python/names.py": { "kind": "TargetFile", "hash": "09490cd34e878fa3c9ad7940171b86a60843fe7591f78d7bb57eb3c52c4edc2e" },
-    "hydra/python/pyproject.py": { "kind": "TargetFile", "hash": "1f9001d8d2273d4783105e099b874c273ce520b58456f9b447cb8d5e9a6a37d7" },
-    "hydra/python/serde.py": { "kind": "TargetFile", "hash": "ad1714baddb710cd3f345c339a9e6a55862197660cd065ac84d3736716792cbf" },
-    "hydra/python/syntax.py": { "kind": "TargetFile", "hash": "24a72af882b47d80cc930f16f51a3e9c1a71c9d8da47a921829f40e847459fca" },
-    "hydra/python/testing.py": { "kind": "TargetFile", "hash": "2b9137ccd1449a8c636c59df9dc5d83662ed1e9547802ba6b8c2c5db5ee29710" },
-    "hydra/python/utils.py": { "kind": "TargetFile", "hash": "05504b0be6dff96d72997295abd89a5510bbc8580b48f85bd25575b313e19645" }
-  }
-}