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

{hydra_python-0.17.5 → hydra_python-0.17.7}/.gitignore

@@ -150,3 +150,6 @@ claude/.*.sh
 
 # Backed-up branch plan documents (not release content)
 finalized-task-plans/
+
+# Coordination-hook state: last surfaced coordination-branch SHA (per worktree)
+.coordination-seen

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hydra-python
-Version: 0.17.5
+Version: 0.17.7
 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.5
+Requires-Dist: hydra-kernel==0.17.7
 Description-Content-Type: text/markdown
 
 # Hydra-Python
@@ -398,7 +398,7 @@ of kwargs + explicit `field()`.
 ```python
 @hydra_element(my_module, type_=T.function(T.int32(), T.string()))
 def show_number(x):
-    return Strings.show_int32(x)
+    return Strings.print_int32(x)
 ```
 
 Idiomatic Python metadata mechanism. Risk: users may expect the

{hydra_python-0.17.5 → hydra_python-0.17.7}/README.md

@@ -384,7 +384,7 @@ of kwargs + explicit `field()`.
 ```python
 @hydra_element(my_module, type_=T.function(T.int32(), T.string()))
 def show_number(x):
-    return Strings.show_int32(x)
+    return Strings.print_int32(x)
 ```
 
 Idiomatic Python metadata mechanism. Risk: users may expect the

hydra_python-0.17.7/build/main/digest.json

