hydra-python 0.17.4__tar.gz → 0.17.5__tar.gz

{hydra_python-0.17.4 → hydra_python-0.17.5}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: hydra-python
-Version: 0.17.4
+Version: 0.17.5
 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.4
+Requires-Dist: hydra-kernel==0.17.5
 Description-Content-Type: text/markdown
 
 # Hydra-Python

{hydra_python-0.17.4 → hydra_python-0.17.5}/build/main/digest.json

@@ -1,20 +1,20 @@
 {
   "digestFormatVersion": 2,
   "moduleFormatVersion": 1,
-  "generator": "2c0ecf5e44272577",
+  "generator": "9de7bd43d8cafa93",
   "generation": {
-    "generatorId": "2c0ecf5e44272577",
+    "generatorId": "9de7bd43d8cafa93",
     "mode": "published",
     "host": "python",
-    "hydraVersion": "0.17.3",
-    "revision": "39f38e98ce",
-    "timestamp": "2026-08-10T00:06:14Z"},
-  "selfHash": "979ad9fa2784665ae8639c0a37ac80ed296d12c8524c0766c21cd7a8802e2965",
-  "dependencyHashes": [{"key": "hydra-kernel", "value": "2af6a4dff2fbf02f4859ca5f0c222c44c9ab9ce5345d26abcf7c6e39f90b5bcb"}],
+    "hydraVersion": "0.17.4",
+    "revision": "9571823830-dirty",
+    "timestamp": "2026-08-19T17:44:59Z"},
+  "selfHash": "f628802be436ebb317632a9429323b63f0ae5045bda0ba24aa263ccf2092e014",
+  "dependencyHashes": [{"key": "hydra-kernel", "value": "5b5813a6dabbc89ed0e4ddd918744636da84f3542d7961284c423aea53629b02"}],
   "inputs": [
     {
       "key": "hydra.python.coder",
-      "value": {"kind": "other", "hash": "33c5deb31968c9c0d41834301852b38d617cdcf7453d0115b75e693c8683401a"}},
+      "value": {"kind": "other", "hash": "0b1e385015be90731b3a461486eec1c2ab2448e1643f3a9e4f1f7427ec0e085a"}},
     {
       "key": "hydra.python.environment",
       "value": {"kind": "other", "hash": "663b02271ddd4a6ad9ab8a2bdc152a64802a675a59280909f605d6dedcc4017e"}},
@@ -23,22 +23,22 @@
       "value": {"kind": "other", "hash": "78fb867a1d0fa6654f46f5d9fd72c2c5607d2934b7c7fbd5f5d830786b4ad91e"}},
     {
       "key": "hydra.python.names",
-      "value": {"kind": "other", "hash": "87bfa00de69547fcb4a14b69a56be98d3f612dcd52b76063153365c375ce91e4"}},
+      "value": {"kind": "other", "hash": "5bc2e53c63d41de79877fbe331aada2c7f43175b09d4245b7ac61cf8261b0ca3"}},
     {
       "key": "hydra.python.pyproject",
       "value": {"kind": "other", "hash": "249512648b2b008db234ee348a72056d4d625cfeb0a80d8caacbda95002569a2"}},
     {
       "key": "hydra.python.serde",
-      "value": {"kind": "other", "hash": "9285fa0296e940da1de51a53465598455c46404851aefc2ce15220fc6ee7efc6"}},
+      "value": {"kind": "other", "hash": "83e48906bdec70d3d0d427c0e1b02b5e4d08bb172d3f85be13992ef4c1120859"}},
     {
       "key": "hydra.python.syntax",
       "value": {"kind": "other", "hash": "88a9154b48fd429f06efa0ba8981bdf12af3fed4de5a057b3304fadc623dbc19"}},
     {
       "key": "hydra.python.testing",
-      "value": {"kind": "other", "hash": "a40b949c594c81f8925ba423a89e46964b2b1475d44a486aa07c792c2c7f807b"}},
+      "value": {"kind": "other", "hash": "113853c870177388fbcc53800768d872fae34fdbfd1a0e2f30d2b2aefb966451"}},
     {
       "key": "hydra.python.utils",
-      "value": {"kind": "other", "hash": "b026355e1174d4573e14ee1a932a17e1d28cef3559f2f85a330d279b543598a3"}},
+      "value": {"kind": "other", "hash": "f480bc8a4c39e62ea073357517964a2175e582fd220de0fbc1bc27b9b108d327"}},
     {
       "key": "jsonContent:hydra/dsl/python/environment.json",
       "value": {"kind": "other", "hash": "684965cea67ad57d492b50f408c6575f679b073c5de5e76826fb0941da86ec21"}},