@@ -0,0 +1,276 @@
+{
+  "digestFormatVersion": 2,
+  "moduleFormatVersion": 1,
+  "generator": "7abcbab265fa1310",
+  "generation": {
+    "generatorId": "7abcbab265fa1310",
+    "mode": "published",
+    "host": "python",
+    "hydraVersion": "0.17.6",
+    "revision": "424d7c2260-dirty",
+    "timestamp": "2026-09-14T21:55:11Z"
+  },
+  "selfHash": "0736daac9936e0be4ec8f8e13bd081a5acb6d26caf193636363c966326e87aba",
+  "dependencyHashes": [
+    {
+      "key": "hydra-kernel",
+      "value": "9a236485c2eb5ac6a517d66ab064b143ae6439d323f9968a1670a4d690c594cf"
+    }
+  ],
+  "inputs": [
+    {
+      "key": "hydra.python.coder",
+      "value": {
+        "kind": "other",
+        "hash": "2dcd40ec0777229e853704eb332bfbbf9790b70534b5e47fb11fb9be4996d22c"
+      }
+    },
+    {
+      "key": "hydra.python.environment",
+      "value": {
+        "kind": "other",
+        "hash": "c9fcaea745fbec176e40ba1f5015539afccce08dd9d64357c092b00a74b0ead7"
+      }
+    },
+    {
+      "key": "hydra.python.language",
+      "value": {
+        "kind": "other",
+        "hash": "023abc0b7f14a46a8ce25a51434878a81aae06093abb0c4bdc56e284a886de0b"
+      }
+    },
+    {
+      "key": "hydra.python.names",
+      "value": {
+        "kind": "other",
+        "hash": "309082902048042e83e9518bdad597cfbdc001400e5f21db59dfa13bb9f35f57"
+      }
+    },
+    {
+      "key": "hydra.python.pyproject",
+      "value": {
+        "kind": "other",
+        "hash": "881be5b9c94d452c99cbe3478f0f0bef48ce0662aa9f9b2591ddff8fef21548b"
+      }
+    },
+    {
+      "key": "hydra.python.serde",
+      "value": {
+        "kind": "other",
+        "hash": "c2f329584d68b5d1eacac7a8336bce84bef18b2ec728edceea8cd59bc4cbb45c"
+      }
+    },
+    {
+      "key": "hydra.python.syntax",
+      "value": {
+        "kind": "other",
+        "hash": "e98016197157f4afaab53d70d18bbbb107951e241e6ef87dbaed78eb7645ffcc"
+      }
+    },
+    {
+      "key": "hydra.python.testing",
+      "value": {
+        "kind": "other",
+        "hash": "8ab02cc21789bdae2221b90bc5664e1617b8d8cf93adea1f619fee05526c9267"
+      }
+    },
+    {
+      "key": "hydra.python.utils",
+      "value": {
+        "kind": "other",
+        "hash": "12d519e0d4e915452b962c16e7e45ec98f444dcc1cb4ee22a2a6c489db17c377"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/dsl/python/environment.json",
+      "value": {
+        "kind": "other",
+        "hash": "c4915d2516067b18ce5b16a8464a47d5a59ba1376932e3987b6df607f7aebfd7"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/dsl/python/names.json",
+      "value": {
+        "kind": "other",
+        "hash": "d3adb9f3e1d12ac227bb5d702b09dc4ce5efe88d2defddd94ec4b123dbf90a36"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/dsl/python/syntax.json",
+      "value": {
+        "kind": "other",
+        "hash": "54bdb29075c43afb543364420ff57de57a9c20188ad6d3f91581181a466fd2fa"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/dsl/python/utils.json",
+      "value": {
+        "kind": "other",
+        "hash": "3314f432e6d4003d2afe84ff2b24ddb84e1589255dd8ef4a7774a5eff07bd84a"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/python/coder.json",
+      "value": {
+        "kind": "other",
+        "hash": "a2b430eceb6212d2c2d4185aa3ca961c8992a8eea0f2b45317ae632f00802947"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/python/environment.json",
+      "value": {
+        "kind": "other",
+        "hash": "ac3e37f8a17ae29d2ef98d7a3b2ce2eaba7eec1bde18caeb9a28e94162ea4d19"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/python/language.json",
+      "value": {
+        "kind": "other",
+        "hash": "657c83931d77ee5efd92b5e7fc25d50aef2ebbf14b834293af0f56a107b914ff"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/python/names.json",
+      "value": {
+        "kind": "other",
+        "hash": "15523ffcae2f183b2e1282cafa98a8fb7ffb063bf3be597200afa449392bf6e5"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/python/pyproject.json",
+      "value": {
+        "kind": "other",
+        "hash": "d2da2c56f2ef83033e3ec7e9e81db072413d4ea295c7884efcb4b10ab73d564e"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/python/serde.json",
+      "value": {
+        "kind": "other",
+        "hash": "4b39e1786bd38ceb73525956e73f5bdc24e7e2085ebcfc53682209de3057012e"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/python/syntax.json",
+      "value": {
+        "kind": "other",
+        "hash": "d6b15c193027c2f9cb381a4a8ecdb9541ce7f863b645d996923e7549c34796e0"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/python/testing.json",
+      "value": {
+        "kind": "other",
+        "hash": "f8564336b36351b02f733b8b6c132b842b42b8e908e31d18bd45e086d9c6abec"
+      }
+    },
+    {
+      "key": "jsonContent:hydra/python/utils.json",
+      "value": {
+        "kind": "other",
+        "hash": "619771b6c8cfa4ac80c27dedba674978470f5846c8575bb3c7b60a1661ce2df4"
+      }
+    },
+    {
+      "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": "faf969debba4f9484e9e758a0d0eef2ec5255a757b368b8c593adf9b567fa56b"
+      }
+    },
+    {
+      "key": "hydra/python/coder.py",
+      "value": {
+        "kind": "targetFile",
+        "hash": "b9e4d3a6b7975300ca9f51880df233283797d5dddee65fe2dbb23ba24fd23830"
+      }
+    },
+    {
+      "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": "3e8498f205a99ebfaa570a44ccac515b69ced9d7f3669a32f74d4d05d48204b6"
+      }
+    },
+    {
+      "key": "hydra/python/pyproject.py",
+      "value": {
+        "kind": "targetFile",
+        "hash": "1f9001d8d2273d4783105e099b874c273ce520b58456f9b447cb8d5e9a6a37d7"
+      }
+    },
+    {
+      "key": "hydra/python/serde.py",
+      "value": {
+        "kind": "targetFile",
+        "hash": "1f36ea2dc8c50df72abe464cd395689c71f0af70a9f78e68d26013f9b436c383"
+      }
+    },
+    {
+      "key": "hydra/python/syntax.py",
+      "value": {
+        "kind": "targetFile",
+        "hash": "24a72af882b47d80cc930f16f51a3e9c1a71c9d8da47a921829f40e847459fca"
+      }
+    },
+    {
+      "key": "hydra/python/testing.py",
+      "value": {
+        "kind": "targetFile",
+        "hash": "5c8f352d976eeeebf14974e9df208b53c8db59810fdbd76e6454868627122635"
+      }
+    },
+    {
+      "key": "hydra/python/utils.py",
+      "value": {
+        "kind": "targetFile",
+        "hash": "28508cfe1fa312c169c894bda18a920092fb8ce708d22f5bd76d7576527935e1"
+      }
+    }
+  ]
+}

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

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

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

@@ -59,6 +59,9 @@ def comment_statement(arg0: hydra.typed.TypedTerm[str]) -> hydra.typed.TypedTerm
     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.commentStatement"))), arg0.value))))
 
+# DSL reference to hydra.python.utils.decimalVariantMethods.
+decimal_variant_methods = hydra.typed.TypedTerm(cast(hydra.core.Term, hydra.core.TermVariable(hydra.core.Name("hydra.python.utils.decimalVariantMethods"))))
+
 def decode_py_comparison_to_py_await_primary(arg0: hydra.typed.TypedTerm[hydra.python.syntax.Comparison]) -> hydra.typed.TypedTerm[Optional[hydra.python.syntax.Primary]]:
     r"""DSL reference to hydra.python.utils.decodePyComparisonToPyAwaitPrimary."""
 

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

@@ -8,6 +8,7 @@ from decimal import Decimal
 from functools import lru_cache
 from hydra.overlay.python.dsl.python import Either, Given, Left, None_, Optional, Right
 from hydra.overlay.python.util import ConsList, Lazy, PersistentMap, PersistentSet
+from hydra.overlay.python.util._decimal import decimal_node_eq, decimal_node_hash
 from typing import TypeVar, cast
 import hydra.analysis
 import hydra.annotations
@@ -343,7 +344,7 @@ def deduplicate_case_variables(cases_: Sequence[hydra.core.CaseAlternative]) ->
                 (lambda : (hydra.overlay.python.lib.maps.insert(v, 1, count_by_name()), hydra.overlay.python.lib.lists.cons(field, done()))),
                 (lambda count: (
                   count2 := Lazy((lambda : hydra.overlay.python.lib.math.add(count, 1))),
-                  v2 := Lazy((lambda : hydra.core.Name(hydra.overlay.python.lib.strings.concat2(v.value, hydra.overlay.python.lib.literals.show_int32(count2.get()))))),
+                  v2 := Lazy((lambda : hydra.core.Name(hydra.overlay.python.lib.strings.concat2(v.value, hydra.overlay.python.lib.literals.print_int32(count2.get()))))),
                   new_body := Lazy((lambda : hydra.reduction.alpha_convert(v, v2.get(), body))),
                   new_lam := Lazy((lambda : hydra.core.Lambda(v2.get(), mdom, new_body.get()))),
                   new_term := Lazy((lambda : cast(hydra.core.Term, hydra.core.TermLambda(new_lam.get())))),
@@ -444,7 +445,7 @@ def encode_float_value_py_special_float(value: str) -> hydra.python.syntax.Expre
     ConsList.of(hydra.python.utils.single_quoted_string(value)))
 
 def encode_float_value_encode_float32(v: float) -> Either[T0, hydra.python.syntax.Expression]:
-    s = Lazy((lambda : hydra.overlay.python.lib.literals.show_float32(v)))
+    s = Lazy((lambda : hydra.overlay.python.lib.literals.print_float32(v)))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(s(), "NaN"),
     (lambda : Right(encode_float_value_py_special_float("nan"))),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(s(), "Infinity"),
@@ -455,7 +456,7 @@ def encode_float_value_encode_float32(v: float) -> Either[T0, hydra.python.synta
     hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberFloat(hydra.overlay.python.lib.literals.float32_to_float64(v)))))))))))))
 
 def encode_float_value_encode_float64(v: float) -> Either[T0, hydra.python.syntax.Expression]:
-    s = Lazy((lambda : hydra.overlay.python.lib.literals.show_float64(v)))
+    s = Lazy((lambda : hydra.overlay.python.lib.literals.print_float64(v)))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(s(), "NaN"),
     (lambda : Right(encode_float_value_py_special_float("nan"))),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(s(), "Infinity"),
@@ -538,7 +539,7 @@ def encode_literal(lit: hydra.core.Literal) -> Either[T0, hydra.python.syntax.Ex
 
         case hydra.core.LiteralDecimal(value=d):
             return Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("Decimal")),
-            ConsList.of(hydra.python.utils.single_quoted_string(hydra.overlay.python.lib.literals.show_decimal(d)))))
+            ConsList.of(hydra.python.utils.single_quoted_string(hydra.overlay.python.lib.literals.print_decimal(d)))))
 
         case hydra.core.LiteralFloat(value=f):
             return encode_float_value(f)
@@ -891,7 +892,7 @@ def lazy_dot_get(expr: hydra.python.syntax.Expression) -> hydra.python.syntax.Ex
 def make_simple_lambda(arity: int, lhs: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
     r"""Wrap a bare reference to a polymorphic function in an uncurried lambda."""
 
-    args = Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
+    args = Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.print_int32(i)))),
     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),
@@ -945,7 +946,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
     as_function_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)),
     args)))
     as_lazy_call = Lazy((lambda : hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(lazy_dot_get(as_variable())), args)))
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(args)),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(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.match(hydra.lexical.lookup_primitive(g(), name),
@@ -957,7 +958,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       (lambda : (
         num_remaining := Lazy((lambda : hydra.overlay.python.lib.math.sub(prim_arity.get(), hydra.overlay.python.lib.lists.length(args)))),
         (
-          remaining_params := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
+          remaining_params := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.print_int32(i)))),
           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,
@@ -1001,7 +1002,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       hydra.overlay.python.lib.logic.not_(el_trivial1.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.lists.null(ts.variables)),
+        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(ts.variables)),
         (lambda : make_simple_lambda(hydra.arity.type_arity(ts.body), as_variable())),
         (lambda : as_variable())))),
         Right(as_function_ref.get()))[1])))))[1]))),
@@ -1012,7 +1013,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       (lambda : (
         ts := Lazy((lambda : hydra.scoping.term_signature_to_type_scheme(prim.definition.signature))),
         (
-          as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(ts.get().variables)),
+          as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(ts.get().variables)),
           (lambda : make_simple_lambda(hydra.arity.type_arity(ts.get().body), as_variable())),
           (lambda : as_variable())))),
           Right(as_function_ref.get()))[1])[1])))[1]))))))),
@@ -1022,14 +1023,14 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
     (lambda : (
       unwrapped := Lazy((lambda : lazy_dot_get(as_variable()))),
       (
-        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))),
+        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
         (lambda : make_simple_lambda(hydra.arity.type_arity(typ), unwrapped.get())),
         (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.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))),
+      as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
       (lambda : make_simple_lambda(hydra.arity.type_arity(typ), as_variable())),
       (lambda : as_variable())))),
       Right(as_function_ref.get()))[1]),
@@ -1040,7 +1041,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       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))),
+        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
         (lambda : make_simple_lambda(hydra.arity.type_arity(typ), as_variable())),
         (lambda : as_variable())))),
         Right(as_function_ref.get()))[1]))),
@@ -1048,14 +1049,14 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       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))),
+        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
         (lambda : make_simple_lambda(hydra.arity.type_arity(typ), as_variable())),
         (lambda : as_variable())))),
         Right(as_function_ref.get()))[1])))))[1]))),
     (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.predicates.is_complex_variable(tc, name)),
     (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))),
+      as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
       (lambda : make_simple_lambda(hydra.arity.type_arity(typ), as_variable())),
       (lambda : as_variable())))),
       Right(as_function_ref.get()))[1]))))))))))))
@@ -1205,7 +1206,7 @@ rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, t
     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()),
+        return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(rest_args()),
         (lambda : e),
         (lambda : hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(e), rest_args())))
     default_case = Lazy((lambda : hydra.overlay.python.lib.eithers.bind(encode_term_inline(cx, env, False, fun),
@@ -1222,7 +1223,7 @@ rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, t
         case hydra.core.TermUnwrap():
             value_expr = Lazy((lambda : hydra.python.utils.project_from_expression(first_arg(), hydra.python.syntax.Name("value"))))
             all_args = Lazy((lambda : hydra.overlay.python.lib.lists.concat2(rest_args(), rargs)))
-            return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(all_args()),
+            return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(all_args()),
             (lambda : Right((value_expr(), ConsList.of()))),
             (lambda : Right((
               hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(value_expr()), all_args()),
@@ -1246,7 +1247,7 @@ rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, t
               consume_count := Lazy((lambda : hydra.overlay.python.lib.ordering.min(el_arity.get(), hydra.overlay.python.lib.lists.length(all_args())))),
               consumed_args := Lazy((lambda : hydra.overlay.python.lib.lists.take(consume_count.get(), all_args()))),
               remaining_args := Lazy((lambda : hydra.overlay.python.lib.lists.drop(consume_count.get(), all_args()))),
-              hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(consumed_args.get()),
+              hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(consumed_args.get()),
               (lambda : hydra.overlay.python.lib.eithers.bind(encode_variable(cx, env, name, ConsList.of()), (lambda expr: Right((expr, rargs))))),
               (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.member(name, inline_vars),
               (lambda : Right((
@@ -1350,7 +1351,7 @@ def encode_term_inline(cx: hydra.typing.InferenceContext, env: hydra.python.envi
               (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)),
                 params.get()))),
-                hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(bindings.get()),
+                hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(bindings.get()),
                 (lambda : Right(make_uncurried_lambda(pparams.get(), pbody))),
                 (lambda : hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map_list((lambda v1: encode_binding_as_assignment(cx, False, inner_env.get(), v1)), bindings.get()),
                 (lambda pbinding_exprs: (
@@ -1408,7 +1409,7 @@ def encode_term_inline(cx: hydra.typing.InferenceContext, env: hydra.python.envi
         case hydra.core.TermLet(value=lt):
             bindings = lt.bindings
             body = lt.body
-            return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(bindings),
+            return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(bindings),
             (lambda : encode_term_inline(cx, env, False, body)),
             (lambda : with_let_inline(env,
             lt,
@@ -1799,7 +1800,7 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
                     Right(cast(hydra.python.syntax.Statement,
                     hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement,
                     hydra.python.syntax.CompoundStatementFunction(hydra.python.syntax.FunctionDefinition(None_(), func_def_raw.get())))))))[5])))))[5])))[3])))[1]),