@@ -53,7 +53,7 @@
       "value": {"kind": "other", "hash": "7a3b84d522c420db0db03a77f9e54635b33544f73eb49ed67cdc3a4d5dac04ae"}},
     {
       "key": "jsonContent:hydra/python/coder.json",
-      "value": {"kind": "other", "hash": "ec4263eccf7a8dd826d44cea6aa4fc112cf7a6eda6c4d1ffd54cda0387e60729"}},
+      "value": {"kind": "other", "hash": "e2f66b5c16393d8050923aab1f832f430334e4bddfc101f4cebc1f158daee01d"}},
     {
       "key": "jsonContent:hydra/python/environment.json",
       "value": {"kind": "other", "hash": "889380dd3664c763437475b2e5146b38f865f4a20a308332633a33a4d038fce1"}},
@@ -62,13 +62,13 @@
       "value": {"kind": "other", "hash": "221e68d68030945db181fdd079be4ff619cb4cd1ad5d4b72b4e70f2aa1bd5230"}},
     {
       "key": "jsonContent:hydra/python/names.json",
-      "value": {"kind": "other", "hash": "7af58464067c990f8acdeb9399a217ee8b345e712927619b163eb18a1fd18a4a"}},
+      "value": {"kind": "other", "hash": "afaa99c99874efa5e02a10973651a7a74ab1089feedb9de0f8a74904a8ec4eb7"}},
     {
       "key": "jsonContent:hydra/python/pyproject.json",
       "value": {"kind": "other", "hash": "c94de46f1615e6e82d2f706d01ef04293373f6241a9a42882bb394d51b4f7f53"}},
     {
       "key": "jsonContent:hydra/python/serde.json",
-      "value": {"kind": "other", "hash": "648d34f63d2336972d5e0a59d4871332a07bd35c88eb38c28236e16a7fd48601"}},
+      "value": {"kind": "other", "hash": "e987b94392abfc72cedc08d2e6b8a4528479a9023c9eff636f8980e9af6e6cfb"}},
     {
       "key": "jsonContent:hydra/python/syntax.json",
       "value": {"kind": "other", "hash": "8dc3a26ac927fa338b273c9deee6317906977a2deec4c2df1e44ff0bbe0a64cd"}},
@@ -77,7 +77,7 @@
       "value": {"kind": "other", "hash": "9c75b534004194396935b1dd3331bae4d8d5cbb31c3959fa3794dda00960c09a"}},
     {
       "key": "jsonContent:hydra/python/utils.json",
-      "value": {"kind": "other", "hash": "9fe5863fa3b3fb7b87b97041336ac5ff947f69e9bc7a8c2667f0bfc217bed724"}},
+      "value": {"kind": "other", "hash": "0ef54f39243803add5f5634d67bf8c949d89159b3fc1c4ff82d9cb0bf829f4b9"}},
     {
       "key": "jsonContent:manifest.json",
       "value": {"kind": "other", "hash": "3f94b521766d042381d7bee84596308ea4e35c7e8fb45f8fd8338a8dbe27a0ac"}}],
@@ -96,7 +96,7 @@
       "value": {"kind": "targetFile", "hash": "3fed9996a3f875a53675b6c8620884949adf7d155b0e68cacfba9007d5d07b29"}},
     {
       "key": "hydra/python/coder.py",
-      "value": {"kind": "targetFile", "hash": "5dc0e92942be490ab049f187918a038b39c40ded8975445966c626eae6f32753"}},
+      "value": {"kind": "targetFile", "hash": "eb662817f2e3390220a06eb6eda9cc7adce67d3e22b47f3e2823ab273d688af6"}},
     {
       "key": "hydra/python/environment.py",
       "value": {"kind": "targetFile", "hash": "1036eb9d285ba3e98c85095820f2e77900334340c9f0223fd4dfd6b3e847f4df"}},