-            (lambda csa: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(lambda_params.get()),
+            (lambda csa: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(lambda_params.get()),
             (lambda : (
               mcs := Lazy((lambda : extract_case_elimination(term1))),
               hydra.overlay.python.lib.optionals.match(mcs.get(),
@@ -1909,7 +1910,7 @@ comment: Optional[str]) -> Either[hydra.errors.Error, hydra.python.syntax.Statem
       is_complex := Lazy((lambda : hydra.predicates.is_complex_binding(tc.get(), binding.get()))),
       is_trivial := Lazy((lambda : hydra.predicates.is_trivial_term(term))),
       hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(is_complex.get(), hydra.overlay.python.lib.logic.not_(is_trivial.get())),
-      (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(top_level), hydra.overlay.python.lib.lists.null(params.get())),
+      (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(top_level), hydra.overlay.python.lib.lists.is_empty(params.get())),
       (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_inline(cx, env2.get(), False, term),
       (lambda body_expr: (
         py_name := Lazy((lambda : hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env2.get(), name))),
@@ -1931,7 +1932,7 @@ def encode_term_multiline(cx: hydra.typing.InferenceContext, env: hydra.python.e
       bindings := Lazy((lambda : fs.bindings)),
       inner_body := Lazy((lambda : fs.body)),
       env2 := Lazy((lambda : fs.environment)),
-      hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(bindings.get()),
+      hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(bindings.get()),
       (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_inline(cx, env, False, term), (lambda expr: Right(ConsList.of(hydra.python.utils.return_single(expr)))))),
       (lambda : hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map_list((lambda v1: encode_binding_as(cx, env2.get(), v1)), bindings.get()),
       (lambda binding_stmts: hydra.overlay.python.lib.eithers.bind(encode_term_multiline(cx, env2.get(), inner_body.get()),
@@ -1988,7 +1989,7 @@ 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)),
+      is_t_c_o := Lazy((lambda : hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(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),
@@ -2009,7 +2010,7 @@ prefixes: Sequence[hydra.python.syntax.Statement]) -> Either[hydra.errors.Error,
         py_tparams := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(use_inline_type_params(),
         (lambda : hydra.overlay.python.lib.lists.map((lambda arg_: hydra.python.utils.py_name_to_py_type_parameter(hydra.python.names.encode_type_variable(arg_))), tparams)),
         (lambda : ConsList.of())))),
-        is_thunk := Lazy((lambda : hydra.overlay.python.lib.lists.null(args))),
+        is_thunk := Lazy((lambda : hydra.overlay.python.lib.lists.is_empty(args))),
         m_decorators := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(is_thunk.get(), (lambda : Given(hydra.python.syntax.Decorators(ConsList.of(lru_cache_decorator())))), (lambda : None_())))),
         py_name := Lazy((lambda : hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, name))),
         Right(cast(hydra.python.syntax.Statement,
@@ -2050,7 +2051,7 @@ def encode_name_constants(env: hydra.python.environment.PythonEnvironment, name:
 def generic_arg(tparam_list: Sequence[hydra.core.Name]) -> Optional[hydra.python.syntax.Expression]:
     r"""Create Generic[...] argument expression for class definition."""
 
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(tparam_list),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(tparam_list),
     (lambda : None_()),
     (lambda : Given(hydra.python.utils.py_primary_to_py_expression(hydra.python.utils.primary_with_expression_slices(cast(hydra.python.syntax.Primary,
     hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("Generic"))))),
@@ -2261,7 +2262,7 @@ def encode_type_quoted(env: hydra.python.environment.PythonEnvironment, typ: hyd
     r"""Encode a type to a Python expression, quoting if the type has free variables."""
 
     return hydra.overlay.python.lib.eithers.bind(encode_type(env, typ),
-    (lambda pytype: Right(hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.null(hydra.variables.free_variables_in_type(typ)),
+    (lambda pytype: Right(hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ)),
     (lambda : pytype),
     (lambda : hydra.python.utils.double_quoted_string(hydra.serialization.print_expr(hydra.python.serde.expression_to_expr(pytype))))))))
 
@@ -2289,17 +2290,21 @@ def encode_union_field(cx: T0, env: hydra.python.environment.PythonEnvironment,
     return hydra.overlay.python.lib.eithers.bind(hydra.annotations.get_type_description(cx, python_environment_get_graph(env), ftype),
     (lambda fcomment: (
       is_unit := Lazy((lambda : hydra.overlay.python.lib.equality.equal(hydra.strip.deannotate_type(ftype), cast(hydra.core.Type, hydra.core.TypeUnit())))),
+      is_decimal := Lazy((lambda : hydra.overlay.python.lib.equality.equal(hydra.strip.deannotate_type(ftype),
+      cast(hydra.core.Type, hydra.core.TypeLiteral(cast(hydra.core.LiteralType, hydra.core.LiteralTypeDecimal())))))),
       var_name := Lazy((lambda : deconflict_variant_name(False, env, union_name, fname, env.graph))),
       tparam_names := Lazy((lambda : find_type_params(env, ftype))),
       tparam_py_names := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda x1: hydra.python.names.encode_type_variable(x1)), tparam_names.get()))),
       field_params := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda x1: hydra.python.utils.py_name_to_py_type_parameter(x1)), tparam_py_names.get()))),
       body := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(is_unit.get(),
       (lambda : hydra.python.utils.indented_block(fcomment, ConsList.of(hydra.python.utils.unit_variant_methods(var_name.get())))),
-      (lambda : hydra.python.utils.indented_block(fcomment, ConsList.of()))))),
+      (lambda : hydra.overlay.python.lib.logic.if_else(is_decimal.get(),
+      (lambda : hydra.python.utils.indented_block(fcomment, ConsList.of(hydra.python.utils.decimal_variant_methods()))),
+      (lambda : hydra.python.utils.indented_block(fcomment, ConsList.of()))))))),
       hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.logic.if_else(is_unit.get(),
       (lambda : Right(None_())),
       (lambda : hydra.overlay.python.lib.eithers.bind(encode_type_quoted(env, ftype), (lambda quoted_type: Right(Given(variant_args(quoted_type, ConsList.of()))))))),
-      (lambda margs: Right(hydra.python.utils.py_class_definition_to_py_statement(hydra.python.syntax.ClassDefinition(None_(), var_name.get(), field_params.get(), margs, body.get()))))))[6]))
+      (lambda margs: Right(hydra.python.utils.py_class_definition_to_py_statement(hydra.python.syntax.ClassDefinition(None_(), var_name.get(), field_params.get(), margs, body.get()))))))[7]))
 
 def encode_union_field_alt(env: hydra.python.environment.PythonEnvironment, union_name: hydra.core.Name, field_type: hydra.core.FieldType) -> hydra.python.syntax.Primary:
     r"""Encode a union field as a primary expression for | alternatives."""
@@ -2309,7 +2314,7 @@ def encode_union_field_alt(env: hydra.python.environment.PythonEnvironment, unio
     tparam_names = Lazy((lambda : find_type_params(env, ftype)))
     tparams = Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda x1: hydra.python.names.encode_type_variable(x1)), tparam_names())))
     name_prim = Lazy((lambda : hydra.python.utils.py_name_to_py_primary(hydra.python.names.variant_name(False, env, union_name, fname))))
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(tparams()),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(tparams()),
     (lambda : name_prim()),
     (lambda : (
       tparam_exprs := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda x1: hydra.python.utils.py_name_to_py_expression(x1)), tparams()))),
@@ -2448,7 +2453,9 @@ def encode_definition(cx: hydra.typing.InferenceContext, env: hydra.python.envir
             name = td.name
             term = td.body
             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 : hydra.core.TypeScheme(ConsList.of(),
+            cast(hydra.core.Type, hydra.core.TypeVariable(hydra.core.Name("hydra.core.Unit"))),
+            hydra.overlay.python.lib.maps.empty())),
             (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),
             (lambda comment: (
@@ -2818,7 +2825,7 @@ def extend_meta_for_type(top_level: bool, is_term_annot: bool, typ: hydra.core.T
         case hydra.core.TypeUnion(value=rt):
             return hydra.overlay.python.lib.logic.if_else(hydra.predicates.is_enum_row_type(rt),
             (lambda : set_meta_uses_enum(meta_with_subtypes(), True)),
-            (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(rt)),
+            (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(rt)),
             (lambda : set_meta_uses_node(meta_with_subtypes(), True)),
             (lambda : meta_with_subtypes()))))
 
@@ -2836,7 +2843,7 @@ def extend_meta_for_type(top_level: bool, is_term_annot: bool, typ: hydra.core.T
 
         case hydra.core.TypeRecord(value=rt2):
             has_annotated = Lazy((lambda : hydra.overlay.python.lib.lists.foldl((lambda b, ft: hydra.overlay.python.lib.logic.or_(b, hydra.annotations.has_type_description(ft.type))), False, rt2)))
-            meta1 = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(rt2),
+            meta1 = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(rt2),
             (lambda : meta_with_subtypes()),
             (lambda : set_meta_uses_dataclass(meta_with_subtypes(), True)))))
             return hydra.overlay.python.lib.logic.if_else(has_annotated(), (lambda : set_meta_uses_annotated(meta1(), True)), (lambda : meta1()))
@@ -3126,7 +3133,7 @@ def gather_metadata(overlay_subs: Set[str], focus_ns: hydra.packaging.ModuleName
     result = Lazy((lambda : hydra.overlay.python.lib.lists.foldl((lambda x1, x2: add_def(x1, x2)), start(), defs)))
     tvars = result().type_variables
     result2 = Lazy((lambda : set_meta_uses_cast(True, set_meta_uses_lru_cache(True, result()))))
-    return set_meta_uses_type_var(result2(), hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.null(tvars)))
+    return set_meta_uses_type_var(result2(), hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(tvars)))
 
 # The target Python version for code generation.
 target_python_version = hydra.python.utils.target_python_version
@@ -3153,7 +3160,7 @@ def is_type_module_check(defs: Sequence[hydra.packaging.Definition]) -> bool:
 
             case _:
                 return False
-    return hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(hydra.overlay.python.lib.lists.filter((lambda d: _hoist_hydra_python_coder_is_type_module_check_1(d)), defs)))
+    return hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(hydra.overlay.python.lib.lists.filter((lambda d: _hoist_hydra_python_coder_is_type_module_check_1(d)), defs)))
 
 def module_domain_imports(namespaces: hydra.util.ModuleNames[hydra.python.syntax.DottedName]) -> Sequence[hydra.python.syntax.ImportStatement]:
     r"""Generate domain import statements from namespace mappings."""
@@ -3203,6 +3210,9 @@ def module_standard_imports(meta: hydra.python.environment.PythonModuleMetadata)
       cond_import_symbol("Lazy", True),
       cond_import_symbol("PersistentMap", meta.uses_frozen_dict),
       cond_import_symbol("PersistentSet", meta.uses_frozen_set))),