@@ -105,13 +105,13 @@
       "value": {"kind": "targetFile", "hash": "7ea0c3a6015ec1de92aebeed0963c1af9f3b70c8d57815e477c528c795383604"}},
     {
       "key": "hydra/python/names.py",
-      "value": {"kind": "targetFile", "hash": "13c7f477a13848ed7636bf773aac098599466964c2db5c35472f53b1152b05a2"}},
+      "value": {"kind": "targetFile", "hash": "3e8498f205a99ebfaa570a44ccac515b69ced9d7f3669a32f74d4d05d48204b6"}},
     {
       "key": "hydra/python/pyproject.py",
       "value": {"kind": "targetFile", "hash": "1f9001d8d2273d4783105e099b874c273ce520b58456f9b447cb8d5e9a6a37d7"}},
     {
       "key": "hydra/python/serde.py",
-      "value": {"kind": "targetFile", "hash": "43864d35b843e14c2ee78fc5ee22e88f61d049ace6d9e951d34dbdfa242662f9"}},
+      "value": {"kind": "targetFile", "hash": "a783457c64ea85769cd2ab757bd429be4d0c7333ab5765b0c04f3b0bf86b1e80"}},
     {
       "key": "hydra/python/syntax.py",
       "value": {"kind": "targetFile", "hash": "24a72af882b47d80cc930f16f51a3e9c1a71c9d8da47a921829f40e847459fca"}},
@@ -120,4 +120,4 @@
       "value": {"kind": "targetFile", "hash": "069c706253e0c41695c8becd42c27c84b7f6ac54b14be14975757ff09416ba92"}},
     {
       "key": "hydra/python/utils.py",
-      "value": {"kind": "targetFile", "hash": "7264b5ca536314e0523ccf46f069ab06dea099d68b2c3459d58ab2c989dc51c6"}}]}
+      "value": {"kind": "targetFile", "hash": "b53dbe52de14f67d6a3c74d8f6bd7051fbaa65dbf686362565bb5cda61f15075"}}]}

{hydra_python-0.17.4 → hydra_python-0.17.5}/pyproject.toml

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

{hydra_python-0.17.4 → hydra_python-0.17.5}/src/main/python/hydra/python/coder.py

@@ -339,7 +339,7 @@ def deduplicate_case_variables(cases_: Sequence[hydra.core.CaseAlternative]) ->
                 v = lam.parameter
                 mdom = lam.domain
                 body = lam.body
-                return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(v, count_by_name()),
+                return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.maps.lookup(v, count_by_name()),
                 (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))),
@@ -892,7 +892,7 @@ def make_simple_lambda(arity: int, lhs: hydra.python.syntax.Expression) -> hydra
     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.concat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
-    hydra.overlay.python.lib.math.range_(1, arity))))
+    hydra.overlay.python.lib.math.range_(1, hydra.overlay.python.lib.math.add(arity, 1)))))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(arity, 0),
     (lambda : lhs),
     (lambda : cast(hydra.python.syntax.Expression,
@@ -948,7 +948,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(args)),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.member(name, inline_vars),
     (lambda : Right(as_lazy_call())),
-    (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_primitive(g(), name),
+    (lambda : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_primitive(g(), name),
     (lambda : Right(as_function_call())),
     (lambda prim: (
       prim_arity := Lazy((lambda : hydra.arity.primitive_arity(prim))),
@@ -958,7 +958,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
         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.concat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
-          hydra.overlay.python.lib.math.range_(1, num_remaining.get())))),
+          hydra.overlay.python.lib.math.range_(1, hydra.overlay.python.lib.math.add(num_remaining.get(), 1))))),
           (
             remaining_exprs := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda n: 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,
@@ -981,20 +981,20 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
                 full_call := Lazy((lambda : hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.names.encode_name(True, hydra.util.CaseConvention.LOWER_SNAKE, env, name)),
                 all_args.get()))),
                 Right(make_uncurried_lambda(remaining_params.get(), full_call.get())))[1])[1])[1])[1])[1])))[1]))))),
-    (lambda : hydra.overlay.python.lib.optionals.cases(m_typ(),
+    (lambda : hydra.overlay.python.lib.optionals.match(m_typ(),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.member(name, tc_lambda_vars),
     (lambda : Right(as_variable())),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.member(name, inline_vars),
     (lambda : Right(lazy_dot_get(as_variable()))),
-    (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_primitive(g(), name),
-    (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 : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_primitive(g(), name),
+    (lambda : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_binding(g(), name),
+    (lambda : hydra.overlay.python.lib.optionals.match(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.concat2("Unknown variable: ", name.value)))))),
     (lambda _: Right(as_function_call())))),
     (lambda el: (
       el_trivial1 := Lazy((lambda : hydra.predicates.is_trivial_term(el.term))),
-      hydra.overlay.python.lib.optionals.cases(el.type_scheme,
+      hydra.overlay.python.lib.optionals.match(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)),
@@ -1027,7 +1027,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
         (lambda : unwrapped.get())))),
         Right(as_function_ref.get()))[1])[1]),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.maps.member(name, tc_metadata)),