+    (
+      "hydra.overlay.python.util._decimal",
+      ConsList.of(cond_import_symbol("decimal_node_eq", meta.uses_decimal), cond_import_symbol("decimal_node_hash", meta.uses_decimal))),
     (
       "typing",
       ConsList.of(cond_import_symbol("Annotated", meta.uses_annotated),
@@ -3213,7 +3223,7 @@ 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()),
+      hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(symbols.get()),
       (lambda : None_()),
       (lambda : Given((mod_name.get(), symbols.get())))))[2]),
     pairs()))))
@@ -3318,7 +3328,7 @@ defs0: Sequence[hydra.packaging.Definition]) -> Either[hydra.errors.Error, hydra
       (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())))),
-      body := Lazy((lambda : hydra.overlay.python.lib.lists.filter((lambda group: hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(group))),
+      body := Lazy((lambda : hydra.overlay.python.lib.lists.filter((lambda group: hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(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]))))
 

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

@@ -89,13 +89,13 @@ def number_to_expr(num: hydra.python.syntax.Number) -> hydra.ast.Expr:
 
     match num:
         case hydra.python.syntax.NumberFloat(value=f):
-            return hydra.serialization.cst(python_float_literal_text(hydra.overlay.python.lib.literals.show_float64(f)))
+            return hydra.serialization.cst(python_float_literal_text(hydra.overlay.python.lib.literals.print_float64(f)))
 
         case hydra.python.syntax.NumberImaginary(value=f2):
-            return hydra.serialization.cst(hydra.overlay.python.lib.strings.concat2(python_float_literal_text(hydra.overlay.python.lib.literals.show_float64(f2)), "j"))
+            return hydra.serialization.cst(hydra.overlay.python.lib.strings.concat2(python_float_literal_text(hydra.overlay.python.lib.literals.print_float64(f2)), "j"))
 
         case hydra.python.syntax.NumberInteger(value=i):
-            return hydra.serialization.cst(hydra.overlay.python.lib.literals.show_bigint(i))
+            return hydra.serialization.cst(hydra.overlay.python.lib.literals.print_bigint(i))
 
         case _:
             raise AssertionError("Unreachable: all variants handled")
@@ -274,7 +274,7 @@ def comparison_to_expr(cmp: hydra.python.syntax.Comparison) -> hydra.ast.Expr:
 
     lhs = cmp.lhs
     rhs = cmp.rhs
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(rhs),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(rhs),
     (lambda : bitwise_or_to_expr(lhs)),
     (lambda : hydra.serialization.space_sep(hydra.overlay.python.lib.lists.cons(bitwise_or_to_expr(lhs), hydra.overlay.python.lib.lists.map((lambda x1: compare_op_bitwise_or_pair_to_expr(x1)), rhs)))))
 
@@ -882,7 +882,7 @@ def type_alias_to_expr(ta: hydra.python.syntax.TypeAlias) -> hydra.ast.Expr:
     tparams = ta.type_params
     expr = ta.expression
     alias = Lazy((lambda : hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(name_to_expr(name)),
-    hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(tparams),
+    hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(tparams),
     (lambda : None_()),
     (lambda : Given(hydra.serialization.bracket_list(hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: type_parameter_to_expr(x1)), tparams))))))))))
     return hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("type"), alias(), hydra.serialization.cst("="), expression_to_expr(expr)))
@@ -1249,7 +1249,7 @@ def function_def_raw_to_expr(fdr: hydra.python.syntax.FunctionDefRaw) -> hydra.a
     ret_type = fdr.return_type
     block = fdr.block
     async_kw = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(async_, (lambda : Given(hydra.serialization.cst("async"))), (lambda : None_()))))
-    tparam_part = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(tparams),
+    tparam_part = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(tparams),
     (lambda : None_()),
     (lambda : Given(hydra.serialization.bracket_list(hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: type_parameter_to_expr(x1)), tparams)))))))
     param_part = Lazy((lambda : hydra.overlay.python.lib.optionals.map((lambda x1: parameters_to_expr(x1)), params)))

{hydra_python-0.17.5 → hydra_python-0.17.7}/src/main/python/hydra/python/testing.py

@@ -49,7 +49,7 @@ def generate_python_test_case(group_path: Sequence[str], tcm: hydra.testing.Test
         case hydra.testing.TestCaseUniversal(value=ucase):
             actual_ = Lazy((lambda : ucase.actual(None)))
             expected_ = Lazy((lambda : ucase.expected(None)))
-            full_name = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(group_path),
+            full_name = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(group_path),
             (lambda : name_),
             (lambda : hydra.overlay.python.lib.strings.join("__", hydra.overlay.python.lib.lists.concat2(group_path, ConsList.of(name_)))))))
             formatted_name = Lazy((lambda : format_python_test_name(full_name())))

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

@@ -197,6 +197,109 @@ def comment_statement(s: str) -> hydra.python.syntax.Statement:
 
     return py_expression_to_py_statement(triple_quoted_string(s))
 
+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.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.is_empty(g))),
+    hydra.overlay.python.lib.lists.cons(comment_group(), stmts))))
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(groups()),
+    (lambda : cast(hydra.python.syntax.Block,
+    hydra.python.syntax.BlockIndented(ConsList.of(ConsList.of(cast(hydra.python.syntax.Statement,
+    hydra.python.syntax.StatementSimple(ConsList.of(py_expression_to_py_simple_statement(py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomEllipsis()))))))))))),
+    (lambda : cast(hydra.python.syntax.Block, hydra.python.syntax.BlockIndented(groups()))))
+
+@lru_cache(1)
+def self_only_params() -> hydra.python.syntax.Parameters:
+    return cast(hydra.python.syntax.Parameters,
+    hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters(ConsList.of(hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(hydra.python.syntax.Name("self"), None_()), None_())),
+    ConsList.of(),
+    None_())))
+
+@lru_cache(1)
+def self_other_params() -> hydra.python.syntax.Parameters:
+    return cast(hydra.python.syntax.Parameters,
+    hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters(ConsList.of(hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(hydra.python.syntax.Name("self"), None_()), None_()),
+    hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(hydra.python.syntax.Name("other"), None_()), None_())),
+    ConsList.of(),
+    None_())))
+
+@lru_cache(1)
+def decimal_variant_methods() -> Sequence[hydra.python.syntax.Statement]:
+    r"""Generate __eq__ and __hash__ methods for the Decimal-typed union variant, delegating to hydra.overlay.python.util._decimal (scale-aware per docs/specification/ordering-and-equality.md; Node's generic derivation delegates to Decimal's own scale-blind equality/hash)."""
+
+    eq_body = Lazy((lambda : py_simple_statement_to_py_statement(cast(hydra.python.syntax.SimpleStatement,
+    hydra.python.syntax.SimpleStatementReturn(hydra.python.syntax.ReturnStatement(ConsList.of(cast(hydra.python.syntax.StarExpression,
+    hydra.python.syntax.StarExpressionSimple(function_call(cast(hydra.python.syntax.Primary,
+    hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("decimal_node_eq"))))),
+    ConsList.of(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.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(None_(),
+    hydra.python.syntax.BitwiseXor(None_(),
+    hydra.python.syntax.BitwiseAnd(None_(),
+    hydra.python.syntax.ShiftExpression(None_(),
+    hydra.python.syntax.Sum(None_(),
+    hydra.python.syntax.Term(None_(),
+    cast(hydra.python.syntax.Factor,
+    hydra.python.syntax.FactorSimple(hydra.python.syntax.Power(hydra.python.syntax.AwaitPrimary(False,
+    cast(hydra.python.syntax.Primary,
+    hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("self")))))),
+    None_()))))))))),
+    ConsList.of()))))))))),
+    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.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(None_(),
+    hydra.python.syntax.BitwiseXor(None_(),
+    hydra.python.syntax.BitwiseAnd(None_(),
+    hydra.python.syntax.ShiftExpression(None_(),
+    hydra.python.syntax.Sum(None_(),
+    hydra.python.syntax.Term(None_(),
+    cast(hydra.python.syntax.Factor,
+    hydra.python.syntax.FactorSimple(hydra.python.syntax.Power(hydra.python.syntax.AwaitPrimary(False,
+    cast(hydra.python.syntax.Primary,
+    hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("other")))))),
+    None_()))))))))),
+    ConsList.of()))))))))))))))))))))
+    eq_method = Lazy((lambda : cast(hydra.python.syntax.Statement,
+    hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement,
+    hydra.python.syntax.CompoundStatementFunction(hydra.python.syntax.FunctionDefinition(None_(),
+    hydra.python.syntax.FunctionDefRaw(False,
+    hydra.python.syntax.Name("__eq__"),
+    ConsList.of(),
+    Given(self_other_params()),
+    None_(),
+    None_(),
+    indented_block(None_(), ConsList.of(ConsList.of(eq_body())))))))))))
+    hash_body = Lazy((lambda : py_simple_statement_to_py_statement(cast(hydra.python.syntax.SimpleStatement,
+    hydra.python.syntax.SimpleStatementReturn(hydra.python.syntax.ReturnStatement(ConsList.of(cast(hydra.python.syntax.StarExpression,
+    hydra.python.syntax.StarExpressionSimple(function_call(cast(hydra.python.syntax.Primary,
+    hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("decimal_node_hash"))))),
+    ConsList.of(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.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(None_(),
+    hydra.python.syntax.BitwiseXor(None_(),
+    hydra.python.syntax.BitwiseAnd(None_(),
+    hydra.python.syntax.ShiftExpression(None_(),
+    hydra.python.syntax.Sum(None_(),
+    hydra.python.syntax.Term(None_(),
+    cast(hydra.python.syntax.Factor,
+    hydra.python.syntax.FactorSimple(hydra.python.syntax.Power(hydra.python.syntax.AwaitPrimary(False,
+    cast(hydra.python.syntax.Primary,
+    hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("self")))))),
+    None_()))))))))),
+    ConsList.of()))))))))))))))))))))
+    hash_method = Lazy((lambda : cast(hydra.python.syntax.Statement,
+    hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement,
+    hydra.python.syntax.CompoundStatementFunction(hydra.python.syntax.FunctionDefinition(None_(),
+    hydra.python.syntax.FunctionDefRaw(False,
+    hydra.python.syntax.Name("__hash__"),
+    ConsList.of(),
+    Given(self_only_params()),
+    None_(),
+    None_(),
+    indented_block(None_(), ConsList.of(ConsList.of(hash_body())))))))))))
+    return ConsList.of(eq_method(), hash_method())
+
 def decode_py_power_to_py_primary(p: hydra.python.syntax.Power) -> Optional[hydra.python.syntax.Primary]:
     r"""Decode a Power to a Primary if possible."""
 
@@ -229,7 +332,7 @@ def decode_py_comparison_to_py_await_primary(c: hydra.python.syntax.Comparison)
 
             case _:
                 return None_()
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(rhs)),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(rhs)),
     (lambda : None_()),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.optionals.is_given(or_lhs),
     (lambda : None_()),
@@ -303,18 +406,6 @@ def get_item_params() -> hydra.python.syntax.Parameters:
     ConsList.of(),
     None_())))
 
-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.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()),
-    (lambda : cast(hydra.python.syntax.Block,
-    hydra.python.syntax.BlockIndented(ConsList.of(ConsList.of(cast(hydra.python.syntax.Statement,
-    hydra.python.syntax.StatementSimple(ConsList.of(py_expression_to_py_simple_statement(py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomEllipsis()))))))))))),
-    (lambda : cast(hydra.python.syntax.Block, hydra.python.syntax.BlockIndented(groups()))))
-
 def primary_and_params(prim: hydra.python.syntax.Primary, params: Sequence[hydra.python.syntax.Expression]) -> hydra.python.syntax.Expression:
     r"""Create a primary with parameters (subscript)."""
 
@@ -358,7 +449,7 @@ def or_expression(prims: Sequence[hydra.python.syntax.Primary]) -> hydra.python.
         (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())))))),