-    (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_binding(g(), name),
+    (lambda : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_binding(g(), name),
     (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))),
       (lambda : make_simple_lambda(hydra.arity.type_arity(typ), as_variable())),
@@ -1035,7 +1035,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       Right(as_function_ref.get()))[1]),
     (lambda el: (
       el_trivial := Lazy((lambda : hydra.predicates.is_trivial_term(el.term))),
-      hydra.overlay.python.lib.optionals.cases(el.type_scheme,
+      hydra.overlay.python.lib.optionals.match(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 : Right(as_function_call())),
@@ -1128,7 +1128,7 @@ v3: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
 def lazy_flags_for_primitive(g: hydra.graph.Graph, name: hydra.core.Name) -> Sequence[bool]:
     r"""Per-parameter isLazy flags of a primitive (by name), or empty if not a primitive. Single source of truth for which arguments coders thunk; replaces hard-coded name tables (issue #391)."""
 
-    return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, g.primitives),
+    return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.maps.lookup(name, g.primitives),
     (lambda : ConsList.of()),
     (lambda prim: (
       def0 := Lazy((lambda : prim.definition)),
@@ -1164,9 +1164,9 @@ def term_arity_with_primitives(graph: hydra.graph.Graph, term: hydra.core.Term)
             return 1
 
         case hydra.core.TermVariable(value=name):
-            return hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_binding(graph, name),
+            return hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_binding(graph, name),
             (lambda : 0),
-            (lambda el: hydra.overlay.python.lib.optionals.cases(el.type_scheme, (lambda : hydra.arity.term_arity(el.term)), (lambda ts: hydra.arity.type_scheme_arity(ts)))))
+            (lambda el: hydra.overlay.python.lib.optionals.match(el.type_scheme, (lambda : hydra.arity.term_arity(el.term)), (lambda ts: hydra.arity.type_scheme_arity(ts)))))
 
         case _:
             return 0
@@ -1236,10 +1236,10 @@ rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, t
             g = Lazy((lambda : python_environment_get_graph(env)))
             all_args = Lazy((lambda : hydra.overlay.python.lib.lists.concat2(hargs, rargs)))
             inline_vars = env.inline_variables
-            return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, g().primitives),
-            (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_binding(g(), name),
+            return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.maps.lookup(name, g().primitives),
+            (lambda : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_binding(g(), name),
             (lambda : hydra.overlay.python.lib.eithers.bind(encode_variable(cx, env, name, hargs), (lambda expr: Right((expr, rargs))))),
-            (lambda el: hydra.overlay.python.lib.optionals.cases(el.type_scheme,
+            (lambda el: hydra.overlay.python.lib.optionals.match(el.type_scheme,
             (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))),
@@ -1282,7 +1282,7 @@ binding: hydra.core.Binding) -> Either[hydra.errors.Error, hydra.python.syntax.N
       is_trivial := Lazy((lambda : hydra.predicates.is_trivial_term(term))),
       needs_thunk := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(is_trivial.get(),
       (lambda : False),
-      (lambda : hydra.overlay.python.lib.optionals.cases(mts,
+      (lambda : hydra.overlay.python.lib.optionals.match(mts,
       (lambda : hydra.overlay.python.lib.logic.and_(allow_thunking, hydra.overlay.python.lib.logic.or_(is_complex_var.get(), term_is_complex.get()))),
       (lambda ts: hydra.overlay.python.lib.logic.and_(allow_thunking,
       hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.arity.type_scheme_arity(ts), 0),
@@ -1451,7 +1451,7 @@ def encode_term_inline(cx: hydra.typing.InferenceContext, env: hydra.python.envi
               Right(hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(pmap_of_entries.get()), tuple_pairs)))[1]))
 
         case hydra.core.TermOptional(value=mt):
-            return hydra.overlay.python.lib.optionals.cases(mt,
+            return hydra.overlay.python.lib.optionals.match(mt,
             (lambda : Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("None_")), ConsList.of()))),
             (lambda t1: hydra.overlay.python.lib.eithers.bind(encode(t1),
             (lambda pyexp: with_cast(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("Given")), ConsList.of(pyexp)))))))
@@ -1495,7 +1495,7 @@ def encode_term_inline(cx: hydra.typing.InferenceContext, env: hydra.python.envi
             (lambda : (
               fname := Lazy((lambda : field.name)),
               (
-                is_unit_variant := Lazy((lambda : hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.find((lambda ft: hydra.overlay.python.lib.equality.equal(ft.name.value, fname.get().value)), rt),
+                is_unit_variant := Lazy((lambda : hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.lists.find((lambda ft: hydra.overlay.python.lib.equality.equal(ft.name.value, fname.get().value)), rt),
                 (lambda : False),
                 (lambda ft: hydra.predicates.is_unit_type(hydra.strip.deannotate_type(ft.type)))))),
                 hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.or_(hydra.predicates.is_unit_term(field.term), is_unit_variant.get()),
@@ -1535,7 +1535,7 @@ py_arg: hydra.python.syntax.Expression) -> Either[hydra.errors.Error, hydra.pyth
       is_enum := Lazy((lambda : hydra.predicates.is_enum_row_type(rt))),
       value_expr := Lazy((lambda : hydra.python.utils.project_from_expression(py_arg, hydra.python.syntax.Name("value")))),
       isinstance_primary := Lazy((lambda : hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("isinstance")))),
-      hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.cases(mdefault,
+      hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.match(mdefault,
       (lambda : Right(unsupported_expression("no matching case in inline union elimination"))),
       (lambda dflt: encode_term_inline(cx, env, False, dflt))),
       (lambda py_default: (
@@ -1580,7 +1580,7 @@ mdflt: Optional[T0],
 tname: hydra.core.Name) -> Either[T1, Sequence[hydra.python.syntax.CaseBlock]]:
     r"""Encode the default (wildcard) case block for a match statement."""
 
-    return hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.cases(mdflt,
+    return hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.match(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.concat2("Unsupported ", hydra.names.local_name_of(tname))))))),
@@ -1754,7 +1754,7 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
     term1 = binding.term
     mts = binding.type_scheme
     fname = Lazy((lambda : hydra.python.names.encode_name(True, hydra.util.CaseConvention.LOWER_SNAKE, env, name1)))
-    return hydra.overlay.python.lib.optionals.cases(mts,
+    return hydra.overlay.python.lib.optionals.match(mts,
     (lambda : (
       gathered := Lazy((lambda : gather_lambdas(term1))),
       (
@@ -1763,12 +1763,12 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
           inner_body := Lazy((lambda : hydra.overlay.python.lib.pairs.second(gathered.get()))),
           (
             mcsa := Lazy((lambda : is_case_statement_application(inner_body.get()))),
-            hydra.overlay.python.lib.optionals.cases(mcsa.get(),
+            hydra.overlay.python.lib.optionals.match(mcsa.get(),
             (lambda : (
               mcs := Lazy((lambda : extract_case_elimination(term1))),
-              hydra.overlay.python.lib.optionals.cases(mcs.get(),
+              hydra.overlay.python.lib.optionals.match(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.head(stmts),
+              (lambda stmts: hydra.overlay.python.lib.optionals.match(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: (
@@ -1802,9 +1802,9 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
             (lambda csa: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(lambda_params.get()),
             (lambda : (
               mcs := Lazy((lambda : extract_case_elimination(term1))),
-              hydra.overlay.python.lib.optionals.cases(mcs.get(),
+              hydra.overlay.python.lib.optionals.match(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.head(stmts),
+              (lambda stmts: hydra.overlay.python.lib.optionals.match(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: (
@@ -2002,7 +2002,7 @@ prefixes: Sequence[hydra.python.syntax.Statement]) -> Either[hydra.errors.Error,
         Right(hydra.python.utils.indented_block(comment, ConsList.of(ConsList.of(while_stmt.get())))))[3]))),
       (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_multiline(cx, env, body),
       (lambda stmts: Right(hydra.python.utils.indented_block(comment, ConsList.of(hydra.overlay.python.lib.lists.concat2(prefixes, stmts)))))))),
-      (lambda block: hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.cases(mcod,
+      (lambda block: hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.match(mcod,
       (lambda : Right(None_())),
       (lambda cod: hydra.overlay.python.lib.eithers.bind(encode_type(env, cod), (lambda pytyp: Right(Given(pytyp)))))),
       (lambda mreturn_type: (
@@ -2205,7 +2205,7 @@ comment: Optional[str]) -> Either[hydra.errors.Error, hydra.python.syntax.Statem
       bound_vars := Lazy((lambda : env.bound_type_variables)),
       tparam_list := Lazy((lambda : hydra.overlay.python.lib.pairs.first(bound_vars.get()))),
       m_generic_arg := Lazy((lambda : generic_arg(tparam_list.get()))),
-      args := Lazy((lambda : hydra.overlay.python.lib.optionals.cases(m_generic_arg.get(), (lambda : None_()), (lambda a: Given(hydra.python.utils.py_expressions_to_py_args(ConsList.of(a))))))),
+      args := Lazy((lambda : hydra.overlay.python.lib.optionals.match(m_generic_arg.get(), (lambda : None_()), (lambda a: Given(hydra.python.utils.py_expressions_to_py_args(ConsList.of(a))))))),
       decs := Lazy((lambda : Given(hydra.python.syntax.Decorators(ConsList.of(dataclass_decorator()))))),
       py_name := Lazy((lambda : hydra.python.names.encode_name(False, hydra.util.CaseConvention.PASCAL, env, name))),
       no_type_params := Lazy((lambda : ConsList.of())),
@@ -2253,7 +2253,7 @@ def encode_enum_value_assignment(cx: T0, env: hydra.python.environment.PythonEnv
       py_value := Lazy((lambda : hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.names.encode_name(True, hydra.util.CaseConvention.PASCAL, env, hydra.core.Name("hydra.core.Name"))),
       ConsList.of(hydra.python.utils.double_quoted_string(fname_str.get()))))),
       assign_stmt := Lazy((lambda : hydra.python.utils.assignment_statement(py_name.get(), py_value.get()))),
-      Right(hydra.overlay.python.lib.optionals.cases(mcomment,
+      Right(hydra.overlay.python.lib.optionals.match(mcomment,
       (lambda : ConsList.of(assign_stmt.get())),
       (lambda c: ConsList.of(assign_stmt.get(), hydra.python.utils.py_expression_to_py_statement(hydra.python.utils.triple_quoted_string(c)))))))[4]))
 
@@ -2447,7 +2447,7 @@ def encode_definition(cx: hydra.typing.InferenceContext, env: hydra.python.envir
         case hydra.packaging.DefinitionTerm(value=td):
             name = td.name
             term = td.body
-            typ = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(td.signature,
+            typ = Lazy((lambda : hydra.overlay.python.lib.optionals.match(td.signature,
             (lambda : hydra.core.TypeScheme(ConsList.of(), cast(hydra.core.Type, hydra.core.TypeVariable(hydra.core.Name("hydra.core.Unit"))), None_())),
             (lambda sig: hydra.scoping.term_signature_to_type_scheme(sig)))))
             return hydra.overlay.python.lib.eithers.bind(hydra.annotations.get_term_description(cx, python_environment_get_graph(env), term),
@@ -2989,14 +2989,14 @@ def extend_meta_for_term(top_level: bool, meta0: hydra.python.environment.Python
                 return hydra.overlay.python.lib.eithers.either((lambda _: set_meta_uses_left(meta_with_cast(), True)), (lambda _: set_meta_uses_right(meta_with_cast(), True)), e)
 
             case hydra.core.TermLambda(value=lam):
-                return hydra.overlay.python.lib.optionals.cases(lam.domain,
+                return hydra.overlay.python.lib.optionals.match(lam.domain,
                 (lambda : meta),
                 (lambda dom: hydra.overlay.python.lib.logic.if_else(top_level, (lambda : extend_meta_for_type(True, False, dom, meta)), (lambda : meta))))
 
             case hydra.core.TermLet(value=lt):
                 bindings = lt.bindings
                 return hydra.overlay.python.lib.lists.foldl((
-                  for_binding := Lazy((lambda : (lambda m, b: hydra.overlay.python.lib.optionals.cases(b.type_scheme,
+                  for_binding := Lazy((lambda : (lambda m, b: hydra.overlay.python.lib.optionals.match(b.type_scheme,
                   (lambda : m),
                   (lambda ts: (
                     term1 := Lazy((lambda : b.term)),
@@ -3018,7 +3018,7 @@ def extend_meta_for_term(top_level: bool, meta0: hydra.python.environment.Python
                 return set_meta_uses_frozen_set(meta, True)
 
             case hydra.core.TermOptional(value=m):
-                return hydra.overlay.python.lib.optionals.cases(m, (lambda : set_meta_uses_nothing(meta, True)), (lambda _: set_meta_uses_just(meta, True)))
+                return hydra.overlay.python.lib.optionals.match(m, (lambda : set_meta_uses_nothing(meta, True)), (lambda _: set_meta_uses_just(meta, True)))
 
             case hydra.core.TermInject():
                 return set_meta_uses_cast(True, meta)
@@ -3110,7 +3110,7 @@ def gather_metadata(overlay_subs: Set[str], focus_ns: hydra.packaging.ModuleName
         match def_:
             case hydra.packaging.DefinitionTerm(value=term_def):
                 term = term_def.body
-                typ = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(term_def.signature,
+                typ = Lazy((lambda : hydra.overlay.python.lib.optionals.match(term_def.signature,
                 (lambda : cast(hydra.core.Type, hydra.core.TypeVariable(hydra.core.Name("hydra.core.Unit")))),
                 (lambda sig: hydra.scoping.term_signature_to_type_scheme(sig).body))))
                 meta2 = Lazy((lambda : extend_meta_for_type(True, True, typ(), meta)))
@@ -3309,7 +3309,7 @@ defs0: Sequence[hydra.packaging.Definition]) -> Either[hydra.errors.Error, hydra
       (lambda : set_meta_uses_type_alias(meta2.get(), True)),
       (lambda : meta2.get())))),
       namespaces := Lazy((lambda : meta0().namespaces)),
-      comment_stmts := Lazy((lambda : hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.optionals.map(hydra.formatting.normalize_comment, hydra.overlay.python.lib.optionals.bind(mod.metadata, (lambda em: em.description))),
+      comment_stmts := Lazy((lambda : hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.optionals.map(hydra.formatting.normalize_comment, hydra.overlay.python.lib.optionals.bind(mod.metadata, (lambda em: em.description))),
       (lambda : ConsList.of()),
       (lambda c: ConsList.of(hydra.python.utils.comment_statement(c)))))),
       import_stmts := Lazy((lambda : module_imports(namespaces.get(), meta.get()))),

{hydra_python-0.17.4 → hydra_python-0.17.5}/src/main/python/hydra/python/names.py

@@ -50,7 +50,7 @@ def overlay_python_module_aliases() -> Mapping[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.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),
+    return hydra.overlay.python.lib.optionals.match(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))),
@@ -89,10 +89,10 @@ name: hydra.core.Name) -> hydra.python.syntax.Name:
     def py_ns(ns_val: hydra.packaging.ModuleName) -> str:
         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.optionals.match(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 : py_local()), (lambda : hydra.python.serde.escape_python_string(True, py_local()))))),
-    (lambda : hydra.overlay.python.lib.optionals.cases(mns,
+    (lambda : hydra.overlay.python.lib.optionals.match(mns,
     (lambda : hydra.python.syntax.Name(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))),
@@ -120,10 +120,10 @@ def encode_name_qualified(env: hydra.python.environment.PythonEnvironment, name:
     local = qual_name().local
     def py_ns(ns_val: hydra.packaging.ModuleName) -> str:
         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()),
+    return hydra.overlay.python.lib.optionals.match(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))))),
-    (lambda : hydra.overlay.python.lib.optionals.cases(mns,
+    (lambda : hydra.overlay.python.lib.optionals.match(mns,
     (lambda : hydra.python.syntax.Name(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))
@@ -167,7 +167,7 @@ def variable_reference(conv: hydra.util.CaseConvention, quoted: bool, env: hydra
     focus_pair = Lazy((lambda : namespaces.focus))
     focus_ns = Lazy((lambda : hydra.overlay.python.lib.pairs.first(focus_pair())))
     mns = Lazy((lambda : hydra.names.module_name_of(name)))
-    same_namespace = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(mns(), (lambda : False), (lambda ns: hydra.overlay.python.lib.equality.equal(ns, focus_ns())))))
+    same_namespace = Lazy((lambda : hydra.overlay.python.lib.optionals.match(mns(), (lambda : False), (lambda ns: hydra.overlay.python.lib.equality.equal(ns, focus_ns())))))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(quoted, same_namespace()),
     (lambda : 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,

{hydra_python-0.17.4 → hydra_python-0.17.5}/src/main/python/hydra/python/serde.py

@@ -10,6 +10,7 @@ from hydra.overlay.python.util import ConsList, Lazy
 from typing import cast
 import hydra.constants
 import hydra.core
+import hydra.formatting
 import hydra.names
 import hydra.overlay.python.lib.equality
 import hydra.overlay.python.lib.lists
@@ -136,7 +137,7 @@ def string_to_expr(s: hydra.python.syntax.String) -> hydra.ast.Expr:
     r"""Serialize a Python string literal."""
 
     content = s.value
-    prefix = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(s.prefix, (lambda : ""), (lambda x1: string_prefix_to_text(x1)))))
+    prefix = Lazy((lambda : hydra.overlay.python.lib.optionals.match(s.prefix, (lambda : ""), (lambda x1: string_prefix_to_text(x1)))))
     style = s.quote_style
     match style:
         case hydra.python.syntax.QuoteStyle.SINGLE:
@@ -759,7 +760,7 @@ def import_from_as_name_to_expr(ifan: hydra.python.syntax.ImportFromAsName) -> h
 
     name = ifan.name
     alias = ifan.as_
-    return hydra.overlay.python.lib.optionals.cases(alias,
+    return hydra.overlay.python.lib.optionals.match(alias,
     (lambda : name_to_expr(name)),
     (lambda a: hydra.serialization.space_sep(ConsList.of(name_to_expr(name), hydra.serialization.cst("as"), name_to_expr(a)))))
 
@@ -1157,7 +1158,7 @@ def to_python_comments(doc_: str) -> str:
     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_))))))
+    hydra.formatting.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)."""

{hydra_python-0.17.4 → hydra_python-0.17.5}/src/main/python/hydra/python/utils.py

@@ -113,14 +113,14 @@ def py_name_to_py_primary(name: hydra.python.syntax.Name) -> hydra.python.syntax
 def annotated_expression(mcomment: Optional[str], expr: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
     r"""Annotate an expression with an optional comment using Annotated[]."""
 
-    return hydra.overlay.python.lib.optionals.cases(mcomment,
+    return hydra.overlay.python.lib.optionals.match(mcomment,
     (lambda : expr),
     (lambda c: py_primary_to_py_expression(primary_with_expression_slices(py_name_to_py_primary(hydra.python.syntax.Name("Annotated")), ConsList.of(expr, double_quoted_string(c))))))
 
 def annotated_statement(mcomment: Optional[str], stmt: hydra.python.syntax.Statement) -> hydra.python.syntax.Statement:
     r"""Annotate a statement with an optional comment."""
 
-    return hydra.overlay.python.lib.optionals.cases(mcomment,
+    return hydra.overlay.python.lib.optionals.match(mcomment,
     (lambda : stmt),
     (lambda c: cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementAnnotated(hydra.python.syntax.AnnotatedStatement(c, stmt)))))
 
@@ -306,7 +306,7 @@ def get_item_params() -> hydra.python.syntax.Parameters:
 def indented_block(mcomment: Optional[str], stmts: Sequence[Sequence[hydra.python.syntax.Statement]]) -> hydra.python.syntax.Block:
     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))))))
+    comment_group = Lazy((lambda : hydra.overlay.python.lib.optionals.match(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))))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(groups()),
@@ -354,7 +354,7 @@ def or_expression(prims: Sequence[hydra.python.syntax.Primary]) -> hydra.python.
     r"""Build an or-expression from multiple primaries."""
 
     def build(prev: Optional[hydra.python.syntax.BitwiseOr], ps: Sequence[hydra.python.syntax.Primary]) -> hydra.python.syntax.BitwiseOr:
-        return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.uncons(ps),
+        return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.lists.uncons(ps),
         (lambda : hydra.python.syntax.BitwiseOr(prev,
         py_primary_to_py_bitwise_xor(cast(hydra.python.syntax.Primary,
         hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomEllipsis())))))),
@@ -419,7 +419,7 @@ def py_expression_to_disjunction(e: hydra.python.syntax.Expression) -> hydra.pyt
 def py_expression_to_py_primary(e: hydra.python.syntax.Expression) -> hydra.python.syntax.Primary:
     r"""Extracts the primary from an expression, or wraps it in parentheses if the expression does not contain a primary."""
 
-    return hydra.overlay.python.lib.optionals.cases(decode_py_expression_to_py_primary(e),
+    return hydra.overlay.python.lib.optionals.match(decode_py_expression_to_py_primary(e),
     (lambda : cast(hydra.python.syntax.Primary,
     hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom,
     hydra.python.syntax.AtomGroup(cast(hydra.python.syntax.Group,