-        (lambda p: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(hydra.overlay.python.lib.pairs.second(p)),
+        (lambda p: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(hydra.overlay.python.lib.pairs.second(p)),
         (lambda : hydra.python.syntax.BitwiseOr(prev, py_primary_to_py_bitwise_xor(hydra.overlay.python.lib.pairs.first(p)))),
         (lambda : build(Given(hydra.python.syntax.BitwiseOr(prev, py_primary_to_py_bitwise_xor(hydra.overlay.python.lib.pairs.first(p)))),
         hydra.overlay.python.lib.pairs.second(p))))))
@@ -485,21 +576,6 @@ def return_single(expr: hydra.python.syntax.Expression) -> hydra.python.syntax.S
     return py_simple_statement_to_py_statement(cast(hydra.python.syntax.SimpleStatement,
     hydra.python.syntax.SimpleStatementReturn(hydra.python.syntax.ReturnStatement(ConsList.of(cast(hydra.python.syntax.StarExpression, hydra.python.syntax.StarExpressionSimple(expr)))))))
 
-@lru_cache(1)
-def self_only_params() -> hydra.python.syntax.Parameters:
-    return cast(hydra.python.syntax.Parameters,
-    hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters(ConsList.of(hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(hydra.python.syntax.Name("self"), None_()), None_())),
-    ConsList.of(),
-    None_())))
-
-@lru_cache(1)
-def self_other_params() -> hydra.python.syntax.Parameters:
-    return cast(hydra.python.syntax.Parameters,
-    hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters(ConsList.of(hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(hydra.python.syntax.Name("self"), None_()), None_()),
-    hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(hydra.python.syntax.Name("other"), None_()), None_())),
-    ConsList.of(),
-    None_())))
-
 def single_quoted_string(s: str) -> hydra.python.syntax.Expression:
     r"""Create a single-quoted string expression."""
 
@@ -595,7 +671,7 @@ extra_stmts: Sequence[hydra.python.syntax.Statement]) -> Sequence[hydra.python.s
     ConsList.of())))))))))))),
     indented_block(None_(), ConsList.of(ConsList.of(get_item_method())))))))
     doc_stmt = Lazy((lambda : py_expression_to_py_statement(triple_quoted_string(doc_string()))))
-    body_groups = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(extra_stmts),
+    body_groups = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(extra_stmts),
     (lambda : (
       pass_stmt := Lazy((lambda : py_simple_statement_to_py_statement(cast(hydra.python.syntax.SimpleStatement, hydra.python.syntax.SimpleStatementPass())))),
       ConsList.of(ConsList.of(doc_stmt()), ConsList.of(pass_stmt.get())))[1]),

hydra_python-0.17.5/build/main/digest.json

@@ -1,123 +0,0 @@
-{
-  "digestFormatVersion": 2,
-  "moduleFormatVersion": 1,
-  "generator": "9de7bd43d8cafa93",
-  "generation": {
-    "generatorId": "9de7bd43d8cafa93",
-    "mode": "published",
-    "host": "python",
-    "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": "0b1e385015be90731b3a461486eec1c2ab2448e1643f3a9e4f1f7427ec0e085a"}},
-    {
-      "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": "5bc2e53c63d41de79877fbe331aada2c7f43175b09d4245b7ac61cf8261b0ca3"}},
-    {
-      "key": "hydra.python.pyproject",
-      "value": {"kind": "other", "hash": "249512648b2b008db234ee348a72056d4d625cfeb0a80d8caacbda95002569a2"}},
-    {
-      "key": "hydra.python.serde",
-      "value": {"kind": "other", "hash": "83e48906bdec70d3d0d427c0e1b02b5e4d08bb172d3f85be13992ef4c1120859"}},
-    {
-      "key": "hydra.python.syntax",
-      "value": {"kind": "other", "hash": "88a9154b48fd429f06efa0ba8981bdf12af3fed4de5a057b3304fadc623dbc19"}},
-    {
-      "key": "hydra.python.testing",
-      "value": {"kind": "other", "hash": "113853c870177388fbcc53800768d872fae34fdbfd1a0e2f30d2b2aefb966451"}},
-    {
-      "key": "hydra.python.utils",
-      "value": {"kind": "other", "hash": "f480bc8a4c39e62ea073357517964a2175e582fd220de0fbc1bc27b9b108d327"}},
-    {
-      "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": "e2f66b5c16393d8050923aab1f832f430334e4bddfc101f4cebc1f158daee01d"}},
-    {
-      "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": "afaa99c99874efa5e02a10973651a7a74ab1089feedb9de0f8a74904a8ec4eb7"}},
-    {
-      "key": "jsonContent:hydra/python/pyproject.json",
-      "value": {"kind": "other", "hash": "c94de46f1615e6e82d2f706d01ef04293373f6241a9a42882bb394d51b4f7f53"}},
-    {
-      "key": "jsonContent:hydra/python/serde.json",
-      "value": {"kind": "other", "hash": "e987b94392abfc72cedc08d2e6b8a4528479a9023c9eff636f8980e9af6e6cfb"}},
-    {
-      "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": "0ef54f39243803add5f5634d67bf8c949d89159b3fc1c4ff82d9cb0bf829f4b9"}},
-    {
-      "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": "eb662817f2e3390220a06eb6eda9cc7adce67d3e22b47f3e2823ab273d688af6"}},
-    {
-      "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": "3e8498f205a99ebfaa570a44ccac515b69ced9d7f3669a32f74d4d05d48204b6"}},
-    {
-      "key": "hydra/python/pyproject.py",
-      "value": {"kind": "targetFile", "hash": "1f9001d8d2273d4783105e099b874c273ce520b58456f9b447cb8d5e9a6a37d7"}},
-    {
-      "key": "hydra/python/serde.py",
-      "value": {"kind": "targetFile", "hash": "a783457c64ea85769cd2ab757bd429be4d0c7333ab5765b0c04f3b0bf86b1e80"}},
-    {
-      "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": "b53dbe52de14f67d6a3c74d8f6bd7051fbaa65dbf686362565bb5cda61f15075"}}]}