hydra-python 0.15.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- hydra/python/coder.py +1364 -0
- hydra/python/environment.py +91 -0
- hydra/python/language.py +48 -0
- hydra/python/names.py +120 -0
- hydra/python/serde.py +817 -0
- hydra/python/syntax.py +1811 -0
- hydra/python/testing.py +58 -0
- hydra/python/utils.py +324 -0
- hydra_python-0.15.0.dist-info/METADATA +247 -0
- hydra_python-0.15.0.dist-info/RECORD +11 -0
- hydra_python-0.15.0.dist-info/WHEEL +4 -0
hydra/python/coder.py
ADDED
|
@@ -0,0 +1,1364 @@
|
|
|
1
|
+
# Note: this is an automatically generated file. Do not edit.
|
|
2
|
+
r"""Python code generator: converts Hydra modules to Python source code."""
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
from collections.abc import Callable
|
|
5
|
+
from decimal import Decimal
|
|
6
|
+
from functools import lru_cache
|
|
7
|
+
from hydra.dsl.python import Either, FrozenDict, Just, Left, Maybe, Nothing, Right, frozenlist
|
|
8
|
+
from typing import TypeVar, cast
|
|
9
|
+
import hydra.analysis
|
|
10
|
+
import hydra.annotations
|
|
11
|
+
import hydra.arity
|
|
12
|
+
import hydra.checking
|
|
13
|
+
import hydra.coders
|
|
14
|
+
import hydra.core
|
|
15
|
+
import hydra.dependencies
|
|
16
|
+
import hydra.environment
|
|
17
|
+
import hydra.errors
|
|
18
|
+
import hydra.formatting
|
|
19
|
+
import hydra.graph
|
|
20
|
+
import hydra.lexical
|
|
21
|
+
import hydra.lib.eithers
|
|
22
|
+
import hydra.lib.equality
|
|
23
|
+
import hydra.lib.lists
|
|
24
|
+
import hydra.lib.literals
|
|
25
|
+
import hydra.lib.logic
|
|
26
|
+
import hydra.lib.maps
|
|
27
|
+
import hydra.lib.math
|
|
28
|
+
import hydra.lib.maybes
|
|
29
|
+
import hydra.lib.pairs
|
|
30
|
+
import hydra.lib.sets
|
|
31
|
+
import hydra.lib.strings
|
|
32
|
+
import hydra.names
|
|
33
|
+
import hydra.packaging
|
|
34
|
+
import hydra.predicates
|
|
35
|
+
import hydra.python.environment
|
|
36
|
+
import hydra.python.names
|
|
37
|
+
import hydra.python.serde
|
|
38
|
+
import hydra.python.syntax
|
|
39
|
+
import hydra.python.utils
|
|
40
|
+
import hydra.reduction
|
|
41
|
+
import hydra.resolution
|
|
42
|
+
import hydra.rewriting
|
|
43
|
+
import hydra.scoping
|
|
44
|
+
import hydra.serialization
|
|
45
|
+
import hydra.show.core
|
|
46
|
+
import hydra.strip
|
|
47
|
+
import hydra.typing
|
|
48
|
+
import hydra.util
|
|
49
|
+
import hydra.variables
|
|
50
|
+
T0 = TypeVar("T0")
|
|
51
|
+
T1 = TypeVar("T1")
|
|
52
|
+
T2 = TypeVar("T2")
|
|
53
|
+
T3 = TypeVar("T3")
|
|
54
|
+
def should_thunk_binding(g: hydra.graph.Graph, b: hydra.core.Binding) -> bool:
|
|
55
|
+
r"""Determine if a binding should be thunked based on its complexity and triviality."""
|
|
56
|
+
return hydra.lib.logic.and_(hydra.predicates.is_complex_binding(g, b), hydra.lib.logic.not_(hydra.predicates.is_trivial_term(b.term)))
|
|
57
|
+
def python_binding_metadata(g: hydra.graph.Graph, b: hydra.core.Binding) -> Maybe[hydra.core.Term]:
|
|
58
|
+
r"""Like bindingMetadata, but only for bindings that will actually be thunked."""
|
|
59
|
+
return hydra.lib.logic.if_else(should_thunk_binding(g, b), (lambda : hydra.lib.logic.if_else(hydra.predicates.is_complex_binding(g, b), (lambda : Just(cast(hydra.core.Term, hydra.core.TermLiteral(cast(hydra.core.Literal, hydra.core.LiteralBoolean(True)))))), (lambda : Nothing()))), (lambda : Nothing()))
|
|
60
|
+
def python_environment_get_graph(env: hydra.python.environment.PythonEnvironment) -> hydra.graph.Graph:
|
|
61
|
+
r"""Get the Graph from a PythonEnvironment."""
|
|
62
|
+
return env.graph
|
|
63
|
+
def python_environment_set_graph(tc: hydra.graph.Graph, env: hydra.python.environment.PythonEnvironment) -> hydra.python.environment.PythonEnvironment:
|
|
64
|
+
r"""Set the Graph in a PythonEnvironment."""
|
|
65
|
+
return hydra.python.environment.PythonEnvironment(env.namespaces, env.bound_type_variables, tc, env.nullary_bindings, env.version, env.skip_casts, env.inline_variables)
|
|
66
|
+
def analyze_python_function(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, term: hydra.core.Term) -> Either[T0, hydra.typing.FunctionStructure[hydra.python.environment.PythonEnvironment]]:
|
|
67
|
+
r"""Analyze a function term with Python-specific Graph management."""
|
|
68
|
+
return hydra.analysis.analyze_function_term_with(cx, (lambda x1, x2: python_binding_metadata(x1, x2)), (lambda x1: python_environment_get_graph(x1)), (lambda x1, x2: python_environment_set_graph(x1, x2)), env, term)
|
|
69
|
+
def class_variant_pattern_unit(py_variant_name: hydra.python.syntax.Name) -> hydra.python.syntax.ClosedPattern:
|
|
70
|
+
r"""Create a class pattern for a unit variant (no value captured)."""
|
|
71
|
+
return cast(hydra.python.syntax.ClosedPattern, hydra.python.syntax.ClosedPatternClass(hydra.python.syntax.ClassPattern(hydra.python.syntax.NameOrAttribute((py_variant_name,)), Nothing(), Nothing())))
|
|
72
|
+
def class_variant_pattern_with_capture(env: hydra.python.environment.PythonEnvironment, py_variant_name: hydra.python.syntax.Name, var_name: hydra.core.Name) -> hydra.python.syntax.ClosedPattern:
|
|
73
|
+
r"""Create a class pattern for a variant with captured value."""
|
|
74
|
+
@lru_cache(1)
|
|
75
|
+
def py_var_name_attr() -> hydra.python.syntax.NameOrAttribute:
|
|
76
|
+
return hydra.python.syntax.NameOrAttribute((py_variant_name,))
|
|
77
|
+
@lru_cache(1)
|
|
78
|
+
def capture_pattern() -> hydra.python.syntax.ClosedPattern:
|
|
79
|
+
return cast(hydra.python.syntax.ClosedPattern, hydra.python.syntax.ClosedPatternCapture(hydra.python.syntax.CapturePattern(hydra.python.syntax.PatternCaptureTarget(hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, var_name)))))
|
|
80
|
+
@lru_cache(1)
|
|
81
|
+
def keyword_pattern() -> hydra.python.syntax.KeywordPattern:
|
|
82
|
+
return hydra.python.syntax.KeywordPattern(hydra.python.syntax.Name("value"), cast(hydra.python.syntax.Pattern, hydra.python.syntax.PatternOr(hydra.python.syntax.OrPattern((capture_pattern(),)))))
|
|
83
|
+
return cast(hydra.python.syntax.ClosedPattern, hydra.python.syntax.ClosedPatternClass(hydra.python.syntax.ClassPattern(py_var_name_attr(), Nothing(), Just(hydra.python.syntax.KeywordPatterns((keyword_pattern(),))))))
|
|
84
|
+
def is_type_variable_name(name: hydra.core.Name) -> bool:
|
|
85
|
+
r"""Check if a name is a type variable (unqualified - no dots)."""
|
|
86
|
+
return hydra.lib.equality.equal(1, hydra.lib.lists.length(hydra.lib.strings.split_on(".", name.value)))
|
|
87
|
+
def collect_type_variables(initial: frozenset[hydra.core.Name], typ: hydra.core.Type) -> frozenset[hydra.core.Name]:
|
|
88
|
+
r"""Collect type variables from a type."""
|
|
89
|
+
while True:
|
|
90
|
+
match hydra.strip.deannotate_type(typ):
|
|
91
|
+
case hydra.core.TypeForall(value=ft):
|
|
92
|
+
return (v := ft.parameter, (body := ft.body, collect_type_variables(hydra.lib.sets.insert(v, initial), body))[1])[1]
|
|
93
|
+
case _:
|
|
94
|
+
return (free_vars := hydra.variables.free_variables_in_type(typ), (is_type_var := (lambda n: is_type_variable_name(n)), (filtered_list := hydra.lib.lists.filter((lambda x1: is_type_var(x1)), hydra.lib.sets.to_list(free_vars)), hydra.lib.sets.union(initial, hydra.lib.sets.from_list(filtered_list)))[1])[1])[1]
|
|
95
|
+
def cond_import_symbol(name: T0, flag: bool) -> Maybe[T0]:
|
|
96
|
+
r"""Conditionally include a symbol name based on a boolean flag."""
|
|
97
|
+
return hydra.lib.logic.if_else(flag, (lambda : Just(name)), (lambda : Nothing()))
|
|
98
|
+
@lru_cache(1)
|
|
99
|
+
def dataclass_decorator() -> hydra.python.syntax.NamedExpression:
|
|
100
|
+
r"""Create a @dataclass(frozen=True) decorator."""
|
|
101
|
+
return cast(hydra.python.syntax.NamedExpression, hydra.python.syntax.NamedExpressionSimple(hydra.python.utils.py_primary_to_py_expression(hydra.python.utils.primary_with_rhs(cast(hydra.python.syntax.Primary, hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("dataclass"))))), cast(hydra.python.syntax.PrimaryRhs, hydra.python.syntax.PrimaryRhsCall(hydra.python.syntax.Args((), (cast(hydra.python.syntax.KwargOrStarred, hydra.python.syntax.KwargOrStarredKwarg(hydra.python.syntax.Kwarg(hydra.python.syntax.Name("frozen"), hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomTrue()))))),), ())))))))
|
|
102
|
+
def deconflict_variant_name(is_qualified: bool, env: hydra.python.environment.PythonEnvironment, union_name: hydra.core.Name, fname: hydra.core.Name, g: hydra.graph.Graph) -> hydra.python.syntax.Name:
|
|
103
|
+
r"""Deconflict a variant name to avoid collisions with type names."""
|
|
104
|
+
@lru_cache(1)
|
|
105
|
+
def candidate_hydra_name() -> hydra.core.Name:
|
|
106
|
+
return hydra.core.Name(hydra.lib.strings.cat2(union_name.value, hydra.formatting.capitalize(fname.value)))
|
|
107
|
+
@lru_cache(1)
|
|
108
|
+
def term_collision() -> bool:
|
|
109
|
+
return hydra.lib.maps.member(candidate_hydra_name(), g.bound_terms)
|
|
110
|
+
@lru_cache(1)
|
|
111
|
+
def type_collision() -> bool:
|
|
112
|
+
return hydra.lib.maps.member(candidate_hydra_name(), g.schema_types)
|
|
113
|
+
@lru_cache(1)
|
|
114
|
+
def collision() -> bool:
|
|
115
|
+
return hydra.lib.logic.or_(term_collision(), type_collision())
|
|
116
|
+
return hydra.lib.logic.if_else(collision(), (lambda : hydra.python.syntax.Name(hydra.lib.strings.cat2(hydra.python.names.variant_name(is_qualified, env, union_name, fname).value, "_"))), (lambda : hydra.python.names.variant_name(is_qualified, env, union_name, fname)))
|
|
117
|
+
def deduplicate_case_variables(cases_: frozenlist[hydra.core.Field]) -> frozenlist[hydra.core.Field]:
|
|
118
|
+
r"""Rewrite case statements to avoid variable name collisions."""
|
|
119
|
+
def rewrite_case(state: tuple[FrozenDict[hydra.core.Name, int], frozenlist[hydra.core.Field]], field: hydra.core.Field) -> tuple[FrozenDict[hydra.core.Name, int], frozenlist[hydra.core.Field]]:
|
|
120
|
+
@lru_cache(1)
|
|
121
|
+
def count_by_name() -> FrozenDict[hydra.core.Name, int]:
|
|
122
|
+
return hydra.lib.pairs.first(state)
|
|
123
|
+
@lru_cache(1)
|
|
124
|
+
def done() -> frozenlist[hydra.core.Field]:
|
|
125
|
+
return hydra.lib.pairs.second(state)
|
|
126
|
+
fname = field.name
|
|
127
|
+
fterm = field.term
|
|
128
|
+
match hydra.strip.deannotate_and_detype_term(fterm):
|
|
129
|
+
case hydra.core.TermLambda(value=lam):
|
|
130
|
+
v = lam.parameter
|
|
131
|
+
mdom = lam.domain
|
|
132
|
+
body = lam.body
|
|
133
|
+
return hydra.lib.maybes.maybe((lambda : (hydra.lib.maps.insert(v, 1, count_by_name()), hydra.lib.lists.cons(field, done()))), (lambda count: (count2 := hydra.lib.math.add(count, 1), v2 := hydra.core.Name(hydra.lib.strings.cat2(v.value, hydra.lib.literals.show_int32(count2))), new_body := hydra.reduction.alpha_convert(v, v2, body), new_lam := hydra.core.Lambda(v2, mdom, new_body), new_term := cast(hydra.core.Term, hydra.core.TermLambda(new_lam)), new_field := hydra.core.Field(fname, new_term), (hydra.lib.maps.insert(v, count2, count_by_name()), hydra.lib.lists.cons(new_field, done())))[6]), hydra.lib.maps.lookup(v, count_by_name()))
|
|
134
|
+
case _:
|
|
135
|
+
return (count_by_name(), hydra.lib.lists.cons(field, done()))
|
|
136
|
+
@lru_cache(1)
|
|
137
|
+
def result() -> tuple[FrozenDict[hydra.core.Name, int], frozenlist[hydra.core.Field]]:
|
|
138
|
+
return hydra.lib.lists.foldl((lambda x1, x2: rewrite_case(x1, x2)), (hydra.lib.maps.empty(), ()), cases_)
|
|
139
|
+
return hydra.lib.lists.reverse(hydra.lib.pairs.second(result()))
|
|
140
|
+
def set_meta_uses_node(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
141
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, b, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
142
|
+
def dig_for_wrap(is_term_annot: bool, meta: hydra.python.environment.PythonModuleMetadata, typ: hydra.core.Type) -> hydra.python.environment.PythonModuleMetadata:
|
|
143
|
+
r"""Recursively dig through forall types to find wrap types."""
|
|
144
|
+
while True:
|
|
145
|
+
match hydra.strip.deannotate_type(typ):
|
|
146
|
+
case hydra.core.TypeForall(value=ft):
|
|
147
|
+
is_term_annot = is_term_annot
|
|
148
|
+
meta = meta
|
|
149
|
+
typ = ft.body
|
|
150
|
+
continue
|
|
151
|
+
case hydra.core.TypeWrap():
|
|
152
|
+
return hydra.lib.logic.if_else(is_term_annot, (lambda : meta), (lambda : set_meta_uses_node(meta, True)))
|
|
153
|
+
case _:
|
|
154
|
+
return meta
|
|
155
|
+
def eliminate_unit_var(v: hydra.core.Name, term0: hydra.core.Term) -> hydra.core.Term:
|
|
156
|
+
r"""Substitute unit for a variable in a term (for unit variant case handling)."""
|
|
157
|
+
def rewrite_field(rewrite: Callable[[hydra.core.Term], hydra.core.Term], fld: hydra.core.Field) -> hydra.core.Field:
|
|
158
|
+
return hydra.core.Field(fld.name, rewrite(fld.term))
|
|
159
|
+
def rewrite_binding(rewrite: Callable[[hydra.core.Term], hydra.core.Term], bnd: hydra.core.Binding) -> hydra.core.Binding:
|
|
160
|
+
return hydra.core.Binding(bnd.name, rewrite(bnd.term), bnd.type_scheme)
|
|
161
|
+
def rewrite(recurse: Callable[[hydra.core.Term], hydra.core.Term], term: hydra.core.Term) -> hydra.core.Term:
|
|
162
|
+
match hydra.strip.deannotate_and_detype_term(term):
|
|
163
|
+
case hydra.core.TermVariable(value=n):
|
|
164
|
+
return hydra.lib.logic.if_else(hydra.lib.equality.equal(n, v), (lambda : cast(hydra.core.Term, hydra.core.TermUnit())), (lambda : term))
|
|
165
|
+
case hydra.core.TermAnnotated(value=at):
|
|
166
|
+
return cast(hydra.core.Term, hydra.core.TermAnnotated(hydra.core.AnnotatedTerm(recurse(at.body), at.annotation)))
|
|
167
|
+
case hydra.core.TermApplication(value=app):
|
|
168
|
+
return cast(hydra.core.Term, hydra.core.TermApplication(hydra.core.Application(recurse(app.function), recurse(app.argument))))
|
|
169
|
+
case hydra.core.TermLambda(value=lam):
|
|
170
|
+
return hydra.lib.logic.if_else(hydra.lib.equality.equal(lam.parameter, v), (lambda : term), (lambda : cast(hydra.core.Term, hydra.core.TermLambda(hydra.core.Lambda(lam.parameter, lam.domain, recurse(lam.body))))))
|
|
171
|
+
case hydra.core.TermCases(value=cs):
|
|
172
|
+
return cast(hydra.core.Term, hydra.core.TermCases(hydra.core.CaseStatement(cs.type_name, hydra.lib.maybes.map(recurse, cs.default), hydra.lib.lists.map((lambda v1: rewrite_field(recurse, v1)), cs.cases))))
|
|
173
|
+
case hydra.core.TermLet(value=lt):
|
|
174
|
+
return cast(hydra.core.Term, hydra.core.TermLet(hydra.core.Let(hydra.lib.lists.map((lambda v1: rewrite_binding(recurse, v1)), lt.bindings), recurse(lt.body))))
|
|
175
|
+
case hydra.core.TermList(value=ts):
|
|
176
|
+
return cast(hydra.core.Term, hydra.core.TermList(hydra.lib.lists.map(recurse, ts)))
|
|
177
|
+
case hydra.core.TermMap(value=m):
|
|
178
|
+
return cast(hydra.core.Term, hydra.core.TermMap(hydra.lib.maps.from_list(hydra.lib.lists.map((lambda kv: (recurse(hydra.lib.pairs.first(kv)), recurse(hydra.lib.pairs.second(kv)))), hydra.lib.maps.to_list(m)))))
|
|
179
|
+
case hydra.core.TermRecord(value=rec):
|
|
180
|
+
return cast(hydra.core.Term, hydra.core.TermRecord(hydra.core.Record(rec.type_name, hydra.lib.lists.map((lambda v1: rewrite_field(recurse, v1)), rec.fields))))
|
|
181
|
+
case hydra.core.TermSet(value=s):
|
|
182
|
+
return cast(hydra.core.Term, hydra.core.TermSet(hydra.lib.sets.map(recurse, s)))
|
|
183
|
+
case hydra.core.TermInject(value=inj):
|
|
184
|
+
return cast(hydra.core.Term, hydra.core.TermInject(hydra.core.Injection(inj.type_name, rewrite_field(recurse, inj.field))))
|
|
185
|
+
case hydra.core.TermMaybe(value=mt):
|
|
186
|
+
return cast(hydra.core.Term, hydra.core.TermMaybe(hydra.lib.maybes.map(recurse, mt)))
|
|
187
|
+
case hydra.core.TermPair(value=p):
|
|
188
|
+
return cast(hydra.core.Term, hydra.core.TermPair((recurse(hydra.lib.pairs.first(p)), recurse(hydra.lib.pairs.second(p)))))
|
|
189
|
+
case hydra.core.TermWrap(value=wt):
|
|
190
|
+
return cast(hydra.core.Term, hydra.core.TermWrap(hydra.core.WrappedTerm(wt.type_name, recurse(wt.body))))
|
|
191
|
+
case hydra.core.TermEither(value=e):
|
|
192
|
+
return cast(hydra.core.Term, hydra.core.TermEither(hydra.lib.eithers.bimap(recurse, recurse, e)))
|
|
193
|
+
case hydra.core.TermTypeApplication(value=ta):
|
|
194
|
+
return cast(hydra.core.Term, hydra.core.TermTypeApplication(hydra.core.TypeApplicationTerm(recurse(ta.body), ta.type)))
|
|
195
|
+
case hydra.core.TermTypeLambda(value=tl):
|
|
196
|
+
return cast(hydra.core.Term, hydra.core.TermTypeLambda(hydra.core.TypeLambda(tl.parameter, recurse(tl.body))))
|
|
197
|
+
case _:
|
|
198
|
+
return term
|
|
199
|
+
def go(term: hydra.core.Term) -> hydra.core.Term:
|
|
200
|
+
return rewrite((lambda x1: go(x1)), term)
|
|
201
|
+
return go(term0)
|
|
202
|
+
def empty_metadata(ns: hydra.packaging.Namespaces[hydra.python.syntax.DottedName]) -> hydra.python.environment.PythonModuleMetadata:
|
|
203
|
+
r"""Create an initial empty metadata record with given namespaces."""
|
|
204
|
+
return hydra.python.environment.PythonModuleMetadata(ns, hydra.lib.sets.empty(), False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False)
|
|
205
|
+
def py_int(n: int) -> hydra.python.syntax.Expression:
|
|
206
|
+
r"""Create integer literal expression."""
|
|
207
|
+
return hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberInteger(n)))))
|
|
208
|
+
def wrap_in_nullary_lambda(expr: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
|
|
209
|
+
r"""Wrap a Python expression in a nullary lambda (thunk) for lazy evaluation."""
|
|
210
|
+
return cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionLambda(hydra.python.syntax.Lambda(hydra.python.syntax.LambdaParameters(Nothing(), (), (), Nothing()), expr)))
|
|
211
|
+
def make_thunk(pbody: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
|
|
212
|
+
r"""Create a thunk (zero-argument lambda) wrapped with lru_cache(1) for memoization."""
|
|
213
|
+
return hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(hydra.python.utils.function_call(cast(hydra.python.syntax.Primary, hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("lru_cache"))))), (py_int(1),))), (wrap_in_nullary_lambda(pbody),))
|
|
214
|
+
def encode_float_value_py_special_float(value: str) -> hydra.python.syntax.Expression:
|
|
215
|
+
return hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("float")), (hydra.python.utils.single_quoted_string(value),))
|
|
216
|
+
def encode_float_value_encode_float32(v: float) -> Either[T0, hydra.python.syntax.Expression]:
|
|
217
|
+
@lru_cache(1)
|
|
218
|
+
def s() -> str:
|
|
219
|
+
return hydra.lib.literals.show_float32(v)
|
|
220
|
+
return hydra.lib.logic.if_else(hydra.lib.equality.equal(s(), "NaN"), (lambda : Right(encode_float_value_py_special_float("nan"))), (lambda : hydra.lib.logic.if_else(hydra.lib.equality.equal(s(), "Infinity"), (lambda : Right(encode_float_value_py_special_float("inf"))), (lambda : hydra.lib.logic.if_else(hydra.lib.equality.equal(s(), "-Infinity"), (lambda : Right(encode_float_value_py_special_float("-inf"))), (lambda : Right(hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberFloat(hydra.lib.literals.float32_to_bigfloat(v)))))))))))))
|
|
221
|
+
def encode_float_value_encode_float64(v: float) -> Either[T0, hydra.python.syntax.Expression]:
|
|
222
|
+
@lru_cache(1)
|
|
223
|
+
def s() -> str:
|
|
224
|
+
return hydra.lib.literals.show_float64(v)
|
|
225
|
+
return hydra.lib.logic.if_else(hydra.lib.equality.equal(s(), "NaN"), (lambda : Right(encode_float_value_py_special_float("nan"))), (lambda : hydra.lib.logic.if_else(hydra.lib.equality.equal(s(), "Infinity"), (lambda : Right(encode_float_value_py_special_float("inf"))), (lambda : hydra.lib.logic.if_else(hydra.lib.equality.equal(s(), "-Infinity"), (lambda : Right(encode_float_value_py_special_float("-inf"))), (lambda : hydra.lib.logic.if_else(hydra.lib.equality.equal(s(), "-0.0"), (lambda : Right(encode_float_value_py_special_float("-0.0"))), (lambda : Right(hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberFloat(hydra.lib.literals.float64_to_bigfloat(v)))))))))))))))
|
|
226
|
+
def encode_float_value(fv: hydra.core.FloatValue) -> Either[T0, hydra.python.syntax.Expression]:
|
|
227
|
+
r"""Encode a float value to a Python expression."""
|
|
228
|
+
match fv:
|
|
229
|
+
case hydra.core.FloatValueBigfloat(value=f):
|
|
230
|
+
return Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("Decimal")), (hydra.python.utils.single_quoted_string(hydra.lib.literals.show_bigfloat(f)),)))
|
|
231
|
+
case hydra.core.FloatValueFloat32(value=f2):
|
|
232
|
+
return encode_float_value_encode_float32(f2)
|
|
233
|
+
case hydra.core.FloatValueFloat64(value=f3):
|
|
234
|
+
return encode_float_value_encode_float64(f3)
|
|
235
|
+
case _:
|
|
236
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
237
|
+
def encode_integer_value(iv: hydra.core.IntegerValue) -> Either[T0, hydra.python.syntax.Expression]:
|
|
238
|
+
r"""Encode an integer value to a Python expression."""
|
|
239
|
+
def to_py_int(n: int) -> Either[T1, hydra.python.syntax.Expression]:
|
|
240
|
+
return Right(hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberInteger(n))))))
|
|
241
|
+
match iv:
|
|
242
|
+
case hydra.core.IntegerValueBigint(value=i):
|
|
243
|
+
return to_py_int(i)
|
|
244
|
+
case hydra.core.IntegerValueInt8(value=i2):
|
|
245
|
+
return to_py_int(hydra.lib.literals.int8_to_bigint(i2))
|
|
246
|
+
case hydra.core.IntegerValueInt16(value=i3):
|
|
247
|
+
return to_py_int(hydra.lib.literals.int16_to_bigint(i3))
|
|
248
|
+
case hydra.core.IntegerValueInt32(value=i4):
|
|
249
|
+
return to_py_int(hydra.lib.literals.int32_to_bigint(i4))
|
|
250
|
+
case hydra.core.IntegerValueInt64(value=i5):
|
|
251
|
+
return to_py_int(hydra.lib.literals.int64_to_bigint(i5))
|
|
252
|
+
case hydra.core.IntegerValueUint8(value=i6):
|
|
253
|
+
return to_py_int(hydra.lib.literals.uint8_to_bigint(i6))
|
|
254
|
+
case hydra.core.IntegerValueUint16(value=i7):
|
|
255
|
+
return to_py_int(hydra.lib.literals.uint16_to_bigint(i7))
|
|
256
|
+
case hydra.core.IntegerValueUint32(value=i8):
|
|
257
|
+
return to_py_int(hydra.lib.literals.uint32_to_bigint(i8))
|
|
258
|
+
case hydra.core.IntegerValueUint64(value=i9):
|
|
259
|
+
return to_py_int(hydra.lib.literals.uint64_to_bigint(i9))
|
|
260
|
+
case _:
|
|
261
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
262
|
+
def encode_literal(lit: hydra.core.Literal) -> Either[T0, hydra.python.syntax.Expression]:
|
|
263
|
+
r"""Encode a literal value to a Python expression."""
|
|
264
|
+
match lit:
|
|
265
|
+
case hydra.core.LiteralBinary(value=bs):
|
|
266
|
+
@lru_cache(1)
|
|
267
|
+
def byte_values() -> frozenlist[int]:
|
|
268
|
+
return hydra.lib.literals.binary_to_bytes(bs)
|
|
269
|
+
return Right(hydra.python.utils.function_call(cast(hydra.python.syntax.Primary, hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("bytes"))))), (hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomList(hydra.python.utils.py_list(hydra.lib.lists.map((lambda byte_val: hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberInteger(hydra.lib.literals.int32_to_bigint(byte_val))))))), byte_values()))))),)))
|
|
270
|
+
case hydra.core.LiteralBoolean(value=b):
|
|
271
|
+
return Right(hydra.python.utils.py_atom_to_py_expression(hydra.lib.logic.if_else(b, (lambda : cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomTrue())), (lambda : cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomFalse())))))
|
|
272
|
+
case hydra.core.LiteralDecimal(value=d):
|
|
273
|
+
return Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("Decimal")), (hydra.python.utils.single_quoted_string(hydra.lib.literals.show_decimal(d)),)))
|
|
274
|
+
case hydra.core.LiteralFloat(value=f):
|
|
275
|
+
return encode_float_value(f)
|
|
276
|
+
case hydra.core.LiteralInteger(value=i):
|
|
277
|
+
return encode_integer_value(i)
|
|
278
|
+
case hydra.core.LiteralString(value=s):
|
|
279
|
+
return Right(hydra.python.utils.string_to_py_expression(hydra.python.syntax.QuoteStyle.DOUBLE, s))
|
|
280
|
+
case _:
|
|
281
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
282
|
+
def encode_literal_type(lt: hydra.core.LiteralType) -> Either[T0, hydra.python.syntax.Expression]:
|
|
283
|
+
r"""Encode a literal type to a Python type expression."""
|
|
284
|
+
@lru_cache(1)
|
|
285
|
+
def find_name():
|
|
286
|
+
def _hoist_find_name_1(v1):
|
|
287
|
+
match v1:
|
|
288
|
+
case hydra.core.FloatType.BIGFLOAT:
|
|
289
|
+
return "Decimal"
|
|
290
|
+
case hydra.core.FloatType.FLOAT32:
|
|
291
|
+
return "float"
|
|
292
|
+
case hydra.core.FloatType.FLOAT64:
|
|
293
|
+
return "float"
|
|
294
|
+
case _:
|
|
295
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
296
|
+
match lt:
|
|
297
|
+
case hydra.core.LiteralTypeBinary():
|
|
298
|
+
return "bytes"
|
|
299
|
+
case hydra.core.LiteralTypeBoolean():
|
|
300
|
+
return "bool"
|
|
301
|
+
case hydra.core.LiteralTypeDecimal():
|
|
302
|
+
return "Decimal"
|
|
303
|
+
case hydra.core.LiteralTypeFloat(value=ft):
|
|
304
|
+
return _hoist_find_name_1(ft)
|
|
305
|
+
case hydra.core.LiteralTypeInteger():
|
|
306
|
+
return "int"
|
|
307
|
+
case hydra.core.LiteralTypeString():
|
|
308
|
+
return "str"
|
|
309
|
+
case _:
|
|
310
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
311
|
+
return Right(cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction((hydra.python.syntax.Conjunction((cast(hydra.python.syntax.Inversion, hydra.python.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(Nothing(), hydra.python.syntax.BitwiseXor(Nothing(), hydra.python.syntax.BitwiseAnd(Nothing(), hydra.python.syntax.ShiftExpression(Nothing(), hydra.python.syntax.Sum(Nothing(), hydra.python.syntax.Term(Nothing(), 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(find_name())))))), Nothing()))))))))), ()))),)),)))))
|
|
312
|
+
def encode_application_type(env: hydra.python.environment.PythonEnvironment, at: hydra.core.ApplicationType) -> Either[T0, hydra.python.syntax.Expression]:
|
|
313
|
+
r"""Encode an application type to Python expression."""
|
|
314
|
+
def gather_params(t: hydra.core.Type, ps: frozenlist[hydra.core.Type]) -> tuple[hydra.core.Type, frozenlist[hydra.core.Type]]:
|
|
315
|
+
while True:
|
|
316
|
+
match hydra.strip.deannotate_type(t):
|
|
317
|
+
case hydra.core.TypeApplication(value=app_t):
|
|
318
|
+
t = app_t.function
|
|
319
|
+
ps = hydra.lib.lists.cons(app_t.argument, ps)
|
|
320
|
+
continue
|
|
321
|
+
case hydra.core.TypeAnnotated():
|
|
322
|
+
return (t, ps)
|
|
323
|
+
case hydra.core.TypeFunction():
|
|
324
|
+
return (t, ps)
|
|
325
|
+
case hydra.core.TypeForall():
|
|
326
|
+
return (t, ps)
|
|
327
|
+
case hydra.core.TypeList():
|
|
328
|
+
return (t, ps)
|
|
329
|
+
case hydra.core.TypeLiteral():
|
|
330
|
+
return (t, ps)
|
|
331
|
+
case hydra.core.TypeMap():
|
|
332
|
+
return (t, ps)
|
|
333
|
+
case hydra.core.TypeMaybe():
|
|
334
|
+
return (t, ps)
|
|
335
|
+
case hydra.core.TypeEither():
|
|
336
|
+
return (t, ps)
|
|
337
|
+
case hydra.core.TypePair():
|
|
338
|
+
return (t, ps)
|
|
339
|
+
case hydra.core.TypeRecord():
|
|
340
|
+
return (t, ps)
|
|
341
|
+
case hydra.core.TypeSet():
|
|
342
|
+
return (t, ps)
|
|
343
|
+
case hydra.core.TypeUnion():
|
|
344
|
+
return (t, ps)
|
|
345
|
+
case hydra.core.TypeUnit():
|
|
346
|
+
return (t, ps)
|
|
347
|
+
case hydra.core.TypeVariable():
|
|
348
|
+
return (t, ps)
|
|
349
|
+
case hydra.core.TypeVoid():
|
|
350
|
+
return (t, ps)
|
|
351
|
+
case hydra.core.TypeWrap():
|
|
352
|
+
return (t, ps)
|
|
353
|
+
case _:
|
|
354
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
355
|
+
@lru_cache(1)
|
|
356
|
+
def body_and_args() -> tuple[hydra.core.Type, frozenlist[hydra.core.Type]]:
|
|
357
|
+
return gather_params(cast(hydra.core.Type, hydra.core.TypeApplication(at)), ())
|
|
358
|
+
@lru_cache(1)
|
|
359
|
+
def body() -> hydra.core.Type:
|
|
360
|
+
return hydra.lib.pairs.first(body_and_args())
|
|
361
|
+
@lru_cache(1)
|
|
362
|
+
def args() -> frozenlist[hydra.core.Type]:
|
|
363
|
+
return hydra.lib.pairs.second(body_and_args())
|
|
364
|
+
return hydra.lib.eithers.bind(encode_type(env, body()), (lambda py_body: hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_type(env, v1)), args()), (lambda py_args: Right(hydra.python.utils.primary_and_params(hydra.python.utils.py_expression_to_py_primary(py_body), py_args))))))
|
|
365
|
+
def encode_forall_type(env: hydra.python.environment.PythonEnvironment, lt: hydra.core.ForallType) -> Either[T0, hydra.python.syntax.Expression]:
|
|
366
|
+
r"""Encode a forall type to Python expression."""
|
|
367
|
+
def gather_params(t: hydra.core.Type, ps: frozenlist[hydra.core.Name]) -> tuple[hydra.core.Type, frozenlist[hydra.core.Name]]:
|
|
368
|
+
while True:
|
|
369
|
+
match hydra.strip.deannotate_type(t):
|
|
370
|
+
case hydra.core.TypeForall(value=forall_t):
|
|
371
|
+
t = forall_t.body
|
|
372
|
+
ps = hydra.lib.lists.cons(forall_t.parameter, ps)
|
|
373
|
+
continue
|
|
374
|
+
case hydra.core.TypeAnnotated():
|
|
375
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
376
|
+
case hydra.core.TypeApplication():
|
|
377
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
378
|
+
case hydra.core.TypeFunction():
|
|
379
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
380
|
+
case hydra.core.TypeList():
|
|
381
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
382
|
+
case hydra.core.TypeLiteral():
|
|
383
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
384
|
+
case hydra.core.TypeMap():
|
|
385
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
386
|
+
case hydra.core.TypeMaybe():
|
|
387
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
388
|
+
case hydra.core.TypeEither():
|
|
389
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
390
|
+
case hydra.core.TypePair():
|
|
391
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
392
|
+
case hydra.core.TypeRecord():
|
|
393
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
394
|
+
case hydra.core.TypeSet():
|
|
395
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
396
|
+
case hydra.core.TypeUnion():
|
|
397
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
398
|
+
case hydra.core.TypeUnit():
|
|
399
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
400
|
+
case hydra.core.TypeVariable():
|
|
401
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
402
|
+
case hydra.core.TypeVoid():
|
|
403
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
404
|
+
case hydra.core.TypeWrap():
|
|
405
|
+
return (t, hydra.lib.lists.reverse(ps))
|
|
406
|
+
case _:
|
|
407
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
408
|
+
@lru_cache(1)
|
|
409
|
+
def body_and_params() -> tuple[hydra.core.Type, frozenlist[hydra.core.Name]]:
|
|
410
|
+
return gather_params(cast(hydra.core.Type, hydra.core.TypeForall(lt)), ())
|
|
411
|
+
@lru_cache(1)
|
|
412
|
+
def body() -> hydra.core.Type:
|
|
413
|
+
return hydra.lib.pairs.first(body_and_params())
|
|
414
|
+
@lru_cache(1)
|
|
415
|
+
def params() -> frozenlist[hydra.core.Name]:
|
|
416
|
+
return hydra.lib.pairs.second(body_and_params())
|
|
417
|
+
return hydra.lib.eithers.bind(encode_type(env, body()), (lambda py_body: Right(hydra.python.utils.primary_and_params(hydra.python.utils.py_expression_to_py_primary(py_body), hydra.lib.lists.map((lambda n: cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction((hydra.python.syntax.Conjunction((cast(hydra.python.syntax.Inversion, hydra.python.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(Nothing(), hydra.python.syntax.BitwiseXor(Nothing(), hydra.python.syntax.BitwiseAnd(Nothing(), hydra.python.syntax.ShiftExpression(Nothing(), hydra.python.syntax.Sum(Nothing(), hydra.python.syntax.Term(Nothing(), 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(n.value)))))), Nothing()))))))))), ()))),)),))))), params())))))
|
|
418
|
+
def encode_function_type(env: hydra.python.environment.PythonEnvironment, ft: hydra.core.FunctionType) -> Either[T0, hydra.python.syntax.Expression]:
|
|
419
|
+
r"""Encode a function type to Python Callable expression."""
|
|
420
|
+
def gather_params(rdoms: frozenlist[hydra.core.Type], ftype: hydra.core.FunctionType) -> tuple[frozenlist[hydra.core.Type], hydra.core.Type]:
|
|
421
|
+
while True:
|
|
422
|
+
inner_cod = ftype.codomain
|
|
423
|
+
dom = ftype.domain
|
|
424
|
+
match hydra.strip.deannotate_type(inner_cod):
|
|
425
|
+
case hydra.core.TypeFunction(value=ft2):
|
|
426
|
+
rdoms = hydra.lib.lists.cons(dom, rdoms)
|
|
427
|
+
ftype = ft2
|
|
428
|
+
continue
|
|
429
|
+
case hydra.core.TypeAnnotated():
|
|
430
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
431
|
+
case hydra.core.TypeApplication():
|
|
432
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
433
|
+
case hydra.core.TypeForall():
|
|
434
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
435
|
+
case hydra.core.TypeList():
|
|
436
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
437
|
+
case hydra.core.TypeLiteral():
|
|
438
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
439
|
+
case hydra.core.TypeMap():
|
|
440
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
441
|
+
case hydra.core.TypeMaybe():
|
|
442
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
443
|
+
case hydra.core.TypeEither():
|
|
444
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
445
|
+
case hydra.core.TypePair():
|
|
446
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
447
|
+
case hydra.core.TypeRecord():
|
|
448
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
449
|
+
case hydra.core.TypeSet():
|
|
450
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
451
|
+
case hydra.core.TypeUnion():
|
|
452
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
453
|
+
case hydra.core.TypeUnit():
|
|
454
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
455
|
+
case hydra.core.TypeVariable():
|
|
456
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
457
|
+
case hydra.core.TypeVoid():
|
|
458
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
459
|
+
case hydra.core.TypeWrap():
|
|
460
|
+
return (hydra.lib.lists.reverse(hydra.lib.lists.cons(dom, rdoms)), inner_cod)
|
|
461
|
+
case _:
|
|
462
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
463
|
+
@lru_cache(1)
|
|
464
|
+
def doms_and_cod() -> tuple[frozenlist[hydra.core.Type], hydra.core.Type]:
|
|
465
|
+
return gather_params((), ft)
|
|
466
|
+
@lru_cache(1)
|
|
467
|
+
def doms() -> frozenlist[hydra.core.Type]:
|
|
468
|
+
return hydra.lib.pairs.first(doms_and_cod())
|
|
469
|
+
@lru_cache(1)
|
|
470
|
+
def cod() -> hydra.core.Type:
|
|
471
|
+
return hydra.lib.pairs.second(doms_and_cod())
|
|
472
|
+
return hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_type(env, v1)), doms()), (lambda pydoms: hydra.lib.eithers.bind(encode_type(env, cod()), (lambda pycod: Right(hydra.python.utils.py_primary_to_py_expression(hydra.python.utils.primary_with_slices(cast(hydra.python.syntax.Primary, hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("Callable"))))), hydra.python.utils.py_primary_to_py_slice(cast(hydra.python.syntax.Primary, hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomList(hydra.python.utils.py_list(pydoms)))))), (cast(hydra.python.syntax.SliceOrStarredExpression, hydra.python.syntax.SliceOrStarredExpressionSlice(hydra.python.utils.py_expression_to_py_slice(pycod))),))))))))
|
|
473
|
+
def encode_type(env: hydra.python.environment.PythonEnvironment, typ: hydra.core.Type) -> Either[T0, hydra.python.syntax.Expression]:
|
|
474
|
+
r"""Encode a Hydra type to a Python type expression."""
|
|
475
|
+
@lru_cache(1)
|
|
476
|
+
def dflt() -> Either[T1, hydra.python.syntax.Expression]:
|
|
477
|
+
return Right(hydra.python.utils.double_quoted_string(hydra.lib.strings.cat2("type = ", hydra.show.core.type(hydra.strip.deannotate_type(typ)))))
|
|
478
|
+
match hydra.strip.deannotate_type(typ):
|
|
479
|
+
case hydra.core.TypeApplication(value=at):
|
|
480
|
+
return encode_application_type(env, at)
|
|
481
|
+
case hydra.core.TypeFunction(value=ft):
|
|
482
|
+
return encode_function_type(env, ft)
|
|
483
|
+
case hydra.core.TypeForall(value=lt):
|
|
484
|
+
return encode_forall_type(env, lt)
|
|
485
|
+
case hydra.core.TypeList(value=et):
|
|
486
|
+
return hydra.lib.eithers.bind(encode_type(env, et), (lambda pyet: Right(hydra.python.utils.name_and_params(hydra.python.syntax.Name("frozenlist"), (pyet,)))))
|
|
487
|
+
case hydra.core.TypeMap(value=mt):
|
|
488
|
+
return hydra.lib.eithers.bind(encode_type(env, mt.keys), (lambda pykt: hydra.lib.eithers.bind(encode_type(env, mt.values), (lambda pyvt: Right(hydra.python.utils.name_and_params(hydra.python.syntax.Name("FrozenDict"), (pykt, pyvt)))))))
|
|
489
|
+
case hydra.core.TypeLiteral(value=lt2):
|
|
490
|
+
return encode_literal_type(lt2)
|
|
491
|
+
case hydra.core.TypeMaybe(value=et2):
|
|
492
|
+
return hydra.lib.eithers.bind(encode_type(env, et2), (lambda ptype: Right(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("Maybe"))))), (ptype,))))))
|
|
493
|
+
case hydra.core.TypeEither(value=either_t):
|
|
494
|
+
return hydra.lib.eithers.bind(encode_type(env, either_t.left), (lambda pyleft: hydra.lib.eithers.bind(encode_type(env, either_t.right), (lambda pyright: Right(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("Either"))))), (pyleft, pyright))))))))
|
|
495
|
+
case hydra.core.TypePair(value=pair_t):
|
|
496
|
+
return hydra.lib.eithers.bind(encode_type(env, pair_t.first), (lambda py_first: hydra.lib.eithers.bind(encode_type(env, pair_t.second), (lambda py_second: Right(hydra.python.utils.name_and_params(hydra.python.syntax.Name("tuple"), (py_first, py_second)))))))
|
|
497
|
+
case hydra.core.TypeRecord():
|
|
498
|
+
return dflt()
|
|
499
|
+
case hydra.core.TypeSet(value=et3):
|
|
500
|
+
return hydra.lib.eithers.bind(encode_type(env, et3), (lambda pyet: Right(hydra.python.utils.name_and_params(hydra.python.syntax.Name("frozenset"), (pyet,)))))
|
|
501
|
+
case hydra.core.TypeUnion():
|
|
502
|
+
return dflt()
|
|
503
|
+
case hydra.core.TypeUnit():
|
|
504
|
+
return Right(hydra.python.utils.py_name_to_py_expression(hydra.python.utils.py_none))
|
|
505
|
+
case hydra.core.TypeVoid():
|
|
506
|
+
return Right(hydra.python.utils.py_name_to_py_expression(hydra.python.utils.py_none))
|
|
507
|
+
case hydra.core.TypeVariable(value=name):
|
|
508
|
+
return Right(hydra.python.names.type_variable_reference(env, name))
|
|
509
|
+
case hydra.core.TypeWrap():
|
|
510
|
+
return dflt()
|
|
511
|
+
case hydra.core.TypeAnnotated():
|
|
512
|
+
return dflt()
|
|
513
|
+
case _:
|
|
514
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
515
|
+
def make_simple_lambda(arity: int, lhs: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
|
|
516
|
+
r"""Wrap a bare reference to a polymorphic function in an uncurried lambda."""
|
|
517
|
+
@lru_cache(1)
|
|
518
|
+
def args() -> frozenlist[hydra.python.syntax.Name]:
|
|
519
|
+
return hydra.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.lib.strings.cat2("x", hydra.lib.literals.show_int32(i)))), hydra.lib.math.range_(1, arity))
|
|
520
|
+
return hydra.lib.logic.if_else(hydra.lib.equality.equal(arity, 0), (lambda : lhs), (lambda : cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionLambda(hydra.python.syntax.Lambda(hydra.python.syntax.LambdaParameters(Nothing(), hydra.lib.lists.map((lambda a: hydra.python.syntax.LambdaParamNoDefault(a)), args()), (), Nothing()), hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(lhs), hydra.lib.lists.map((lambda a: cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction((hydra.python.syntax.Conjunction((cast(hydra.python.syntax.Inversion, hydra.python.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(Nothing(), hydra.python.syntax.BitwiseXor(Nothing(), hydra.python.syntax.BitwiseAnd(Nothing(), hydra.python.syntax.ShiftExpression(Nothing(), hydra.python.syntax.Sum(Nothing(), hydra.python.syntax.Term(Nothing(), 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(a))))), Nothing()))))))))), ()))),)),))))), args())))))))
|
|
521
|
+
def make_uncurried_lambda(params: frozenlist[hydra.python.syntax.Name], body: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
|
|
522
|
+
r"""Create an uncurried lambda with multiple parameters."""
|
|
523
|
+
return cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionLambda(hydra.python.syntax.Lambda(hydra.python.syntax.LambdaParameters(Nothing(), hydra.lib.lists.map((lambda p: hydra.python.syntax.LambdaParamNoDefault(p)), params), (), Nothing()), body)))
|
|
524
|
+
def encode_variable(cx: T0, env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, args: frozenlist[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hydra.python.syntax.Expression]:
|
|
525
|
+
r"""Encode a variable reference to a Python expression."""
|
|
526
|
+
@lru_cache(1)
|
|
527
|
+
def g() -> hydra.graph.Graph:
|
|
528
|
+
return python_environment_get_graph(env)
|
|
529
|
+
tc = env.graph
|
|
530
|
+
tc_types = tc.bound_types
|
|
531
|
+
tc_lambda_vars = tc.lambda_variables
|
|
532
|
+
tc_metadata = tc.metadata
|
|
533
|
+
inline_vars = env.inline_variables
|
|
534
|
+
@lru_cache(1)
|
|
535
|
+
def m_typ_scheme() -> Maybe[hydra.core.TypeScheme]:
|
|
536
|
+
return hydra.lib.maps.lookup(name, tc_types)
|
|
537
|
+
@lru_cache(1)
|
|
538
|
+
def m_typ() -> Maybe[hydra.core.Type]:
|
|
539
|
+
return hydra.lib.maybes.map((lambda ts_: ts_.body), m_typ_scheme())
|
|
540
|
+
@lru_cache(1)
|
|
541
|
+
def as_variable() -> hydra.python.syntax.Expression:
|
|
542
|
+
return hydra.python.names.term_variable_reference(env, name)
|
|
543
|
+
@lru_cache(1)
|
|
544
|
+
def as_function_call() -> hydra.python.syntax.Expression:
|
|
545
|
+
return 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)
|
|
546
|
+
return hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.lists.null(args)), (lambda : hydra.lib.maybes.maybe((lambda : Right(as_function_call())), (lambda prim: (prim_arity := hydra.arity.primitive_arity(prim), hydra.lib.logic.if_else(hydra.lib.equality.equal(prim_arity, hydra.lib.lists.length(args)), (lambda : Right(as_function_call())), (lambda : (num_remaining := hydra.lib.math.sub(prim_arity, hydra.lib.lists.length(args)), (remaining_params := hydra.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.lib.strings.cat2("x", hydra.lib.literals.show_int32(i)))), hydra.lib.math.range_(1, num_remaining)), (remaining_exprs := hydra.lib.lists.map((lambda n: cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction((hydra.python.syntax.Conjunction((cast(hydra.python.syntax.Inversion, hydra.python.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(Nothing(), hydra.python.syntax.BitwiseXor(Nothing(), hydra.python.syntax.BitwiseAnd(Nothing(), hydra.python.syntax.ShiftExpression(Nothing(), hydra.python.syntax.Sum(Nothing(), hydra.python.syntax.Term(Nothing(), 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(n))))), Nothing()))))))))), ()))),)),))))), remaining_params), (all_args := hydra.lib.lists.concat2(args, remaining_exprs), (full_call := 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), Right(make_uncurried_lambda(remaining_params, full_call)))[1])[1])[1])[1])[1])))[1]), hydra.lexical.lookup_primitive(g(), name))), (lambda : hydra.lib.maybes.maybe((lambda : hydra.lib.logic.if_else(hydra.lib.sets.member(name, tc_lambda_vars), (lambda : Right(as_variable())), (lambda : hydra.lib.logic.if_else(hydra.lib.sets.member(name, inline_vars), (lambda : Right(as_variable())), (lambda : hydra.lib.maybes.maybe((lambda : hydra.lib.maybes.maybe((lambda : hydra.lib.maybes.maybe((lambda : Left(cast(hydra.errors.Error, hydra.errors.ErrorOther(hydra.errors.OtherError(hydra.lib.strings.cat2("Unknown variable: ", name.value)))))), (lambda _: Right(as_function_call())), hydra.lib.maps.lookup(name, tc_metadata))), (lambda el: (el_trivial1 := hydra.predicates.is_trivial_term(el.term), hydra.lib.maybes.maybe((lambda : Right(as_variable())), (lambda ts: hydra.lib.logic.if_else(hydra.lib.logic.and_(hydra.lib.logic.and_(hydra.lib.equality.equal(hydra.arity.type_scheme_arity(ts), 0), hydra.predicates.is_complex_binding(tc, el)), hydra.lib.logic.not_(el_trivial1)), (lambda : Right(as_function_call())), (lambda : (as_function_ref := hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.lists.null(ts.variables)), (lambda : make_simple_lambda(hydra.arity.type_arity(ts.body), as_variable())), (lambda : as_variable())), Right(as_function_ref))[1]))), el.type_scheme))[1]), hydra.lexical.lookup_binding(g(), name))), (lambda prim: (prim_arity := hydra.arity.primitive_arity(prim), hydra.lib.logic.if_else(hydra.lib.equality.equal(prim_arity, 0), (lambda : Right(as_function_call())), (lambda : (ts := prim.type_scheme, (as_function_ref := hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.lists.null(ts.variables)), (lambda : make_simple_lambda(hydra.arity.type_arity(ts.body), as_variable())), (lambda : as_variable())), Right(as_function_ref))[1])[1])))[1]), hydra.lexical.lookup_primitive(g(), name))))))), (lambda typ: hydra.lib.logic.if_else(hydra.lib.sets.member(name, tc_lambda_vars), (lambda : Right(as_variable())), (lambda : hydra.lib.logic.if_else(hydra.lib.sets.member(name, inline_vars), (lambda : (as_function_ref := hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.sets.null(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))[1]), (lambda : hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.maps.member(name, tc_metadata)), (lambda : hydra.lib.maybes.maybe((lambda : (as_function_ref := hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.sets.null(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))[1]), (lambda el: (el_trivial := hydra.predicates.is_trivial_term(el.term), hydra.lib.maybes.maybe((lambda : hydra.lib.logic.if_else(hydra.lib.logic.and_(hydra.lib.equality.equal(hydra.arity.type_arity(typ), 0), hydra.lib.logic.not_(el_trivial)), (lambda : Right(as_function_call())), (lambda : (as_function_ref := hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.sets.null(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))[1]))), (lambda ts: hydra.lib.logic.if_else(hydra.lib.logic.and_(hydra.lib.logic.and_(hydra.lib.equality.equal(hydra.arity.type_arity(typ), 0), hydra.predicates.is_complex_binding(tc, el)), hydra.lib.logic.not_(el_trivial)), (lambda : Right(as_function_call())), (lambda : (as_function_ref := hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.sets.null(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))[1]))), el.type_scheme))[1]), hydra.lexical.lookup_binding(g(), name))), (lambda : hydra.lib.logic.if_else(hydra.lib.logic.and_(hydra.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 := hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.sets.null(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))[1]))))))))), m_typ())))
|
|
547
|
+
def make_curried_lambda(params: frozenlist[hydra.python.syntax.Name], body: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
|
|
548
|
+
r"""Create a curried lambda chain from a list of parameter names and a body."""
|
|
549
|
+
return hydra.lib.lists.foldl((lambda acc, p: cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionLambda(hydra.python.syntax.Lambda(hydra.python.syntax.LambdaParameters(Nothing(), (hydra.python.syntax.LambdaParamNoDefault(p),), (), Nothing()), acc)))), body, hydra.lib.lists.reverse(params))
|
|
550
|
+
def unsupported_expression(msg: str) -> hydra.python.syntax.Expression:
|
|
551
|
+
r"""Create an expression that calls hydra.dsl.python.unsupported(message) at runtime."""
|
|
552
|
+
return hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(hydra.python.utils.project_from_expression(hydra.python.utils.project_from_expression(hydra.python.utils.project_from_expression(cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction((hydra.python.syntax.Conjunction((cast(hydra.python.syntax.Inversion, hydra.python.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(Nothing(), hydra.python.syntax.BitwiseXor(Nothing(), hydra.python.syntax.BitwiseAnd(Nothing(), hydra.python.syntax.ShiftExpression(Nothing(), hydra.python.syntax.Sum(Nothing(), hydra.python.syntax.Term(Nothing(), 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("hydra")))))), Nothing()))))))))), ()))),)),)))), hydra.python.syntax.Name("dsl")), hydra.python.syntax.Name("python")), hydra.python.syntax.Name("unsupported"))), (hydra.python.utils.string_to_py_expression(hydra.python.syntax.QuoteStyle.DOUBLE, msg),))
|
|
553
|
+
def with_let_inline(env: hydra.python.environment.PythonEnvironment, lt: hydra.core.Let, body: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
|
|
554
|
+
r"""Execute a computation with inline let context (for walrus operators)."""
|
|
555
|
+
@lru_cache(1)
|
|
556
|
+
def binding_names() -> frozenlist[hydra.core.Name]:
|
|
557
|
+
return hydra.lib.lists.map((lambda b: b.name), lt.bindings)
|
|
558
|
+
@lru_cache(1)
|
|
559
|
+
def inline_vars() -> frozenset[hydra.core.Name]:
|
|
560
|
+
return hydra.lib.sets.from_list(binding_names())
|
|
561
|
+
def no_metadata(tc: T1, b: T2) -> Maybe[T3]:
|
|
562
|
+
return Nothing()
|
|
563
|
+
return hydra.environment.with_let_context((lambda x1: python_environment_get_graph(x1)), (lambda x1, x2: python_environment_set_graph(x1, x2)), (lambda x1, x2: no_metadata(x1, x2)), env, lt, (lambda inner_env: (updated_env := hydra.python.environment.PythonEnvironment(inner_env.namespaces, inner_env.bound_type_variables, inner_env.graph, inner_env.nullary_bindings, inner_env.version, inner_env.skip_casts, hydra.lib.sets.union(inline_vars(), inner_env.inline_variables)), body(updated_env))[1]))
|
|
564
|
+
def with_type_lambda(v1: hydra.python.environment.PythonEnvironment, v2: hydra.core.TypeLambda, v3: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
|
|
565
|
+
r"""Execute a computation with type lambda context."""
|
|
566
|
+
return hydra.environment.with_type_lambda_context((lambda x1: python_environment_get_graph(x1)), (lambda x1, x2: python_environment_set_graph(x1, x2)), v1, v2, v3)
|
|
567
|
+
def is_variant_unit_type(row_type: frozenlist[hydra.core.FieldType], field_name: hydra.core.Name) -> bool:
|
|
568
|
+
r"""Check if a variant field has unit type."""
|
|
569
|
+
@lru_cache(1)
|
|
570
|
+
def mfield() -> Maybe[hydra.core.FieldType]:
|
|
571
|
+
return hydra.lib.lists.find((lambda ft: hydra.lib.equality.equal(ft.name, field_name)), row_type)
|
|
572
|
+
return hydra.lib.maybes.from_maybe((lambda : False), hydra.lib.maybes.map((lambda ft: hydra.predicates.is_unit_type(hydra.strip.deannotate_type(ft.type))), mfield()))
|
|
573
|
+
def wrap_lazy_arguments(name: hydra.core.Name, args: frozenlist[hydra.python.syntax.Expression]) -> frozenlist[hydra.python.syntax.Expression]:
|
|
574
|
+
r"""Wrap specific arguments in nullary lambdas for primitives that require lazy evaluation."""
|
|
575
|
+
@lru_cache(1)
|
|
576
|
+
def dummy_expr() -> hydra.python.syntax.Expression:
|
|
577
|
+
return hydra.python.utils.py_name_to_py_expression(hydra.python.syntax.Name(""))
|
|
578
|
+
def arg_at(i: int) -> hydra.python.syntax.Expression:
|
|
579
|
+
return hydra.lib.maybes.from_maybe((lambda : dummy_expr()), hydra.lib.lists.maybe_at(i, args))
|
|
580
|
+
return hydra.lib.logic.if_else(hydra.lib.logic.and_(hydra.lib.equality.equal(name, hydra.core.Name("hydra.lib.logic.ifElse")), hydra.lib.equality.equal(hydra.lib.lists.length(args), 3)), (lambda : (arg_at(0), wrap_in_nullary_lambda(arg_at(1)), wrap_in_nullary_lambda(arg_at(2)))), (lambda : hydra.lib.logic.if_else(hydra.lib.logic.and_(hydra.lib.equality.equal(name, hydra.core.Name("hydra.lib.maybes.cases")), hydra.lib.equality.equal(hydra.lib.lists.length(args), 3)), (lambda : (arg_at(0), wrap_in_nullary_lambda(arg_at(1)), arg_at(2))), (lambda : hydra.lib.logic.if_else(hydra.lib.logic.and_(hydra.lib.logic.or_(hydra.lib.equality.equal(name, hydra.core.Name("hydra.lib.maybes.maybe")), hydra.lib.equality.equal(name, hydra.core.Name("hydra.lib.maybes.fromMaybe"))), hydra.lib.equality.gte(hydra.lib.lists.length(args), 1)), (lambda : hydra.lib.lists.cons(wrap_in_nullary_lambda(arg_at(0)), hydra.lib.lists.drop(1, args))), (lambda : args))))))
|
|
581
|
+
def term_arity_with_primitives(graph: hydra.graph.Graph, term: hydra.core.Term) -> int:
|
|
582
|
+
r"""Calculate term arity with proper primitive handling."""
|
|
583
|
+
match hydra.strip.deannotate_and_detype_term(term):
|
|
584
|
+
case hydra.core.TermApplication(value=app):
|
|
585
|
+
return hydra.lib.math.max(0, hydra.lib.math.sub(term_arity_with_primitives(graph, app.function), 1))
|
|
586
|
+
case hydra.core.TermLambda(value=lam):
|
|
587
|
+
return hydra.lib.math.add(1, term_arity_with_primitives(graph, lam.body))
|
|
588
|
+
case hydra.core.TermProject():
|
|
589
|
+
return 1
|
|
590
|
+
case hydra.core.TermUnwrap():
|
|
591
|
+
return 1
|
|
592
|
+
case hydra.core.TermCases():
|
|
593
|
+
return 1
|
|
594
|
+
case hydra.core.TermVariable(value=name):
|
|
595
|
+
return hydra.lib.maybes.maybe((lambda : 0), (lambda el: hydra.lib.maybes.maybe((lambda : hydra.arity.term_arity(el.term)), (lambda ts: hydra.arity.type_scheme_arity(ts)), el.type_scheme)), hydra.lexical.lookup_binding(graph, name))
|
|
596
|
+
case _:
|
|
597
|
+
return 0
|
|
598
|
+
def encode_application(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, app: hydra.core.Application) -> Either[hydra.errors.Error, hydra.python.syntax.Expression]:
|
|
599
|
+
r"""Encode a function application to a Python expression."""
|
|
600
|
+
@lru_cache(1)
|
|
601
|
+
def g() -> hydra.graph.Graph:
|
|
602
|
+
return python_environment_get_graph(env)
|
|
603
|
+
@lru_cache(1)
|
|
604
|
+
def term() -> hydra.core.Term:
|
|
605
|
+
return cast(hydra.core.Term, hydra.core.TermApplication(app))
|
|
606
|
+
@lru_cache(1)
|
|
607
|
+
def gathered() -> tuple[hydra.core.Term, frozenlist[hydra.core.Term]]:
|
|
608
|
+
return hydra.analysis.gather_args(term(), ())
|
|
609
|
+
@lru_cache(1)
|
|
610
|
+
def fun() -> hydra.core.Term:
|
|
611
|
+
return hydra.lib.pairs.first(gathered())
|
|
612
|
+
@lru_cache(1)
|
|
613
|
+
def args() -> frozenlist[hydra.core.Term]:
|
|
614
|
+
return hydra.lib.pairs.second(gathered())
|
|
615
|
+
@lru_cache(1)
|
|
616
|
+
def known_arity() -> int:
|
|
617
|
+
return term_arity_with_primitives(g(), fun())
|
|
618
|
+
@lru_cache(1)
|
|
619
|
+
def arity() -> int:
|
|
620
|
+
return hydra.lib.math.max(known_arity(), hydra.lib.lists.length(args()))
|
|
621
|
+
return hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda t: encode_term_inline(cx, env, False, t)), args()), (lambda pargs: (hargs := hydra.lib.lists.take(arity(), pargs), rargs := hydra.lib.lists.drop(arity(), pargs), hydra.lib.eithers.bind(encode_application_inner(cx, env, fun(), hargs, rargs), (lambda result: (lhs := hydra.lib.pairs.first(result), remaining_rargs := hydra.lib.pairs.second(result), pyapp := hydra.lib.lists.foldl((lambda t, a: hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(t), (a,))), lhs, remaining_rargs), Right(pyapp))[3])))[2]))
|
|
622
|
+
def encode_application_inner(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, fun: hydra.core.Term, hargs: frozenlist[hydra.python.syntax.Expression], rargs: frozenlist[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, tuple[hydra.python.syntax.Expression, frozenlist[hydra.python.syntax.Expression]]]:
|
|
623
|
+
r"""Inner helper for encodeApplication."""
|
|
624
|
+
@lru_cache(1)
|
|
625
|
+
def first_arg() -> hydra.python.syntax.Expression:
|
|
626
|
+
return hydra.lib.maybes.from_maybe((lambda : hydra.python.utils.py_name_to_py_expression(hydra.python.syntax.Name(""))), hydra.lib.lists.maybe_head(hargs))
|
|
627
|
+
@lru_cache(1)
|
|
628
|
+
def rest_args() -> frozenlist[hydra.python.syntax.Expression]:
|
|
629
|
+
return hydra.lib.lists.drop(1, hargs)
|
|
630
|
+
def with_rest(e: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
|
|
631
|
+
return hydra.lib.logic.if_else(hydra.lib.lists.null(rest_args()), (lambda : e), (lambda : hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(e), rest_args())))
|
|
632
|
+
@lru_cache(1)
|
|
633
|
+
def default_case() -> Either[hydra.errors.Error, tuple[hydra.python.syntax.Expression, frozenlist[hydra.python.syntax.Expression]]]:
|
|
634
|
+
return hydra.lib.eithers.bind(encode_term_inline(cx, env, False, fun), (lambda pfun: Right((hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(pfun), hargs), rargs))))
|
|
635
|
+
match hydra.strip.deannotate_and_detype_term(fun):
|
|
636
|
+
case hydra.core.TermProject(value=proj):
|
|
637
|
+
fname = proj.field
|
|
638
|
+
@lru_cache(1)
|
|
639
|
+
def field_expr() -> hydra.python.syntax.Expression:
|
|
640
|
+
return hydra.python.utils.project_from_expression(first_arg(), hydra.python.names.encode_field_name(env, fname))
|
|
641
|
+
return Right((with_rest(field_expr()), rargs))
|
|
642
|
+
case hydra.core.TermCases(value=cs):
|
|
643
|
+
return hydra.lib.eithers.bind(encode_union_elimination_inline(cx, env, cs, first_arg()), (lambda inline_expr: Right((with_rest(inline_expr), rargs))))
|
|
644
|
+
case hydra.core.TermUnwrap():
|
|
645
|
+
@lru_cache(1)
|
|
646
|
+
def value_expr() -> hydra.python.syntax.Expression:
|
|
647
|
+
return hydra.python.utils.project_from_expression(first_arg(), hydra.python.syntax.Name("value"))
|
|
648
|
+
@lru_cache(1)
|
|
649
|
+
def all_args() -> frozenlist[hydra.python.syntax.Expression]:
|
|
650
|
+
return hydra.lib.lists.concat2(rest_args(), rargs)
|
|
651
|
+
return hydra.lib.logic.if_else(hydra.lib.lists.null(all_args()), (lambda : Right((value_expr(), ()))), (lambda : Right((hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(value_expr()), all_args()), ()))))
|
|
652
|
+
case hydra.core.TermLambda():
|
|
653
|
+
return hydra.lib.eithers.bind(encode_term_inline(cx, env, False, fun), (lambda pfun: Right((hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(pfun), hargs), rargs))))
|
|
654
|
+
case hydra.core.TermVariable(value=name):
|
|
655
|
+
@lru_cache(1)
|
|
656
|
+
def g() -> hydra.graph.Graph:
|
|
657
|
+
return python_environment_get_graph(env)
|
|
658
|
+
@lru_cache(1)
|
|
659
|
+
def all_args() -> frozenlist[hydra.python.syntax.Expression]:
|
|
660
|
+
return hydra.lib.lists.concat2(hargs, rargs)
|
|
661
|
+
return hydra.lib.maybes.cases(hydra.lib.maps.lookup(name, g().primitives), (lambda : hydra.lib.maybes.maybe((lambda : hydra.lib.eithers.bind(encode_variable(cx, env, name, hargs), (lambda expr: Right((expr, rargs))))), (lambda el: hydra.lib.maybes.maybe((lambda : hydra.lib.eithers.bind(encode_variable(cx, env, name, hargs), (lambda expr: Right((expr, rargs))))), (lambda ts: (el_arity := hydra.arity.type_scheme_arity(ts), consume_count := hydra.lib.math.min(el_arity, hydra.lib.lists.length(all_args())), consumed_args := hydra.lib.lists.take(consume_count, all_args()), remaining_args := hydra.lib.lists.drop(consume_count, all_args()), hydra.lib.logic.if_else(hydra.lib.lists.null(consumed_args), (lambda : hydra.lib.eithers.bind(encode_variable(cx, env, name, ()), (lambda expr: Right((expr, rargs))))), (lambda : Right((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)), consumed_args), remaining_args)))))[4]), el.type_scheme)), hydra.lexical.lookup_binding(g(), name))), (lambda _prim: (wrapped_args := wrap_lazy_arguments(name, hargs), hydra.lib.eithers.bind(encode_variable(cx, env, name, wrapped_args), (lambda expr: Right((expr, rargs)))))[1]))
|
|
662
|
+
case _:
|
|
663
|
+
return default_case()
|
|
664
|
+
def encode_binding_as_assignment(cx: hydra.context.Context, allow_thunking: bool, env: hydra.python.environment.PythonEnvironment, binding: hydra.core.Binding) -> Either[hydra.errors.Error, hydra.python.syntax.NamedExpression]:
|
|
665
|
+
r"""Encode a binding as a walrus operator assignment."""
|
|
666
|
+
name = binding.name
|
|
667
|
+
term = binding.term
|
|
668
|
+
mts = binding.type_scheme
|
|
669
|
+
@lru_cache(1)
|
|
670
|
+
def py_name() -> hydra.python.syntax.Name:
|
|
671
|
+
return hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, name)
|
|
672
|
+
return hydra.lib.eithers.bind(encode_term_inline(cx, env, False, term), (lambda pbody: (tc := env.graph, is_complex_var := hydra.predicates.is_complex_variable(tc, name), term_is_complex := hydra.predicates.is_complex_term(tc, term), is_trivial := hydra.predicates.is_trivial_term(term), needs_thunk := hydra.lib.logic.if_else(is_trivial, (lambda : False), (lambda : hydra.lib.maybes.maybe((lambda : hydra.lib.logic.and_(allow_thunking, hydra.lib.logic.or_(is_complex_var, term_is_complex))), (lambda ts: hydra.lib.logic.and_(allow_thunking, hydra.lib.logic.and_(hydra.lib.equality.equal(hydra.arity.type_scheme_arity(ts), 0), hydra.lib.logic.or_(is_complex_var, term_is_complex)))), mts))), pterm := hydra.lib.logic.if_else(needs_thunk, (lambda : make_thunk(pbody)), (lambda : pbody)), Right(cast(hydra.python.syntax.NamedExpression, hydra.python.syntax.NamedExpressionAssignment(hydra.python.syntax.AssignmentExpression(py_name(), pterm)))))[6]))
|
|
673
|
+
def encode_term_inline(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, no_cast: bool, term: hydra.core.Term) -> Either[hydra.errors.Error, hydra.python.syntax.Expression]:
|
|
674
|
+
r"""Encode a term to a Python expression (inline form)."""
|
|
675
|
+
def encode(t: hydra.core.Term) -> Either[hydra.errors.Error, hydra.python.syntax.Expression]:
|
|
676
|
+
return encode_term_inline(cx, env, False, t)
|
|
677
|
+
def strip_type_apps(t: hydra.core.Term) -> hydra.core.Term:
|
|
678
|
+
while True:
|
|
679
|
+
match t:
|
|
680
|
+
case hydra.core.TermAnnotated(value=ann):
|
|
681
|
+
t = ann.body
|
|
682
|
+
continue
|
|
683
|
+
case hydra.core.TermTypeApplication(value=ta):
|
|
684
|
+
t = ta.body
|
|
685
|
+
continue
|
|
686
|
+
case _:
|
|
687
|
+
return t
|
|
688
|
+
def with_cast(pyexp: hydra.python.syntax.Expression) -> Either[T0, hydra.python.syntax.Expression]:
|
|
689
|
+
return hydra.lib.logic.if_else(hydra.lib.logic.or_(no_cast, env.skip_casts), (lambda : Right(pyexp)), (lambda : (tc := env.graph, (mtyp := hydra.lib.eithers.map((lambda _r: hydra.lib.pairs.first(_r)), hydra.checking.type_of(cx, tc, (), term)), hydra.lib.eithers.either((lambda _: Right(pyexp)), (lambda typ: hydra.lib.eithers.either((lambda _: Right(pyexp)), (lambda pytyp: Right(hydra.python.utils.cast_to(pytyp, pyexp))), encode_type(env, typ))), mtyp))[1])[1]))
|
|
690
|
+
match hydra.strip.deannotate_and_detype_term(term):
|
|
691
|
+
case hydra.core.TermApplication(value=app):
|
|
692
|
+
return encode_application(cx, env, app)
|
|
693
|
+
case hydra.core.TermEither(value=et):
|
|
694
|
+
return hydra.lib.eithers.either((lambda t1: hydra.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("Left")), (pyexp,)))))), (lambda t1: hydra.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("Right")), (pyexp,)))))), et)
|
|
695
|
+
case hydra.core.TermLambda(value=lam):
|
|
696
|
+
return hydra.lib.eithers.bind(analyze_python_function(cx, env, cast(hydra.core.Term, hydra.core.TermLambda(lam))), (lambda fs: (params := fs.params, bindings := fs.bindings, inner_body := fs.body, inner_env0 := fs.environment, binding_names := hydra.lib.lists.map((lambda b: b.name), bindings), inner_env := hydra.python.environment.PythonEnvironment(inner_env0.namespaces, inner_env0.bound_type_variables, inner_env0.graph, inner_env0.nullary_bindings, inner_env0.version, inner_env0.skip_casts, hydra.lib.sets.union(hydra.lib.sets.from_list(binding_names), inner_env0.inline_variables)), hydra.lib.eithers.bind(encode_term_inline(cx, inner_env, False, inner_body), (lambda pbody: (pparams := hydra.lib.lists.map((lambda v1: hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, inner_env, v1)), params), hydra.lib.logic.if_else(hydra.lib.lists.null(bindings), (lambda : Right(make_uncurried_lambda(pparams, pbody))), (lambda : hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_binding_as_assignment(cx, False, inner_env, v1)), bindings), (lambda pbinding_exprs: (pbinding_star_exprs := hydra.lib.lists.map((lambda ne: cast(hydra.python.syntax.StarNamedExpression, hydra.python.syntax.StarNamedExpressionSimple(ne))), pbinding_exprs), pbody_star_expr := hydra.python.utils.py_expression_to_py_star_named_expression(pbody), tuple_elements := hydra.lib.lists.concat2(pbinding_star_exprs, (pbody_star_expr,)), tuple_expr := hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomTuple(hydra.python.syntax.Tuple(tuple_elements)))), index_value := hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberInteger(hydra.lib.literals.int32_to_bigint(hydra.lib.lists.length(bindings))))))), indexed_expr := hydra.python.utils.primary_with_expression_slices(hydra.python.utils.py_expression_to_py_primary(tuple_expr), (index_value,)), Right(make_uncurried_lambda(pparams, hydra.python.utils.py_primary_to_py_expression(indexed_expr))))[6])))))[1])))[6]))
|
|
697
|
+
case hydra.core.TermProject(value=proj):
|
|
698
|
+
fname = proj.field
|
|
699
|
+
return Right(make_curried_lambda((hydra.python.syntax.Name("v1"),), hydra.python.utils.project_from_expression(cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction((hydra.python.syntax.Conjunction((cast(hydra.python.syntax.Inversion, hydra.python.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(Nothing(), hydra.python.syntax.BitwiseXor(Nothing(), hydra.python.syntax.BitwiseAnd(Nothing(), hydra.python.syntax.ShiftExpression(Nothing(), hydra.python.syntax.Sum(Nothing(), hydra.python.syntax.Term(Nothing(), 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("v1")))))), Nothing()))))))))), ()))),)),)))), hydra.python.names.encode_field_name(env, fname))))
|
|
700
|
+
case hydra.core.TermUnwrap():
|
|
701
|
+
return Right(make_curried_lambda((hydra.python.syntax.Name("v1"),), hydra.python.utils.project_from_expression(cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction((hydra.python.syntax.Conjunction((cast(hydra.python.syntax.Inversion, hydra.python.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(Nothing(), hydra.python.syntax.BitwiseXor(Nothing(), hydra.python.syntax.BitwiseAnd(Nothing(), hydra.python.syntax.ShiftExpression(Nothing(), hydra.python.syntax.Sum(Nothing(), hydra.python.syntax.Term(Nothing(), 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("v1")))))), Nothing()))))))))), ()))),)),)))), hydra.python.syntax.Name("value"))))
|
|
702
|
+
case hydra.core.TermCases():
|
|
703
|
+
return Right(unsupported_expression("case expressions as values are not yet supported"))
|
|
704
|
+
case hydra.core.TermLet(value=lt):
|
|
705
|
+
bindings = lt.bindings
|
|
706
|
+
body = lt.body
|
|
707
|
+
return hydra.lib.logic.if_else(hydra.lib.lists.null(bindings), (lambda : encode_term_inline(cx, env, False, body)), (lambda : with_let_inline(env, lt, (lambda inner_env: hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_binding_as_assignment(cx, False, inner_env, v1)), bindings), (lambda pbinding_exprs: hydra.lib.eithers.bind(encode_term_inline(cx, inner_env, False, body), (lambda pbody: (pbinding_star_exprs := hydra.lib.lists.map((lambda ne: cast(hydra.python.syntax.StarNamedExpression, hydra.python.syntax.StarNamedExpressionSimple(ne))), pbinding_exprs), pbody_star_expr := hydra.python.utils.py_expression_to_py_star_named_expression(pbody), tuple_elements := hydra.lib.lists.concat2(pbinding_star_exprs, (pbody_star_expr,)), tuple_expr := hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomTuple(hydra.python.syntax.Tuple(tuple_elements)))), index_value := hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberInteger(hydra.lib.literals.int32_to_bigint(hydra.lib.lists.length(bindings))))))), indexed_expr := hydra.python.utils.primary_with_expression_slices(hydra.python.utils.py_expression_to_py_primary(tuple_expr), (index_value,)), Right(hydra.python.utils.py_primary_to_py_expression(indexed_expr)))[6]))))))))
|
|
708
|
+
case hydra.core.TermList(value=terms):
|
|
709
|
+
return hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda x1: encode(x1)), terms), (lambda py_exprs: Right(hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomTuple(hydra.python.syntax.Tuple(hydra.lib.lists.map((lambda x1: hydra.python.utils.py_expression_to_py_star_named_expression(x1)), py_exprs))))))))
|
|
710
|
+
case hydra.core.TermLiteral(value=lit):
|
|
711
|
+
return encode_literal(lit)
|
|
712
|
+
case hydra.core.TermMap(value=m):
|
|
713
|
+
return hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda kv: (k := hydra.lib.pairs.first(kv), v := hydra.lib.pairs.second(kv), hydra.lib.eithers.bind(encode(k), (lambda py_k: hydra.lib.eithers.bind(encode(v), (lambda py_v: Right(cast(hydra.python.syntax.DoubleStarredKvpair, hydra.python.syntax.DoubleStarredKvpairPair(hydra.python.syntax.Kvpair(py_k, py_v)))))))))[2]), hydra.lib.maps.to_list(m)), (lambda pairs: Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("FrozenDict")), (hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomDict(hydra.python.syntax.Dict(pairs)))),)))))
|
|
714
|
+
case hydra.core.TermMaybe(value=mt):
|
|
715
|
+
return hydra.lib.maybes.maybe((lambda : Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("Nothing")), ()))), (lambda t1: hydra.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("Just")), (pyexp,)))))), mt)
|
|
716
|
+
case hydra.core.TermPair(value=p):
|
|
717
|
+
@lru_cache(1)
|
|
718
|
+
def t1() -> hydra.core.Term:
|
|
719
|
+
return hydra.lib.pairs.first(p)
|
|
720
|
+
@lru_cache(1)
|
|
721
|
+
def t2() -> hydra.core.Term:
|
|
722
|
+
return hydra.lib.pairs.second(p)
|
|
723
|
+
return hydra.lib.eithers.bind(encode(t1()), (lambda py_expr1: hydra.lib.eithers.bind(encode(t2()), (lambda py_expr2: Right(hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomTuple(hydra.python.syntax.Tuple((hydra.python.utils.py_expression_to_py_star_named_expression(py_expr1), hydra.python.utils.py_expression_to_py_star_named_expression(py_expr2)))))))))))
|
|
724
|
+
case hydra.core.TermRecord(value=r):
|
|
725
|
+
tname = r.type_name
|
|
726
|
+
fields = r.fields
|
|
727
|
+
return hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda fld: encode(fld.term)), fields), (lambda pargs: Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.names.encode_name_qualified(env, tname)), pargs))))
|
|
728
|
+
case hydra.core.TermSet(value=s):
|
|
729
|
+
return hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda x1: encode(x1)), hydra.lib.sets.to_list(s)), (lambda py_els: Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("frozenset")), (hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomSet(hydra.python.syntax.Set(hydra.lib.lists.map((lambda x1: hydra.python.utils.py_expression_to_py_star_named_expression(x1)), py_els))))),)))))
|
|
730
|
+
case hydra.core.TermTypeApplication(value=ta):
|
|
731
|
+
body = ta.body
|
|
732
|
+
return hydra.lib.eithers.bind(encode_term_inline(cx, env, True, strip_type_apps(body)), (lambda pybase: with_cast(pybase)))
|
|
733
|
+
case hydra.core.TermTypeLambda(value=tl):
|
|
734
|
+
body = tl.body
|
|
735
|
+
return with_type_lambda(env, tl, (lambda env2: encode_term_inline(cx, env2, no_cast, body)))
|
|
736
|
+
case hydra.core.TermInject(value=inj):
|
|
737
|
+
tname = inj.type_name
|
|
738
|
+
field = inj.field
|
|
739
|
+
return hydra.lib.eithers.bind(hydra.resolution.require_union_type(cx, python_environment_get_graph(env), tname), (lambda rt: hydra.lib.logic.if_else(hydra.predicates.is_enum_row_type(rt), (lambda : Right(hydra.python.utils.project_from_expression(hydra.python.utils.py_name_to_py_expression(hydra.python.names.encode_name_qualified(env, tname)), hydra.python.names.encode_enum_value(env, field.name)))), (lambda : (fname := field.name, (is_unit_variant := hydra.lib.maybes.maybe((lambda : False), (lambda ft: hydra.predicates.is_unit_type(hydra.strip.deannotate_type(ft.type))), hydra.lib.lists.find((lambda ft: hydra.lib.equality.equal(ft.name.value, fname.value)), rt)), hydra.lib.eithers.bind(hydra.lib.logic.if_else(hydra.lib.logic.or_(hydra.predicates.is_unit_term(field.term), is_unit_variant), (lambda : Right(())), (lambda : hydra.lib.eithers.bind(encode(field.term), (lambda parg: Right((parg,)))))), (lambda args: (deconflicted_name := deconflict_variant_name(True, env, tname, fname, env.graph), Right(hydra.python.utils.cast_to(hydra.python.names.type_variable_reference(env, tname), hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(deconflicted_name), args))))[1])))[1])[1]))))
|
|
740
|
+
case hydra.core.TermUnit():
|
|
741
|
+
return Right(hydra.python.utils.py_name_to_py_expression(hydra.python.utils.py_none))
|
|
742
|
+
case hydra.core.TermVariable(value=name):
|
|
743
|
+
return encode_variable(cx, env, name, ())
|
|
744
|
+
case hydra.core.TermWrap(value=wrapped):
|
|
745
|
+
tname = wrapped.type_name
|
|
746
|
+
inner = wrapped.body
|
|
747
|
+
return hydra.lib.eithers.bind(encode(inner), (lambda parg: Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.names.encode_name_qualified(env, tname)), (parg,)))))
|
|
748
|
+
case _:
|
|
749
|
+
raise TypeError("Unsupported Term")
|
|
750
|
+
def encode_union_elimination_inline(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, cs: hydra.core.CaseStatement, py_arg: hydra.python.syntax.Expression) -> Either[hydra.errors.Error, hydra.python.syntax.Expression]:
|
|
751
|
+
r"""Encode a union elimination as an inline conditional chain (isinstance-based ternary)."""
|
|
752
|
+
tname = cs.type_name
|
|
753
|
+
mdefault = cs.default
|
|
754
|
+
cases_ = cs.cases
|
|
755
|
+
return hydra.lib.eithers.bind(hydra.resolution.require_union_type(cx, python_environment_get_graph(env), tname), (lambda rt: (is_enum := hydra.predicates.is_enum_row_type(rt), value_expr := hydra.python.utils.project_from_expression(py_arg, hydra.python.syntax.Name("value")), isinstance_primary := hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("isinstance")), hydra.lib.eithers.bind(hydra.lib.maybes.maybe((lambda : Right(unsupported_expression("no matching case in inline union elimination"))), (lambda dflt: encode_term_inline(cx, env, False, dflt)), mdefault), (lambda py_default: (encode_branch := (lambda field: (fname := field.name, fterm := field.term, is_unit_variant := is_variant_unit_type(rt, fname), py_variant_name := deconflict_variant_name(True, env, tname, fname, env.graph), isinstance_check := hydra.lib.logic.if_else(is_enum, (lambda : cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction((hydra.python.syntax.Conjunction((cast(hydra.python.syntax.Inversion, hydra.python.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.utils.py_expression_to_bitwise_or(py_arg), (hydra.python.syntax.CompareOpBitwiseOrPair(hydra.python.syntax.CompareOp.EQ, hydra.python.utils.py_expression_to_bitwise_or(hydra.python.utils.py_name_to_py_expression(py_variant_name))),)))),)),))))), (lambda : hydra.python.utils.function_call(isinstance_primary, (py_arg, hydra.python.utils.py_name_to_py_expression(py_variant_name))))), hydra.lib.eithers.bind(encode_term_inline(cx, env, False, fterm), (lambda py_branch: (py_result := hydra.lib.logic.if_else(is_enum, (lambda : hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(py_branch), (py_arg,))), (lambda : hydra.lib.logic.if_else(is_unit_variant, (lambda : hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(py_branch), (py_arg,))), (lambda : hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(py_branch), (value_expr,)))))), Right((isinstance_check, py_result)))[1])))[5]), hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda x1: encode_branch(x1)), cases_), (lambda encoded_branches: (build_chain := (lambda else_expr, branch_pair: (check_expr := hydra.lib.pairs.first(branch_pair), result_expr := hydra.lib.pairs.second(branch_pair), cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionConditional(hydra.python.syntax.Conditional(hydra.python.utils.py_expression_to_disjunction(result_expr), hydra.python.utils.py_expression_to_disjunction(check_expr), else_expr))))[2]), Right(hydra.lib.lists.foldl((lambda x1, x2: build_chain(x1, x2)), py_default, hydra.lib.lists.reverse(encoded_branches))))[1])))[1])))[3]))
|
|
756
|
+
def enum_variant_pattern(env: hydra.python.environment.PythonEnvironment, type_name: hydra.core.Name, field_name: hydra.core.Name) -> hydra.python.syntax.ClosedPattern:
|
|
757
|
+
r"""Create a value pattern for an enum variant."""
|
|
758
|
+
return cast(hydra.python.syntax.ClosedPattern, hydra.python.syntax.ClosedPatternValue(hydra.python.syntax.ValuePattern(hydra.python.syntax.Attribute((hydra.python.names.encode_name(True, hydra.util.CaseConvention.PASCAL, env, type_name), hydra.python.names.encode_enum_value(env, field_name))))))
|
|
759
|
+
def variant_closed_pattern(env: hydra.python.environment.PythonEnvironment, type_name: hydra.core.Name, field_name: hydra.core.Name, py_variant_name: hydra.python.syntax.Name, row_type: T0, is_enum: bool, var_name: hydra.core.Name, should_capture: bool) -> hydra.python.syntax.ClosedPattern:
|
|
760
|
+
r"""Create a ClosedPattern for a variant based on its characteristics."""
|
|
761
|
+
return hydra.lib.logic.if_else(is_enum, (lambda : enum_variant_pattern(env, type_name, field_name)), (lambda : hydra.lib.logic.if_else(hydra.lib.logic.not_(should_capture), (lambda : class_variant_pattern_unit(py_variant_name)), (lambda : class_variant_pattern_with_capture(env, py_variant_name, var_name)))))
|
|
762
|
+
def encode_case_block(cx: T0, env: hydra.python.environment.PythonEnvironment, tname: hydra.core.Name, row_type: frozenlist[hydra.core.FieldType], is_enum: bool, encode_body: Callable[[hydra.python.environment.PythonEnvironment, hydra.core.Term], Either[T1, frozenlist[hydra.python.syntax.Statement]]], field: hydra.core.Field) -> Either[T1, hydra.python.syntax.CaseBlock]:
|
|
763
|
+
r"""Encode a single case (Field) into a CaseBlock for a match statement."""
|
|
764
|
+
fname = field.name
|
|
765
|
+
fterm = field.term
|
|
766
|
+
@lru_cache(1)
|
|
767
|
+
def stripped() -> hydra.core.Term:
|
|
768
|
+
return hydra.strip.deannotate_and_detype_term(fterm)
|
|
769
|
+
@lru_cache(1)
|
|
770
|
+
def effective_lambda() -> hydra.core.Lambda:
|
|
771
|
+
match stripped():
|
|
772
|
+
case hydra.core.TermLambda(value=lam):
|
|
773
|
+
return lam
|
|
774
|
+
case _:
|
|
775
|
+
return (synthetic_var := hydra.core.Name("_matchValue"), hydra.core.Lambda(synthetic_var, Nothing(), cast(hydra.core.Term, hydra.core.TermApplication(hydra.core.Application(stripped(), cast(hydra.core.Term, hydra.core.TermVariable(synthetic_var)))))))[1]
|
|
776
|
+
v = effective_lambda().parameter
|
|
777
|
+
raw_body = effective_lambda().body
|
|
778
|
+
@lru_cache(1)
|
|
779
|
+
def is_unit_variant() -> bool:
|
|
780
|
+
return is_variant_unit_type(row_type, fname)
|
|
781
|
+
@lru_cache(1)
|
|
782
|
+
def effective_body() -> hydra.core.Term:
|
|
783
|
+
return hydra.lib.logic.if_else(is_unit_variant(), (lambda : eliminate_unit_var(v, raw_body)), (lambda : raw_body))
|
|
784
|
+
@lru_cache(1)
|
|
785
|
+
def should_capture() -> bool:
|
|
786
|
+
return hydra.lib.logic.not_(hydra.lib.logic.or_(is_unit_variant(), hydra.lib.logic.or_(hydra.variables.is_free_variable_in_term(v, raw_body), hydra.predicates.is_unit_term(raw_body))))
|
|
787
|
+
@lru_cache(1)
|
|
788
|
+
def env2() -> hydra.python.environment.PythonEnvironment:
|
|
789
|
+
return python_environment_set_graph(hydra.scoping.extend_graph_for_lambda(python_environment_get_graph(env), effective_lambda()), env)
|
|
790
|
+
@lru_cache(1)
|
|
791
|
+
def py_variant_name() -> hydra.python.syntax.Name:
|
|
792
|
+
return deconflict_variant_name(True, env2(), tname, fname, env2().graph)
|
|
793
|
+
@lru_cache(1)
|
|
794
|
+
def pattern() -> hydra.python.syntax.ClosedPattern:
|
|
795
|
+
return variant_closed_pattern(env2(), tname, fname, py_variant_name(), row_type, is_enum, v, should_capture())
|
|
796
|
+
return hydra.lib.eithers.bind(encode_body(env2(), effective_body()), (lambda stmts: (py_body := hydra.python.utils.indented_block(Nothing(), (stmts,)), Right(hydra.python.syntax.CaseBlock(hydra.python.utils.py_closed_pattern_to_py_patterns(pattern()), Nothing(), py_body)))[1]))
|
|
797
|
+
def encode_default_case_block(encode_term: Callable[[T0], Either[T1, hydra.python.syntax.Expression]], is_full: bool, mdflt: Maybe[T0], tname: hydra.core.Name) -> Either[T1, frozenlist[hydra.python.syntax.CaseBlock]]:
|
|
798
|
+
r"""Encode the default (wildcard) case block for a match statement."""
|
|
799
|
+
return hydra.lib.eithers.bind(hydra.lib.maybes.maybe((lambda : Right(hydra.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.lib.strings.cat2("Unsupported ", hydra.names.local_name_of(tname))))))), (lambda d: hydra.lib.eithers.bind(encode_term(d), (lambda pyexpr: Right(hydra.python.utils.return_single(pyexpr))))), mdflt), (lambda stmt: (patterns := hydra.python.utils.py_closed_pattern_to_py_patterns(cast(hydra.python.syntax.ClosedPattern, hydra.python.syntax.ClosedPatternWildcard())), body := hydra.python.utils.indented_block(Nothing(), ((stmt,),)), Right((hydra.python.syntax.CaseBlock(patterns, Nothing(), body),)))[2]))
|
|
800
|
+
def is_cases_full(row_type: frozenlist[T0], cases_: frozenlist[T1]) -> bool:
|
|
801
|
+
r"""Check if union cases are fully covered."""
|
|
802
|
+
@lru_cache(1)
|
|
803
|
+
def num_cases() -> int:
|
|
804
|
+
return hydra.lib.lists.length(cases_)
|
|
805
|
+
@lru_cache(1)
|
|
806
|
+
def num_fields() -> int:
|
|
807
|
+
return hydra.lib.lists.length(row_type)
|
|
808
|
+
return hydra.lib.logic.not_(hydra.lib.equality.lt(num_cases(), num_fields()))
|
|
809
|
+
def encode_term_multiline_t_c_o(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, func_name: hydra.core.Name, param_names: frozenlist[hydra.core.Name], term: hydra.core.Term):
|
|
810
|
+
r"""Encode a term body for TCO: tail self-calls become param reassignment + continue."""
|
|
811
|
+
@lru_cache(1)
|
|
812
|
+
def stripped() -> hydra.core.Term:
|
|
813
|
+
return hydra.strip.deannotate_and_detype_term(term)
|
|
814
|
+
@lru_cache(1)
|
|
815
|
+
def gathered() -> tuple[frozenlist[hydra.core.Term], hydra.core.Term]:
|
|
816
|
+
return hydra.analysis.gather_applications(stripped())
|
|
817
|
+
@lru_cache(1)
|
|
818
|
+
def gather_args() -> frozenlist[hydra.core.Term]:
|
|
819
|
+
return hydra.lib.pairs.first(gathered())
|
|
820
|
+
@lru_cache(1)
|
|
821
|
+
def gather_fun() -> hydra.core.Term:
|
|
822
|
+
return hydra.lib.pairs.second(gathered())
|
|
823
|
+
@lru_cache(1)
|
|
824
|
+
def stripped_fun() -> hydra.core.Term:
|
|
825
|
+
return hydra.strip.deannotate_and_detype_term(gather_fun())
|
|
826
|
+
@lru_cache(1)
|
|
827
|
+
def is_self_call() -> bool:
|
|
828
|
+
match stripped_fun():
|
|
829
|
+
case hydra.core.TermVariable(value=n):
|
|
830
|
+
return hydra.lib.equality.equal(n, func_name)
|
|
831
|
+
case _:
|
|
832
|
+
return False
|
|
833
|
+
return hydra.lib.logic.if_else(hydra.lib.logic.and_(is_self_call(), hydra.lib.equality.equal(hydra.lib.lists.length(gather_args()), hydra.lib.lists.length(param_names))), (lambda : hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda a: encode_term_inline(cx, env, False, a)), gather_args()), (lambda py_args: (assignments := hydra.lib.lists.map((lambda pair: (param_name := hydra.lib.pairs.first(pair), py_arg := hydra.lib.pairs.second(pair), hydra.python.utils.assignment_statement(hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, param_name), py_arg))[2]), hydra.lib.lists.zip(param_names, py_args)), continue_stmt := cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementSimple((cast(hydra.python.syntax.SimpleStatement, hydra.python.syntax.SimpleStatementContinue()),))), Right(hydra.lib.lists.concat2(assignments, (continue_stmt,))))[2]))), (lambda : (gathered2 := hydra.analysis.gather_applications(term), (args2 := hydra.lib.pairs.first(gathered2), (body2 := hydra.lib.pairs.second(gathered2), hydra.lib.logic.if_else(hydra.lib.equality.equal(hydra.lib.lists.length(args2), 1), (lambda : (arg := hydra.lib.maybes.from_maybe((lambda : cast(hydra.core.Term, hydra.core.TermUnit())), hydra.lib.lists.maybe_head(args2)), (_hoist_arg_body_1 := (lambda v1: (lambda cs: (tname := cs.type_name, dflt := cs.default, cases_ := cs.cases, hydra.lib.eithers.bind(hydra.resolution.require_union_type(cx, python_environment_get_graph(env), tname), (lambda rt: (is_enum := hydra.predicates.is_enum_row_type(rt), is_full := is_cases_full(rt, cases_), hydra.lib.eithers.bind(encode_term_inline(cx, env, False, arg), (lambda py_arg: hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v12: encode_case_block(cx, env, tname, rt, is_enum, (lambda e2, t2: encode_term_multiline_t_c_o(cx, e2, func_name, param_names, t2)), v12)), deduplicate_case_variables(cases_)), (lambda py_cases: hydra.lib.eithers.bind(encode_default_case_block((lambda t2: encode_term_inline(cx, env, False, t2)), is_full, dflt, tname), (lambda py_dflt: (subj := cast(hydra.python.syntax.SubjectExpression, hydra.python.syntax.SubjectExpressionSimple(cast(hydra.python.syntax.NamedExpression, hydra.python.syntax.NamedExpressionSimple(py_arg)))), match_stmt := cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementMatch(hydra.python.syntax.MatchStatement(subj, hydra.lib.lists.concat2(py_cases, py_dflt)))))), Right((match_stmt,)))[2])))))))[2])))[3])(v1.value) if isinstance(v1, hydra.core.TermCases) else hydra.lib.eithers.bind(encode_term_inline(cx, env, False, term), (lambda expr: Right((hydra.python.utils.return_single(expr),))))), _hoist_arg_body_1(hydra.strip.deannotate_and_detype_term(body2)))[1])[1]), (lambda : hydra.lib.eithers.bind(encode_term_inline(cx, env, False, term), (lambda expr: Right((hydra.python.utils.return_single(expr),)))))))[1])[1])[1]))
|
|
834
|
+
@lru_cache(1)
|
|
835
|
+
def lru_cache_decorator() -> hydra.python.syntax.NamedExpression:
|
|
836
|
+
r"""Decorator for @lru_cache(1) to memoize zero-argument function results."""
|
|
837
|
+
return cast(hydra.python.syntax.NamedExpression, hydra.python.syntax.NamedExpressionSimple(hydra.python.utils.function_call(cast(hydra.python.syntax.Primary, hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("lru_cache"))))), (py_int(1),))))
|
|
838
|
+
def use_inline_type_params_for(version: hydra.python.environment.PythonVersion) -> bool:
|
|
839
|
+
r"""Version-aware inline type parameters."""
|
|
840
|
+
return hydra.lib.equality.equal(version, hydra.python.environment.PythonVersion.PYTHON312)
|
|
841
|
+
@lru_cache(1)
|
|
842
|
+
def use_inline_type_params() -> bool:
|
|
843
|
+
r"""Legacy constant for backward compatibility; use useInlineTypeParamsFor in new code."""
|
|
844
|
+
return use_inline_type_params_for(hydra.python.utils.target_python_version)
|
|
845
|
+
def extend_env_with_lambda_params(env: hydra.python.environment.PythonEnvironment, term: hydra.core.Term) -> hydra.python.environment.PythonEnvironment:
|
|
846
|
+
r"""Extend environment with lambda parameters from a term."""
|
|
847
|
+
def go(e: hydra.python.environment.PythonEnvironment, t: hydra.core.Term) -> hydra.python.environment.PythonEnvironment:
|
|
848
|
+
while True:
|
|
849
|
+
match hydra.strip.deannotate_and_detype_term(t):
|
|
850
|
+
case hydra.core.TermLambda(value=lam):
|
|
851
|
+
return (new_tc := hydra.scoping.extend_graph_for_lambda(python_environment_get_graph(e), lam), (new_env := python_environment_set_graph(new_tc, e), go(new_env, lam.body))[1])[1]
|
|
852
|
+
case _:
|
|
853
|
+
return e
|
|
854
|
+
return go(env, term)
|
|
855
|
+
def extract_case_elimination(term: hydra.core.Term) -> Maybe[hydra.core.CaseStatement]:
|
|
856
|
+
r"""Extract CaseStatement from a case elimination term."""
|
|
857
|
+
match hydra.strip.deannotate_and_detype_term(term):
|
|
858
|
+
case hydra.core.TermCases(value=cs):
|
|
859
|
+
return Just(cs)
|
|
860
|
+
case _:
|
|
861
|
+
return Nothing()
|
|
862
|
+
def gather_lambdas(term: hydra.core.Term) -> tuple[frozenlist[hydra.core.Name], hydra.core.Term]:
|
|
863
|
+
r"""Extract lambdas and their bodies from a term."""
|
|
864
|
+
def go(params: frozenlist[hydra.core.Name], t: hydra.core.Term) -> tuple[frozenlist[hydra.core.Name], hydra.core.Term]:
|
|
865
|
+
while True:
|
|
866
|
+
match hydra.strip.deannotate_and_detype_term(t):
|
|
867
|
+
case hydra.core.TermLambda(value=l):
|
|
868
|
+
params = hydra.lib.lists.concat2(params, (l.parameter,))
|
|
869
|
+
t = l.body
|
|
870
|
+
continue
|
|
871
|
+
case _:
|
|
872
|
+
return (params, t)
|
|
873
|
+
return go((), term)
|
|
874
|
+
def is_case_statement_application(term: hydra.core.Term):
|
|
875
|
+
r"""Check if a term is a case statement applied to exactly one argument."""
|
|
876
|
+
@lru_cache(1)
|
|
877
|
+
def gathered() -> tuple[frozenlist[hydra.core.Term], hydra.core.Term]:
|
|
878
|
+
return hydra.analysis.gather_applications(term)
|
|
879
|
+
@lru_cache(1)
|
|
880
|
+
def args() -> frozenlist[hydra.core.Term]:
|
|
881
|
+
return hydra.lib.pairs.first(gathered())
|
|
882
|
+
@lru_cache(1)
|
|
883
|
+
def body() -> hydra.core.Term:
|
|
884
|
+
return hydra.lib.pairs.second(gathered())
|
|
885
|
+
return hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.equality.equal(hydra.lib.lists.length(args()), 1)), (lambda : Nothing()), (lambda : (arg := hydra.lib.maybes.from_maybe((lambda : cast(hydra.core.Term, hydra.core.TermUnit())), hydra.lib.lists.maybe_head(args())), (_hoist_arg_body_1 := (lambda v1: (lambda cs: Just((cs.type_name, (cs.default, (cs.cases, arg)))))(v1.value) if isinstance(v1, hydra.core.TermCases) else Nothing()), _hoist_arg_body_1(hydra.strip.deannotate_and_detype_term(body())))[1])[1]))
|
|
886
|
+
def encode_binding_as(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, binding: hydra.core.Binding) -> Either[hydra.errors.Error, hydra.python.syntax.Statement]:
|
|
887
|
+
r"""Encode a binding as a Python statement (function definition or assignment)."""
|
|
888
|
+
name1 = binding.name
|
|
889
|
+
term1 = binding.term
|
|
890
|
+
mts = binding.type_scheme
|
|
891
|
+
@lru_cache(1)
|
|
892
|
+
def fname() -> hydra.python.syntax.Name:
|
|
893
|
+
return hydra.python.names.encode_name(True, hydra.util.CaseConvention.LOWER_SNAKE, env, name1)
|
|
894
|
+
return hydra.lib.maybes.maybe((lambda : (gathered := gather_lambdas(term1), (lambda_params := hydra.lib.pairs.first(gathered), (inner_body := hydra.lib.pairs.second(gathered), (mcsa := is_case_statement_application(inner_body), hydra.lib.maybes.maybe((lambda : (mcs := extract_case_elimination(term1), hydra.lib.maybes.maybe((lambda : hydra.lib.eithers.bind(encode_term_multiline(cx, env, term1), (lambda stmts: hydra.lib.maybes.maybe((lambda : Left(cast(hydra.errors.Error, hydra.errors.ErrorOther(hydra.errors.OtherError("encodeTermMultiline returned no statements"))))), (lambda x: Right(x)), hydra.lib.lists.maybe_head(stmts))))), (lambda cs: (tname := cs.type_name, dflt := cs.default, cases_ := cs.cases, hydra.lib.eithers.bind(hydra.resolution.require_union_type(cx, python_environment_get_graph(env), tname), (lambda rt: (is_enum := hydra.predicates.is_enum_row_type(rt), is_full := is_cases_full(rt, cases_), inner_param := hydra.python.syntax.Param(hydra.python.syntax.Name("x"), Nothing()), param := hydra.python.syntax.ParamNoDefault(inner_param, Nothing()), params := cast(hydra.python.syntax.Parameters, hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters((param,), (), Nothing()))), hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_case_block(cx, env, tname, rt, is_enum, (lambda e, t: encode_term_multiline(cx, e, t)), v1)), cases_), (lambda py_cases: hydra.lib.eithers.bind(encode_default_case_block((lambda t: encode_term_inline(cx, env, False, t)), is_full, dflt, tname), (lambda py_dflt: (subj := cast(hydra.python.syntax.SubjectExpression, hydra.python.syntax.SubjectExpressionSimple(cast(hydra.python.syntax.NamedExpression, hydra.python.syntax.NamedExpressionSimple(hydra.python.utils.py_name_to_py_expression(hydra.python.syntax.Name("x")))))), all_cases := hydra.lib.lists.concat2(py_cases, py_dflt), match_stmt := cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementMatch(hydra.python.syntax.MatchStatement(subj, all_cases))))), body := hydra.python.utils.indented_block(Nothing(), ((match_stmt,),)), func_def_raw := hydra.python.syntax.FunctionDefRaw(False, fname(), (), Just(params), Nothing(), Nothing(), body), Right(cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementFunction(hydra.python.syntax.FunctionDefinition(Nothing(), func_def_raw)))))))[5])))))[5])))[3]), mcs))[1]), (lambda csa: hydra.lib.logic.if_else(hydra.lib.lists.null(lambda_params), (lambda : (mcs := extract_case_elimination(term1), hydra.lib.maybes.maybe((lambda : hydra.lib.eithers.bind(encode_term_multiline(cx, env, term1), (lambda stmts: hydra.lib.maybes.maybe((lambda : Left(cast(hydra.errors.Error, hydra.errors.ErrorOther(hydra.errors.OtherError("encodeTermMultiline returned no statements"))))), (lambda x: Right(x)), hydra.lib.lists.maybe_head(stmts))))), (lambda cs: (tname := cs.type_name, dflt := cs.default, cases_ := cs.cases, hydra.lib.eithers.bind(hydra.resolution.require_union_type(cx, python_environment_get_graph(env), tname), (lambda rt: (is_enum := hydra.predicates.is_enum_row_type(rt), is_full := is_cases_full(rt, cases_), inner_param := hydra.python.syntax.Param(hydra.python.syntax.Name("x"), Nothing()), param := hydra.python.syntax.ParamNoDefault(inner_param, Nothing()), params := cast(hydra.python.syntax.Parameters, hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters((param,), (), Nothing()))), hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_case_block(cx, env, tname, rt, is_enum, (lambda e, t: encode_term_multiline(cx, e, t)), v1)), cases_), (lambda py_cases: hydra.lib.eithers.bind(encode_default_case_block((lambda t: encode_term_inline(cx, env, False, t)), is_full, dflt, tname), (lambda py_dflt: (subj := cast(hydra.python.syntax.SubjectExpression, hydra.python.syntax.SubjectExpressionSimple(cast(hydra.python.syntax.NamedExpression, hydra.python.syntax.NamedExpressionSimple(hydra.python.utils.py_name_to_py_expression(hydra.python.syntax.Name("x")))))), all_cases := hydra.lib.lists.concat2(py_cases, py_dflt), match_stmt := cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementMatch(hydra.python.syntax.MatchStatement(subj, all_cases))))), body := hydra.python.utils.indented_block(Nothing(), ((match_stmt,),)), func_def_raw := hydra.python.syntax.FunctionDefRaw(False, fname(), (), Just(params), Nothing(), Nothing(), body), Right(cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementFunction(hydra.python.syntax.FunctionDefinition(Nothing(), func_def_raw)))))))[5])))))[5])))[3]), mcs))[1]), (lambda : (tname := hydra.lib.pairs.first(csa), (rest1 := hydra.lib.pairs.second(csa), (dflt := hydra.lib.pairs.first(rest1), (rest2 := hydra.lib.pairs.second(rest1), (cases_ := hydra.lib.pairs.first(rest2), hydra.lib.eithers.bind(hydra.resolution.require_union_type(cx, python_environment_get_graph(env), tname), (lambda rt: (is_enum := hydra.predicates.is_enum_row_type(rt), is_full := is_cases_full(rt, cases_), captured_var_names := hydra.lib.maybes.from_maybe((lambda : ()), hydra.lib.lists.maybe_init(lambda_params)), match_lambda_param := hydra.lib.maybes.from_maybe((lambda : hydra.core.Name("")), hydra.lib.lists.maybe_last(lambda_params)), captured_params := hydra.lib.lists.map((lambda n: hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, n), Nothing()), Nothing())), captured_var_names), match_arg_name := hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, match_lambda_param), match_param := hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(match_arg_name, Nothing()), Nothing()), all_params := hydra.lib.lists.concat2(captured_params, (match_param,)), params := cast(hydra.python.syntax.Parameters, hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters(all_params, (), Nothing()))), env_with_params := extend_env_with_lambda_params(env, term1), hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_case_block(cx, env_with_params, tname, rt, is_enum, (lambda e, t: encode_term_multiline(cx, e, t)), v1)), cases_), (lambda py_cases: hydra.lib.eithers.bind(encode_default_case_block((lambda t: encode_term_inline(cx, env_with_params, False, t)), is_full, dflt, tname), (lambda py_dflt: (subj := cast(hydra.python.syntax.SubjectExpression, hydra.python.syntax.SubjectExpressionSimple(cast(hydra.python.syntax.NamedExpression, hydra.python.syntax.NamedExpressionSimple(hydra.python.utils.py_name_to_py_expression(match_arg_name))))), all_cases := hydra.lib.lists.concat2(py_cases, py_dflt), match_stmt := cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementMatch(hydra.python.syntax.MatchStatement(subj, all_cases))))), body := hydra.python.utils.indented_block(Nothing(), ((match_stmt,),)), func_def_raw := hydra.python.syntax.FunctionDefRaw(False, fname(), (), Just(params), Nothing(), Nothing(), body), Right(cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementFunction(hydra.python.syntax.FunctionDefinition(Nothing(), func_def_raw)))))))[5])))))[10])))[1])[1])[1])[1])[1]))), mcsa))[1])[1])[1])[1]), (lambda ts: hydra.lib.eithers.bind(hydra.annotations.get_term_description(cx, python_environment_get_graph(env), term1), (lambda comment: (norm_comment := hydra.lib.maybes.map(hydra.formatting.normalize_comment, comment), encode_term_assignment(cx, env, name1, term1, ts, norm_comment))[1]))), mts)
|
|
895
|
+
def encode_function_definition(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, tparams: frozenlist[hydra.core.Name], args: frozenlist[hydra.core.Name], body: hydra.core.Term, doms: frozenlist[hydra.core.Type], mcod: Maybe[hydra.core.Type], comment: Maybe[str], prefixes: frozenlist[hydra.python.syntax.Statement]) -> Either[hydra.errors.Error, hydra.python.syntax.Statement]:
|
|
896
|
+
r"""Encode a function definition with parameters and body."""
|
|
897
|
+
return hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda pair: (arg_name := hydra.lib.pairs.first(pair), typ := hydra.lib.pairs.second(pair), hydra.lib.eithers.bind(encode_type(env, typ), (lambda py_typ: Right(hydra.python.syntax.ParamNoDefault(hydra.python.syntax.Param(hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, arg_name), Just(hydra.python.syntax.Annotation(py_typ))), Nothing())))))[2]), hydra.lib.lists.zip(args, doms)), (lambda py_args: (py_params := cast(hydra.python.syntax.Parameters, hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters(py_args, (), Nothing()))), is_t_c_o := hydra.lib.logic.and_(hydra.lib.logic.not_(hydra.lib.lists.null(args)), hydra.analysis.is_self_tail_recursive(name, body)), hydra.lib.eithers.bind(hydra.lib.logic.if_else(is_t_c_o, (lambda : hydra.lib.eithers.bind(encode_term_multiline_t_c_o(cx, env, name, args, body), (lambda tco_stmts: (true_expr := cast(hydra.python.syntax.NamedExpression, hydra.python.syntax.NamedExpressionSimple(hydra.python.utils.py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomTrue())))), while_body := hydra.python.utils.indented_block(Nothing(), (hydra.lib.lists.concat2(prefixes, tco_stmts),)), while_stmt := cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementWhile(hydra.python.syntax.WhileStatement(true_expr, while_body, Nothing()))))), Right(hydra.python.utils.indented_block(comment, ((while_stmt,),))))[3]))), (lambda : hydra.lib.eithers.bind(encode_term_multiline(cx, env, body), (lambda stmts: Right(hydra.python.utils.indented_block(comment, (hydra.lib.lists.concat2(prefixes, stmts),))))))), (lambda block: hydra.lib.eithers.bind(hydra.lib.maybes.maybe((lambda : Right(Nothing())), (lambda cod: hydra.lib.eithers.bind(encode_type(env, cod), (lambda pytyp: Right(Just(pytyp))))), mcod), (lambda mreturn_type: (py_tparams := hydra.lib.logic.if_else(use_inline_type_params(), (lambda : hydra.lib.lists.map((lambda arg_: hydra.python.utils.py_name_to_py_type_parameter(hydra.python.names.encode_type_variable(arg_))), tparams)), (lambda : ())), is_thunk := hydra.lib.lists.null(args), m_decorators := hydra.lib.logic.if_else(is_thunk, (lambda : Just(hydra.python.syntax.Decorators((lru_cache_decorator(),)))), (lambda : Nothing())), py_name := hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, name), Right(cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementFunction(hydra.python.syntax.FunctionDefinition(m_decorators, hydra.python.syntax.FunctionDefRaw(False, py_name, py_tparams, Just(py_params), mreturn_type, Nothing(), block))))))))[4])))))[2]))
|
|
898
|
+
def encode_term_assignment(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, term: hydra.core.Term, ts: hydra.core.TypeScheme, comment: Maybe[str]) -> Either[hydra.errors.Error, hydra.python.syntax.Statement]:
|
|
899
|
+
r"""Encode a term assignment to a Python statement."""
|
|
900
|
+
return hydra.lib.eithers.bind(analyze_python_function(cx, env, term), (lambda fs: (tparams := fs.type_params, params := fs.params, bindings := fs.bindings, body := fs.body, doms := fs.domains, mcod := fs.codomain, env2 := fs.environment, tc := env2.graph, binding := hydra.core.Binding(name, term, Just(ts)), is_complex := hydra.predicates.is_complex_binding(tc, binding), is_trivial := hydra.predicates.is_trivial_term(term), hydra.lib.logic.if_else(hydra.lib.logic.and_(is_complex, hydra.lib.logic.not_(is_trivial)), (lambda : hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_binding_as(cx, env2, v1)), bindings), (lambda binding_stmts: encode_function_definition(cx, env2, name, tparams, params, body, doms, mcod, comment, binding_stmts)))), (lambda : hydra.lib.eithers.bind(encode_term_inline(cx, env2, False, body), (lambda body_expr: (py_name := hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env2, name), Right(hydra.python.utils.annotated_statement(comment, hydra.python.utils.assignment_statement(py_name, body_expr))))[1])))))[11]))
|
|
901
|
+
def encode_term_multiline(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, term: hydra.core.Term):
|
|
902
|
+
r"""Encode a term to a list of statements with return as final statement."""
|
|
903
|
+
@lru_cache(1)
|
|
904
|
+
def dflt_logic() -> Either[hydra.errors.Error, frozenlist[hydra.python.syntax.Statement]]:
|
|
905
|
+
return hydra.lib.eithers.bind(analyze_python_function(cx, env, term), (lambda fs: (params := fs.params, bindings := fs.bindings, inner_body := fs.body, env2 := fs.environment, hydra.lib.logic.if_else(hydra.lib.lists.null(bindings), (lambda : hydra.lib.eithers.bind(encode_term_inline(cx, env, False, term), (lambda expr: Right((hydra.python.utils.return_single(expr),))))), (lambda : hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_binding_as(cx, env2, v1)), bindings), (lambda binding_stmts: hydra.lib.eithers.bind(encode_term_multiline(cx, env2, inner_body), (lambda body_stmts: Right(hydra.lib.lists.concat2(binding_stmts, body_stmts)))))))))[4]))
|
|
906
|
+
@lru_cache(1)
|
|
907
|
+
def gathered() -> tuple[frozenlist[hydra.core.Term], hydra.core.Term]:
|
|
908
|
+
return hydra.analysis.gather_applications(term)
|
|
909
|
+
@lru_cache(1)
|
|
910
|
+
def args() -> frozenlist[hydra.core.Term]:
|
|
911
|
+
return hydra.lib.pairs.first(gathered())
|
|
912
|
+
@lru_cache(1)
|
|
913
|
+
def body() -> hydra.core.Term:
|
|
914
|
+
return hydra.lib.pairs.second(gathered())
|
|
915
|
+
return hydra.lib.logic.if_else(hydra.lib.equality.equal(hydra.lib.lists.length(args()), 1), (lambda : (arg := hydra.lib.maybes.from_maybe((lambda : cast(hydra.core.Term, hydra.core.TermUnit())), hydra.lib.lists.maybe_head(args())), (_hoist_arg_body_1 := (lambda v1: (lambda cs: (tname := cs.type_name, dflt := cs.default, cases_ := cs.cases, hydra.lib.eithers.bind(hydra.resolution.require_union_type(cx, python_environment_get_graph(env), tname), (lambda rt: (is_enum := hydra.predicates.is_enum_row_type(rt), is_full := is_cases_full(rt, cases_), hydra.lib.eithers.bind(encode_term_inline(cx, env, False, arg), (lambda py_arg: hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v12: encode_case_block(cx, env, tname, rt, is_enum, (lambda e, t: encode_term_multiline(cx, e, t)), v12)), deduplicate_case_variables(cases_)), (lambda py_cases: hydra.lib.eithers.bind(encode_default_case_block((lambda t: encode_term_inline(cx, env, False, t)), is_full, dflt, tname), (lambda py_dflt: (subj := cast(hydra.python.syntax.SubjectExpression, hydra.python.syntax.SubjectExpressionSimple(cast(hydra.python.syntax.NamedExpression, hydra.python.syntax.NamedExpressionSimple(py_arg)))), match_stmt := cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement, hydra.python.syntax.CompoundStatementMatch(hydra.python.syntax.MatchStatement(subj, hydra.lib.lists.concat2(py_cases, py_dflt)))))), Right((match_stmt,)))[2])))))))[2])))[3])(v1.value) if isinstance(v1, hydra.core.TermCases) else dflt_logic()), _hoist_arg_body_1(hydra.strip.deannotate_and_detype_term(body())))[1])[1]), (lambda : dflt_logic()))
|
|
916
|
+
def encode_bindings_as_defs(env: T0, encode_binding: Callable[[T0, T1], Either[T2, T3]], bindings: frozenlist[T1]) -> Either[T2, frozenlist[T3]]:
|
|
917
|
+
r"""Encode bindings as function definitions."""
|
|
918
|
+
return hydra.lib.eithers.map_list((lambda v1: encode_binding(env, v1)), bindings)
|
|
919
|
+
def encode_field_type(cx: T0, env: hydra.python.environment.PythonEnvironment, field_type: hydra.core.FieldType) -> Either[hydra.errors.Error, hydra.python.syntax.Statement]:
|
|
920
|
+
r"""Encode a field type for record definitions (field: type annotation)."""
|
|
921
|
+
fname = field_type.name
|
|
922
|
+
ftype = field_type.type
|
|
923
|
+
return hydra.lib.eithers.bind(hydra.annotations.get_type_description(cx, python_environment_get_graph(env), ftype), (lambda comment: (py_name := cast(hydra.python.syntax.SingleTarget, hydra.python.syntax.SingleTargetName(hydra.python.names.encode_field_name(env, fname))), hydra.lib.eithers.bind(encode_type(env, ftype), (lambda py_type: (annotated_py_type := hydra.python.utils.annotated_expression(comment, py_type), Right(hydra.python.utils.py_assignment_to_py_statement(cast(hydra.python.syntax.Assignment, hydra.python.syntax.AssignmentTyped(hydra.python.syntax.TypedAssignment(py_name, annotated_py_type, Nothing()))))))[1])))[1]))
|
|
924
|
+
def encode_name_constants(env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, fields: frozenlist[hydra.core.FieldType]) -> frozenlist[hydra.python.syntax.Statement]:
|
|
925
|
+
r"""Generate name constants for a type as class-level attributes."""
|
|
926
|
+
def to_stmt(pair: tuple[hydra.python.syntax.Name, hydra.core.Name]) -> hydra.python.syntax.Statement:
|
|
927
|
+
return hydra.python.utils.assignment_statement(hydra.lib.pairs.first(pair), 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"))), (hydra.python.utils.double_quoted_string(hydra.lib.pairs.second(pair).value),)))
|
|
928
|
+
@lru_cache(1)
|
|
929
|
+
def name_pair() -> tuple[hydra.python.syntax.Name, hydra.core.Name]:
|
|
930
|
+
return (hydra.python.names.encode_constant_for_type_name(env, name), name)
|
|
931
|
+
@lru_cache(1)
|
|
932
|
+
def field_pairs() -> frozenlist[tuple[hydra.python.syntax.Name, hydra.core.Name]]:
|
|
933
|
+
return hydra.lib.lists.map((lambda field: (hydra.python.names.encode_constant_for_field_name(env, name, field.name), field.name)), fields)
|
|
934
|
+
return hydra.lib.lists.map((lambda x1: to_stmt(x1)), hydra.lib.lists.cons(name_pair(), field_pairs()))
|
|
935
|
+
def generic_arg(tparam_list: frozenlist[hydra.core.Name]) -> Maybe[hydra.python.syntax.Expression]:
|
|
936
|
+
r"""Create Generic[...] argument expression for class definition."""
|
|
937
|
+
return hydra.lib.logic.if_else(hydra.lib.lists.null(tparam_list), (lambda : Nothing()), (lambda : Just(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"))))), hydra.lib.lists.map((lambda n: cast(hydra.python.syntax.Expression, hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction((hydra.python.syntax.Conjunction((cast(hydra.python.syntax.Inversion, hydra.python.syntax.InversionSimple(hydra.python.syntax.Comparison(hydra.python.syntax.BitwiseOr(Nothing(), hydra.python.syntax.BitwiseXor(Nothing(), hydra.python.syntax.BitwiseAnd(Nothing(), hydra.python.syntax.ShiftExpression(Nothing(), hydra.python.syntax.Sum(Nothing(), hydra.python.syntax.Term(Nothing(), 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.names.encode_type_variable(n)))))), Nothing()))))))))), ()))),)),))))), tparam_list))))))
|
|
938
|
+
def encode_record_type(cx: T0, env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, row_type: frozenlist[hydra.core.FieldType], comment: Maybe[str]) -> Either[hydra.errors.Error, hydra.python.syntax.Statement]:
|
|
939
|
+
r"""Encode a record type as a Python dataclass."""
|
|
940
|
+
return hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_field_type(cx, env, v1)), row_type), (lambda py_fields: (const_stmts := encode_name_constants(env, name, row_type), body := hydra.python.utils.indented_block(comment, (py_fields, const_stmts)), bound_vars := env.bound_type_variables, tparam_list := hydra.lib.pairs.first(bound_vars), m_generic_arg := generic_arg(tparam_list), args := hydra.lib.maybes.maybe((lambda : Nothing()), (lambda a: Just(hydra.python.utils.py_expressions_to_py_args((a,)))), m_generic_arg), decs := Just(hydra.python.syntax.Decorators((dataclass_decorator(),))), py_name := hydra.python.names.encode_name(False, hydra.util.CaseConvention.PASCAL, env, name), no_type_params := (), Right(hydra.python.utils.py_class_definition_to_py_statement(hydra.python.syntax.ClassDefinition(decs, py_name, no_type_params, args, body))))[9]))
|
|
941
|
+
def environment_type_parameters(env: hydra.python.environment.PythonEnvironment) -> frozenlist[hydra.python.syntax.TypeParameter]:
|
|
942
|
+
r"""Get type parameters from environment as Python TypeParameters."""
|
|
943
|
+
return hydra.lib.lists.map((lambda arg_: hydra.python.utils.py_name_to_py_type_parameter(hydra.python.names.encode_type_variable(arg_))), hydra.lib.pairs.first(env.bound_type_variables))
|
|
944
|
+
def type_alias_statement_for(env: hydra.python.environment.PythonEnvironment, name: hydra.python.syntax.Name, tparams: frozenlist[hydra.python.syntax.TypeParameter], mcomment: Maybe[str], tyexpr: hydra.python.syntax.Expression) -> hydra.python.syntax.Statement:
|
|
945
|
+
r"""Version-aware type alias statement generation."""
|
|
946
|
+
return hydra.lib.logic.if_else(use_inline_type_params_for(env.version), (lambda : hydra.python.utils.type_alias_statement(name, tparams, mcomment, tyexpr)), (lambda : hydra.python.utils.type_alias_statement310(name, tparams, mcomment, tyexpr)))
|
|
947
|
+
def encode_type_def_single(env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, comment: Maybe[str], type_expr: hydra.python.syntax.Expression) -> frozenlist[hydra.python.syntax.Statement]:
|
|
948
|
+
r"""Encode a simple type alias definition."""
|
|
949
|
+
@lru_cache(1)
|
|
950
|
+
def py_name() -> hydra.python.syntax.Name:
|
|
951
|
+
return hydra.python.names.encode_name(False, hydra.util.CaseConvention.PASCAL, env, name)
|
|
952
|
+
@lru_cache(1)
|
|
953
|
+
def tparams() -> frozenlist[hydra.python.syntax.TypeParameter]:
|
|
954
|
+
return environment_type_parameters(env)
|
|
955
|
+
return (type_alias_statement_for(env, py_name(), tparams(), comment, type_expr),)
|
|
956
|
+
def encode_enum_value_assignment(cx: T0, env: hydra.python.environment.PythonEnvironment, field_type: hydra.core.FieldType) -> Either[hydra.errors.Error, frozenlist[hydra.python.syntax.Statement]]:
|
|
957
|
+
r"""Encode an enum value assignment statement with optional comment."""
|
|
958
|
+
fname = field_type.name
|
|
959
|
+
ftype = field_type.type
|
|
960
|
+
return hydra.lib.eithers.bind(hydra.annotations.get_type_description(cx, python_environment_get_graph(env), ftype), (lambda mcomment: (py_name := hydra.python.names.encode_enum_value(env, fname), fname_str := fname.value, py_value := 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"))), (hydra.python.utils.double_quoted_string(fname_str),)), assign_stmt := hydra.python.utils.assignment_statement(py_name, py_value), Right(hydra.lib.maybes.maybe((lambda : (assign_stmt,)), (lambda c: (assign_stmt, hydra.python.utils.py_expression_to_py_statement(hydra.python.utils.triple_quoted_string(c)))), mcomment)))[4]))
|
|
961
|
+
def encode_type_quoted(env: hydra.python.environment.PythonEnvironment, typ: hydra.core.Type) -> Either[T0, hydra.python.syntax.Expression]:
|
|
962
|
+
r"""Encode a type to a Python expression, quoting if the type has free variables."""
|
|
963
|
+
return hydra.lib.eithers.bind(encode_type(env, typ), (lambda pytype: Right(hydra.lib.logic.if_else(hydra.lib.sets.null(hydra.variables.free_variables_in_type(typ)), (lambda : pytype), (lambda : hydra.python.utils.double_quoted_string(hydra.serialization.print_expr(hydra.python.serde.encode_expression(pytype))))))))
|
|
964
|
+
def find_type_params(env: hydra.python.environment.PythonEnvironment, typ: hydra.core.Type) -> frozenlist[hydra.core.Name]:
|
|
965
|
+
r"""Find type parameters in a type that are bound in the environment."""
|
|
966
|
+
@lru_cache(1)
|
|
967
|
+
def bound_vars() -> FrozenDict[hydra.core.Name, hydra.python.syntax.Name]:
|
|
968
|
+
return hydra.lib.pairs.second(env.bound_type_variables)
|
|
969
|
+
def is_bound(v: hydra.core.Name) -> bool:
|
|
970
|
+
return hydra.lib.maybes.is_just(hydra.lib.maps.lookup(v, bound_vars()))
|
|
971
|
+
return hydra.lib.lists.filter((lambda x1: is_bound(x1)), hydra.lib.sets.to_list(hydra.variables.free_variables_in_type(typ)))
|
|
972
|
+
def variant_args(ptype: hydra.python.syntax.Expression, tparams: frozenlist[hydra.core.Name]) -> hydra.python.syntax.Args:
|
|
973
|
+
r"""Create args for variant (Node[type], Generic[tparams])."""
|
|
974
|
+
return hydra.python.utils.py_expressions_to_py_args(hydra.lib.maybes.cat((Just(hydra.python.utils.py_primary_to_py_expression(hydra.python.utils.primary_with_expression_slices(cast(hydra.python.syntax.Primary, hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("Node"))))), (ptype,)))), generic_arg(tparams))))
|
|
975
|
+
def encode_union_field(cx: T0, env: hydra.python.environment.PythonEnvironment, union_name: hydra.core.Name, field_type: hydra.core.FieldType) -> Either[hydra.errors.Error, hydra.python.syntax.Statement]:
|
|
976
|
+
r"""Encode a union field as a variant class."""
|
|
977
|
+
fname = field_type.name
|
|
978
|
+
ftype = field_type.type
|
|
979
|
+
return hydra.lib.eithers.bind(hydra.annotations.get_type_description(cx, python_environment_get_graph(env), ftype), (lambda fcomment: (is_unit := hydra.lib.equality.equal(hydra.strip.deannotate_type(ftype), cast(hydra.core.Type, hydra.core.TypeUnit())), var_name := deconflict_variant_name(False, env, union_name, fname, env.graph), tparam_names := find_type_params(env, ftype), tparam_py_names := hydra.lib.lists.map((lambda x1: hydra.python.names.encode_type_variable(x1)), tparam_names), field_params := hydra.lib.lists.map((lambda x1: hydra.python.utils.py_name_to_py_type_parameter(x1)), tparam_py_names), body := hydra.lib.logic.if_else(is_unit, (lambda : hydra.python.utils.indented_block(fcomment, (hydra.python.utils.unit_variant_methods(var_name),))), (lambda : hydra.python.utils.indented_block(fcomment, ()))), hydra.lib.eithers.bind(hydra.lib.logic.if_else(is_unit, (lambda : Right(Nothing())), (lambda : hydra.lib.eithers.bind(encode_type_quoted(env, ftype), (lambda quoted_type: Right(Just(variant_args(quoted_type, ()))))))), (lambda margs: Right(hydra.python.utils.py_class_definition_to_py_statement(hydra.python.syntax.ClassDefinition(Nothing(), var_name, field_params, margs, body))))))[6]))
|
|
980
|
+
def encode_union_field_alt(env: hydra.python.environment.PythonEnvironment, union_name: hydra.core.Name, field_type: hydra.core.FieldType) -> hydra.python.syntax.Primary:
|
|
981
|
+
r"""Encode a union field as a primary expression for | alternatives."""
|
|
982
|
+
fname = field_type.name
|
|
983
|
+
ftype = field_type.type
|
|
984
|
+
@lru_cache(1)
|
|
985
|
+
def tparam_names() -> frozenlist[hydra.core.Name]:
|
|
986
|
+
return find_type_params(env, ftype)
|
|
987
|
+
@lru_cache(1)
|
|
988
|
+
def tparams() -> frozenlist[hydra.python.syntax.Name]:
|
|
989
|
+
return hydra.lib.lists.map((lambda x1: hydra.python.names.encode_type_variable(x1)), tparam_names())
|
|
990
|
+
@lru_cache(1)
|
|
991
|
+
def name_prim() -> hydra.python.syntax.Primary:
|
|
992
|
+
return hydra.python.utils.py_name_to_py_primary(hydra.python.names.variant_name(False, env, union_name, fname))
|
|
993
|
+
return hydra.lib.logic.if_else(hydra.lib.lists.null(tparams()), (lambda : name_prim()), (lambda : (tparam_exprs := hydra.lib.lists.map((lambda x1: hydra.python.utils.py_name_to_py_expression(x1)), tparams()), hydra.python.utils.primary_with_expression_slices(name_prim(), tparam_exprs))[1]))
|
|
994
|
+
def union_type_statements_for(env: hydra.python.environment.PythonEnvironment, name: hydra.python.syntax.Name, tparams: frozenlist[hydra.python.syntax.TypeParameter], mcomment: Maybe[str], tyexpr: hydra.python.syntax.Expression, extra_stmts: frozenlist[hydra.python.syntax.Statement]) -> frozenlist[hydra.python.syntax.Statement]:
|
|
995
|
+
r"""Version-aware union type statement generation."""
|
|
996
|
+
return hydra.lib.logic.if_else(use_inline_type_params_for(env.version), (lambda : hydra.lib.lists.concat2((hydra.python.utils.type_alias_statement(name, tparams, mcomment, tyexpr),), extra_stmts)), (lambda : hydra.python.utils.union_type_class_statements310(name, mcomment, tyexpr, extra_stmts)))
|
|
997
|
+
def encode_union_type(cx: T0, env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, row_type: frozenlist[hydra.core.FieldType], comment: Maybe[str]) -> Either[hydra.errors.Error, frozenlist[hydra.python.syntax.Statement]]:
|
|
998
|
+
r"""Encode a union type as an enum (for unit-only fields) or variant classes."""
|
|
999
|
+
return hydra.lib.logic.if_else(hydra.predicates.is_enum_row_type(row_type), (lambda : hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_enum_value_assignment(cx, env, v1)), row_type), (lambda vals: (body := hydra.python.utils.indented_block(comment, vals), enum_name := hydra.python.syntax.Name("Enum"), args := Just(hydra.python.utils.py_expressions_to_py_args((hydra.python.utils.py_name_to_py_expression(enum_name),))), py_name := hydra.python.names.encode_name(False, hydra.util.CaseConvention.PASCAL, env, name), type_const_stmt := hydra.python.utils.dotted_assignment_statement(py_name, hydra.python.names.encode_constant_for_type_name(env, name), 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"))), (hydra.python.utils.double_quoted_string(name.value),))), Right((hydra.python.utils.py_class_definition_to_py_statement(hydra.python.syntax.ClassDefinition(Nothing(), py_name, (), args, body)), type_const_stmt)))[5]))), (lambda : (const_stmts := encode_name_constants(env, name, row_type), hydra.lib.eithers.bind(hydra.lib.eithers.map_list((lambda v1: encode_union_field(cx, env, name, v1)), row_type), (lambda field_stmts: (tparams := environment_type_parameters(env), union_alts := hydra.lib.lists.map((lambda v1: encode_union_field_alt(env, name, v1)), row_type), union_stmts := union_type_statements_for(env, hydra.python.names.encode_name(False, hydra.util.CaseConvention.PASCAL, env, name), tparams, comment, hydra.python.utils.or_expression(union_alts), const_stmts), Right(hydra.lib.lists.concat2(field_stmts, union_stmts)))[3])))[1]))
|
|
1000
|
+
def encode_wrapped_type(env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, typ: hydra.core.Type, comment: Maybe[str]) -> Either[T0, frozenlist[hydra.python.syntax.Statement]]:
|
|
1001
|
+
r"""Encode a wrapped type (newtype) to a Python class definition."""
|
|
1002
|
+
@lru_cache(1)
|
|
1003
|
+
def tparam_list() -> frozenlist[hydra.core.Name]:
|
|
1004
|
+
return hydra.lib.pairs.first(env.bound_type_variables)
|
|
1005
|
+
return hydra.lib.eithers.bind(encode_type_quoted(env, typ), (lambda ptype_quoted: (py_name := hydra.python.names.encode_name(False, hydra.util.CaseConvention.PASCAL, env, name), body := hydra.python.utils.indented_block(comment, ()), type_const_stmt := hydra.python.utils.dotted_assignment_statement(py_name, hydra.python.names.encode_constant_for_type_name(env, name), 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"))), (hydra.python.utils.double_quoted_string(name.value),))), Right((hydra.python.utils.py_class_definition_to_py_statement(hydra.python.syntax.ClassDefinition(Nothing(), py_name, hydra.lib.lists.map((lambda arg_: hydra.python.utils.py_name_to_py_type_parameter(hydra.python.names.encode_type_variable(arg_))), find_type_params(env, typ)), Just(variant_args(ptype_quoted, tparam_list())), body)), type_const_stmt)))[3]))
|
|
1006
|
+
def extend_env_with_type_var(env: hydra.python.environment.PythonEnvironment, var_: hydra.core.Name) -> hydra.python.environment.PythonEnvironment:
|
|
1007
|
+
r"""Extend a PythonEnvironment with a new bound type variable."""
|
|
1008
|
+
old_bound = env.bound_type_variables
|
|
1009
|
+
@lru_cache(1)
|
|
1010
|
+
def tparam_list() -> frozenlist[hydra.core.Name]:
|
|
1011
|
+
return hydra.lib.pairs.first(old_bound)
|
|
1012
|
+
@lru_cache(1)
|
|
1013
|
+
def tparam_map() -> FrozenDict[hydra.core.Name, hydra.python.syntax.Name]:
|
|
1014
|
+
return hydra.lib.pairs.second(old_bound)
|
|
1015
|
+
@lru_cache(1)
|
|
1016
|
+
def new_list() -> frozenlist[hydra.core.Name]:
|
|
1017
|
+
return hydra.lib.lists.concat2(tparam_list(), (var_,))
|
|
1018
|
+
@lru_cache(1)
|
|
1019
|
+
def new_map() -> FrozenDict[hydra.core.Name, hydra.python.syntax.Name]:
|
|
1020
|
+
return hydra.lib.maps.insert(var_, hydra.python.names.encode_type_variable(var_), tparam_map())
|
|
1021
|
+
return hydra.python.environment.PythonEnvironment(env.namespaces, (new_list(), new_map()), env.graph, env.nullary_bindings, env.version, env.skip_casts, env.inline_variables)
|
|
1022
|
+
def encode_type_assignment_inner(cx: T0, env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, typ: hydra.core.Type, comment: Maybe[str]) -> Either[hydra.errors.Error, frozenlist[hydra.python.syntax.Statement]]:
|
|
1023
|
+
r"""Encode the inner type definition, unwrapping forall types."""
|
|
1024
|
+
while True:
|
|
1025
|
+
@lru_cache(1)
|
|
1026
|
+
def stripped() -> hydra.core.Type:
|
|
1027
|
+
return hydra.strip.deannotate_type(typ)
|
|
1028
|
+
@lru_cache(1)
|
|
1029
|
+
def dflt() -> Either[T1, frozenlist[hydra.python.syntax.Statement]]:
|
|
1030
|
+
return hydra.lib.eithers.bind(encode_type(env, typ), (lambda type_expr: Right(encode_type_def_single(env, name, comment, type_expr))))
|
|
1031
|
+
match stripped():
|
|
1032
|
+
case hydra.core.TypeForall(value=ft):
|
|
1033
|
+
return (tvar := ft.parameter, (body := ft.body, (new_env := extend_env_with_type_var(env, tvar), encode_type_assignment_inner(cx, new_env, name, body, comment))[1])[1])[1]
|
|
1034
|
+
case hydra.core.TypeRecord(value=rt):
|
|
1035
|
+
return hydra.lib.eithers.map((lambda s: (s,)), encode_record_type(cx, env, name, rt, comment))
|
|
1036
|
+
case hydra.core.TypeUnion(value=rt2):
|
|
1037
|
+
return encode_union_type(cx, env, name, rt2, comment)
|
|
1038
|
+
case hydra.core.TypeWrap(value=wt):
|
|
1039
|
+
return encode_wrapped_type(env, name, wt, comment)
|
|
1040
|
+
case _:
|
|
1041
|
+
return dflt()
|
|
1042
|
+
def encode_type_assignment(cx: T0, env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name, typ: hydra.core.Type, comment: Maybe[str]) -> Either[hydra.errors.Error, frozenlist[frozenlist[hydra.python.syntax.Statement]]]:
|
|
1043
|
+
r"""Encode a type definition, dispatching based on type structure."""
|
|
1044
|
+
return hydra.lib.eithers.bind(encode_type_assignment_inner(cx, env, name, typ, comment), (lambda def_stmts: Right(hydra.lib.lists.map((lambda s: (s,)), def_stmts))))
|
|
1045
|
+
def encode_definition(cx: hydra.context.Context, env: hydra.python.environment.PythonEnvironment, def_: hydra.packaging.Definition) -> Either[hydra.errors.Error, frozenlist[frozenlist[hydra.python.syntax.Statement]]]:
|
|
1046
|
+
r"""Encode a definition (term or type) to Python statements."""
|
|
1047
|
+
match def_:
|
|
1048
|
+
case hydra.packaging.DefinitionTerm(value=td):
|
|
1049
|
+
name = td.name
|
|
1050
|
+
term = td.term
|
|
1051
|
+
@lru_cache(1)
|
|
1052
|
+
def typ() -> hydra.core.TypeScheme:
|
|
1053
|
+
return hydra.lib.maybes.maybe((lambda : hydra.core.TypeScheme((), cast(hydra.core.Type, hydra.core.TypeVariable(hydra.core.Name("hydra.core.Unit"))), Nothing())), (lambda x: x), td.type_scheme)
|
|
1054
|
+
return hydra.lib.eithers.bind(hydra.annotations.get_term_description(cx, python_environment_get_graph(env), term), (lambda comment: (norm_comment := hydra.lib.maybes.map(hydra.formatting.normalize_comment, comment), hydra.lib.eithers.bind(encode_term_assignment(cx, env, name, term, typ(), norm_comment), (lambda stmt: Right(((stmt,),)))))[1]))
|
|
1055
|
+
case hydra.packaging.DefinitionType(value=td2):
|
|
1056
|
+
name = td2.name
|
|
1057
|
+
typ = td2.type_scheme.body
|
|
1058
|
+
return hydra.lib.eithers.bind(hydra.annotations.get_type_description(cx, python_environment_get_graph(env), typ), (lambda comment: (norm_comment := hydra.lib.maybes.map(hydra.formatting.normalize_comment, comment), encode_type_assignment(cx, env, name, typ, norm_comment))[1]))
|
|
1059
|
+
case _:
|
|
1060
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
1061
|
+
def encode_field(cx: T0, env: hydra.python.environment.PythonEnvironment, field: hydra.core.Field, encode_term: Callable[[hydra.core.Term], Either[T1, T2]]) -> Either[T1, tuple[hydra.python.syntax.Name, T2]]:
|
|
1062
|
+
r"""Encode a field (name-value pair) to a Python (Name, Expression) pair."""
|
|
1063
|
+
fname = field.name
|
|
1064
|
+
fterm = field.term
|
|
1065
|
+
return hydra.lib.eithers.bind(encode_term(fterm), (lambda pterm: Right((hydra.python.names.encode_field_name(env, fname), pterm))))
|
|
1066
|
+
def set_meta_type_variables(m: hydra.python.environment.PythonModuleMetadata, tvars: frozenset[hydra.core.Name]) -> hydra.python.environment.PythonModuleMetadata:
|
|
1067
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, tvars, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1068
|
+
def set_meta_uses_annotated(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1069
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, b, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1070
|
+
def set_meta_uses_callable(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1071
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, b, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1072
|
+
def set_meta_uses_dataclass(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1073
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, b, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1074
|
+
def set_meta_uses_decimal(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1075
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, b, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1076
|
+
def set_meta_uses_either(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1077
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, b, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1078
|
+
def set_meta_uses_enum(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1079
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, b, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1080
|
+
def set_meta_uses_frozen_dict(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1081
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, b, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1082
|
+
def set_meta_uses_frozen_list(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1083
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, b, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1084
|
+
def set_meta_uses_generic(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1085
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, b, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1086
|
+
def set_meta_uses_maybe(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1087
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, b, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1088
|
+
def extend_meta_for_type(top_level: bool, is_term_annot: bool, typ: hydra.core.Type, meta: hydra.python.environment.PythonModuleMetadata):
|
|
1089
|
+
r"""Extend metadata based on a type (used during module encoding)."""
|
|
1090
|
+
current_tvars = meta.type_variables
|
|
1091
|
+
@lru_cache(1)
|
|
1092
|
+
def new_tvars() -> frozenset[hydra.core.Name]:
|
|
1093
|
+
return collect_type_variables(current_tvars, typ)
|
|
1094
|
+
@lru_cache(1)
|
|
1095
|
+
def meta_with_tvars() -> hydra.python.environment.PythonModuleMetadata:
|
|
1096
|
+
return set_meta_type_variables(meta, new_tvars())
|
|
1097
|
+
@lru_cache(1)
|
|
1098
|
+
def meta_with_subtypes() -> hydra.python.environment.PythonModuleMetadata:
|
|
1099
|
+
return hydra.lib.lists.foldl((lambda m, t: extend_meta_for_type(False, is_term_annot, t, m)), meta_with_tvars(), hydra.rewriting.subtypes(typ))
|
|
1100
|
+
def _hoist_meta_with_subtypes_body_1(v1):
|
|
1101
|
+
match v1:
|
|
1102
|
+
case hydra.core.FloatType.BIGFLOAT:
|
|
1103
|
+
return set_meta_uses_decimal(meta_with_subtypes(), True)
|
|
1104
|
+
case _:
|
|
1105
|
+
return meta_with_subtypes()
|
|
1106
|
+
def _hoist_meta_with_subtypes_body_2(v1):
|
|
1107
|
+
match v1:
|
|
1108
|
+
case hydra.core.LiteralTypeDecimal():
|
|
1109
|
+
return set_meta_uses_decimal(meta_with_subtypes(), True)
|
|
1110
|
+
case hydra.core.LiteralTypeFloat(value=ft):
|
|
1111
|
+
return _hoist_meta_with_subtypes_body_1(ft)
|
|
1112
|
+
case _:
|
|
1113
|
+
return meta_with_subtypes()
|
|
1114
|
+
match hydra.strip.deannotate_type(typ):
|
|
1115
|
+
case hydra.core.TypeFunction(value=ft):
|
|
1116
|
+
cod = ft.codomain
|
|
1117
|
+
dom = ft.domain
|
|
1118
|
+
@lru_cache(1)
|
|
1119
|
+
def meta2() -> hydra.python.environment.PythonModuleMetadata:
|
|
1120
|
+
return extend_meta_for_type(top_level, is_term_annot, cod, meta_with_subtypes())
|
|
1121
|
+
@lru_cache(1)
|
|
1122
|
+
def meta3() -> hydra.python.environment.PythonModuleMetadata:
|
|
1123
|
+
return extend_meta_for_type(False, is_term_annot, dom, meta2())
|
|
1124
|
+
return hydra.lib.logic.if_else(hydra.lib.logic.and_(is_term_annot, top_level), (lambda : meta3()), (lambda : set_meta_uses_callable(meta3(), True)))
|
|
1125
|
+
case hydra.core.TypeList():
|
|
1126
|
+
return set_meta_uses_frozen_list(meta_with_subtypes(), True)
|
|
1127
|
+
case hydra.core.TypeMap():
|
|
1128
|
+
return set_meta_uses_frozen_dict(meta_with_subtypes(), True)
|
|
1129
|
+
case hydra.core.TypeMaybe():
|
|
1130
|
+
return set_meta_uses_maybe(meta_with_subtypes(), True)
|
|
1131
|
+
case hydra.core.TypeEither():
|
|
1132
|
+
return set_meta_uses_either(meta_with_subtypes(), True)
|
|
1133
|
+
case hydra.core.TypeLiteral(value=lt):
|
|
1134
|
+
return _hoist_meta_with_subtypes_body_2(lt)
|
|
1135
|
+
case hydra.core.TypeUnion(value=rt):
|
|
1136
|
+
return hydra.lib.logic.if_else(hydra.predicates.is_enum_row_type(rt), (lambda : set_meta_uses_enum(meta_with_subtypes(), True)), (lambda : hydra.lib.logic.if_else(hydra.lib.logic.not_(hydra.lib.lists.null(rt)), (lambda : set_meta_uses_node(meta_with_subtypes(), True)), (lambda : meta_with_subtypes()))))
|
|
1137
|
+
case hydra.core.TypeForall(value=ft2):
|
|
1138
|
+
body = ft2.body
|
|
1139
|
+
@lru_cache(1)
|
|
1140
|
+
def meta_for_wrap() -> hydra.python.environment.PythonModuleMetadata:
|
|
1141
|
+
return dig_for_wrap(is_term_annot, meta_with_subtypes(), body)
|
|
1142
|
+
def _hoist_meta_for_wrap_body_1(v1):
|
|
1143
|
+
match v1:
|
|
1144
|
+
case hydra.core.TypeRecord():
|
|
1145
|
+
return set_meta_uses_generic(meta_for_wrap(), True)
|
|
1146
|
+
case _:
|
|
1147
|
+
return meta_for_wrap()
|
|
1148
|
+
return _hoist_meta_for_wrap_body_1(hydra.strip.deannotate_type(body))
|
|
1149
|
+
case hydra.core.TypeRecord(value=rt2):
|
|
1150
|
+
@lru_cache(1)
|
|
1151
|
+
def has_annotated() -> bool:
|
|
1152
|
+
return hydra.lib.lists.foldl((lambda b, ft: hydra.lib.logic.or_(b, hydra.annotations.has_type_description(ft.type))), False, rt2)
|
|
1153
|
+
@lru_cache(1)
|
|
1154
|
+
def meta1() -> hydra.python.environment.PythonModuleMetadata:
|
|
1155
|
+
return hydra.lib.logic.if_else(hydra.lib.lists.null(rt2), (lambda : meta_with_subtypes()), (lambda : set_meta_uses_dataclass(meta_with_subtypes(), True)))
|
|
1156
|
+
return hydra.lib.logic.if_else(has_annotated(), (lambda : set_meta_uses_annotated(meta1(), True)), (lambda : meta1()))
|
|
1157
|
+
case hydra.core.TypeWrap():
|
|
1158
|
+
return hydra.lib.logic.if_else(is_term_annot, (lambda : meta_with_subtypes()), (lambda : set_meta_uses_node(meta_with_subtypes(), True)))
|
|
1159
|
+
case _:
|
|
1160
|
+
return meta_with_subtypes()
|
|
1161
|
+
def set_meta_uses_cast(b: bool, m: hydra.python.environment.PythonModuleMetadata) -> hydra.python.environment.PythonModuleMetadata:
|
|
1162
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, b, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1163
|
+
def set_meta_uses_just(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1164
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, b, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1165
|
+
def set_meta_uses_left(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1166
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, b, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1167
|
+
def set_meta_uses_nothing(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1168
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, b, m.uses_right, m.uses_type_var)
|
|
1169
|
+
def set_meta_uses_right(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1170
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, b, m.uses_type_var)
|
|
1171
|
+
def extend_meta_for_term(top_level: bool, meta0: hydra.python.environment.PythonModuleMetadata, term: hydra.core.Term) -> hydra.python.environment.PythonModuleMetadata:
|
|
1172
|
+
r"""Extend metadata based on a term (used during module encoding)."""
|
|
1173
|
+
def step(meta: hydra.python.environment.PythonModuleMetadata, t: hydra.core.Term):
|
|
1174
|
+
def _hoist_step_1(meta, v1):
|
|
1175
|
+
match v1:
|
|
1176
|
+
case hydra.core.FloatValueBigfloat():
|
|
1177
|
+
return set_meta_uses_decimal(meta, True)
|
|
1178
|
+
case _:
|
|
1179
|
+
return meta
|
|
1180
|
+
def _hoist_step_2(meta, v1):
|
|
1181
|
+
match v1:
|
|
1182
|
+
case hydra.core.LiteralDecimal():
|
|
1183
|
+
return set_meta_uses_decimal(meta, True)
|
|
1184
|
+
case hydra.core.LiteralFloat(value=fv):
|
|
1185
|
+
return _hoist_step_1(meta, fv)
|
|
1186
|
+
case _:
|
|
1187
|
+
return meta
|
|
1188
|
+
match t:
|
|
1189
|
+
case hydra.core.TermEither(value=e):
|
|
1190
|
+
@lru_cache(1)
|
|
1191
|
+
def meta_with_cast() -> hydra.python.environment.PythonModuleMetadata:
|
|
1192
|
+
return set_meta_uses_cast(True, meta)
|
|
1193
|
+
return hydra.lib.eithers.either((lambda _: set_meta_uses_left(meta_with_cast(), True)), (lambda _: set_meta_uses_right(meta_with_cast(), True)), e)
|
|
1194
|
+
case hydra.core.TermLambda(value=lam):
|
|
1195
|
+
return hydra.lib.maybes.maybe((lambda : meta), (lambda dom: hydra.lib.logic.if_else(top_level, (lambda : extend_meta_for_type(True, False, dom, meta)), (lambda : meta))), lam.domain)
|
|
1196
|
+
case hydra.core.TermLet(value=lt):
|
|
1197
|
+
bindings = lt.bindings
|
|
1198
|
+
return hydra.lib.lists.foldl((for_binding := (lambda m, b: hydra.lib.maybes.maybe((lambda : m), (lambda ts: (term1 := b.term, hydra.lib.logic.if_else(hydra.analysis.is_simple_assignment(term1), (lambda : m), (lambda : extend_meta_for_type(True, True, ts.body, m))))[1]), b.type_scheme)), (lambda x1, x2: for_binding(x1, x2)))[1], meta, bindings)
|
|
1199
|
+
case hydra.core.TermLiteral(value=l):
|
|
1200
|
+
return _hoist_step_2(meta, l)
|
|
1201
|
+
case hydra.core.TermMap():
|
|
1202
|
+
return set_meta_uses_frozen_dict(meta, True)
|
|
1203
|
+
case hydra.core.TermMaybe(value=m):
|
|
1204
|
+
return hydra.lib.maybes.maybe((lambda : set_meta_uses_nothing(meta, True)), (lambda _: set_meta_uses_just(meta, True)), m)
|
|
1205
|
+
case hydra.core.TermInject():
|
|
1206
|
+
return set_meta_uses_cast(True, meta)
|
|
1207
|
+
case _:
|
|
1208
|
+
return meta
|
|
1209
|
+
return hydra.rewriting.fold_over_term(hydra.coders.TraversalOrder.PRE, (lambda x1, x2: step(x1, x2)), meta0, term)
|
|
1210
|
+
def set_meta_uses_lru_cache(b: bool, m: hydra.python.environment.PythonModuleMetadata) -> hydra.python.environment.PythonModuleMetadata:
|
|
1211
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, b, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1212
|
+
def set_meta_uses_name(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1213
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, b, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1214
|
+
def set_meta_uses_type_var(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1215
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, b)
|
|
1216
|
+
def gather_metadata(focus_ns: hydra.packaging.Namespace, defs: frozenlist[hydra.packaging.Definition]) -> hydra.python.environment.PythonModuleMetadata:
|
|
1217
|
+
r"""Gather metadata from definitions."""
|
|
1218
|
+
@lru_cache(1)
|
|
1219
|
+
def start() -> hydra.python.environment.PythonModuleMetadata:
|
|
1220
|
+
return empty_metadata(hydra.python.utils.find_namespaces(focus_ns, defs))
|
|
1221
|
+
def add_def(meta: hydra.python.environment.PythonModuleMetadata, def_: hydra.packaging.Definition) -> hydra.python.environment.PythonModuleMetadata:
|
|
1222
|
+
match def_:
|
|
1223
|
+
case hydra.packaging.DefinitionTerm(value=term_def):
|
|
1224
|
+
term = term_def.term
|
|
1225
|
+
@lru_cache(1)
|
|
1226
|
+
def typ() -> hydra.core.Type:
|
|
1227
|
+
return hydra.lib.maybes.maybe((lambda : cast(hydra.core.Type, hydra.core.TypeVariable(hydra.core.Name("hydra.core.Unit")))), (lambda v1: v1.body), term_def.type_scheme)
|
|
1228
|
+
@lru_cache(1)
|
|
1229
|
+
def meta2() -> hydra.python.environment.PythonModuleMetadata:
|
|
1230
|
+
return extend_meta_for_type(True, True, typ(), meta)
|
|
1231
|
+
return extend_meta_for_term(True, meta2(), term)
|
|
1232
|
+
case hydra.packaging.DefinitionType(value=type_def):
|
|
1233
|
+
typ = type_def.type_scheme.body
|
|
1234
|
+
@lru_cache(1)
|
|
1235
|
+
def meta2() -> hydra.python.environment.PythonModuleMetadata:
|
|
1236
|
+
return set_meta_uses_name(meta, True)
|
|
1237
|
+
return hydra.rewriting.fold_over_type(hydra.coders.TraversalOrder.PRE, (lambda m, t: extend_meta_for_type(True, False, t, m)), meta2(), typ)
|
|
1238
|
+
case _:
|
|
1239
|
+
raise AssertionError("Unreachable: all variants handled")
|
|
1240
|
+
@lru_cache(1)
|
|
1241
|
+
def result() -> hydra.python.environment.PythonModuleMetadata:
|
|
1242
|
+
return hydra.lib.lists.foldl((lambda x1, x2: add_def(x1, x2)), start(), defs)
|
|
1243
|
+
tvars = result().type_variables
|
|
1244
|
+
@lru_cache(1)
|
|
1245
|
+
def result2() -> hydra.python.environment.PythonModuleMetadata:
|
|
1246
|
+
return set_meta_uses_cast(True, set_meta_uses_lru_cache(True, result()))
|
|
1247
|
+
return set_meta_uses_type_var(result2(), hydra.lib.logic.not_(hydra.lib.sets.null(tvars)))
|
|
1248
|
+
# The target Python version for code generation.
|
|
1249
|
+
target_python_version = hydra.python.utils.target_python_version
|
|
1250
|
+
def initial_environment(namespaces: hydra.packaging.Namespaces[hydra.python.syntax.DottedName], tcontext: hydra.graph.Graph) -> hydra.python.environment.PythonEnvironment:
|
|
1251
|
+
r"""Create an initial Python environment for code generation."""
|
|
1252
|
+
return hydra.python.environment.PythonEnvironment(namespaces, ((), hydra.lib.maps.empty()), tcontext, hydra.lib.sets.empty(), target_python_version, True, hydra.lib.sets.empty())
|
|
1253
|
+
def is_type_module_check(defs: frozenlist[hydra.packaging.Definition]):
|
|
1254
|
+
def _hoist_hydra_python_coder_is_type_module_check_1(v1):
|
|
1255
|
+
match v1:
|
|
1256
|
+
case hydra.packaging.DefinitionType():
|
|
1257
|
+
return True
|
|
1258
|
+
case _:
|
|
1259
|
+
return False
|
|
1260
|
+
return hydra.lib.logic.not_(hydra.lib.lists.null(hydra.lib.lists.filter((lambda d: _hoist_hydra_python_coder_is_type_module_check_1(d)), defs)))
|
|
1261
|
+
def module_domain_imports(namespaces: hydra.packaging.Namespaces[hydra.python.syntax.DottedName]) -> frozenlist[hydra.python.syntax.ImportStatement]:
|
|
1262
|
+
r"""Generate domain import statements from namespace mappings."""
|
|
1263
|
+
@lru_cache(1)
|
|
1264
|
+
def names() -> frozenlist[hydra.python.syntax.DottedName]:
|
|
1265
|
+
return hydra.lib.lists.sort(hydra.lib.maps.elems(namespaces.mapping))
|
|
1266
|
+
return hydra.lib.lists.map((lambda ns: cast(hydra.python.syntax.ImportStatement, hydra.python.syntax.ImportStatementName(hydra.python.syntax.ImportName((hydra.python.syntax.DottedAsName(ns, Nothing()),))))), names())
|
|
1267
|
+
def standard_import_statement(mod_name: str, symbols: frozenlist[str]) -> hydra.python.syntax.ImportStatement:
|
|
1268
|
+
r"""Generate a single from-import statement."""
|
|
1269
|
+
return cast(hydra.python.syntax.ImportStatement, hydra.python.syntax.ImportStatementFrom(hydra.python.syntax.ImportFrom((), Just(hydra.python.syntax.DottedName((hydra.python.syntax.Name(mod_name),))), cast(hydra.python.syntax.ImportFromTargets, hydra.python.syntax.ImportFromTargetsSimple(hydra.lib.lists.map((lambda s: hydra.python.syntax.ImportFromAsName(hydra.python.syntax.Name(s), Nothing())), symbols))))))
|
|
1270
|
+
def module_standard_imports(meta: hydra.python.environment.PythonModuleMetadata) -> frozenlist[hydra.python.syntax.ImportStatement]:
|
|
1271
|
+
r"""Generate standard import statements based on module metadata."""
|
|
1272
|
+
@lru_cache(1)
|
|
1273
|
+
def pairs() -> frozenlist[tuple[str, frozenlist[Maybe[str]]]]:
|
|
1274
|
+
return (("__future__", (cond_import_symbol("annotations", hydra.python.names.use_future_annotations),)), ("collections.abc", (cond_import_symbol("Callable", meta.uses_callable),)), ("dataclasses", (cond_import_symbol("dataclass", meta.uses_dataclass),)), ("decimal", (cond_import_symbol("Decimal", meta.uses_decimal),)), ("enum", (cond_import_symbol("Enum", meta.uses_enum),)), ("functools", (cond_import_symbol("lru_cache", meta.uses_lru_cache),)), ("hydra.dsl.python", (cond_import_symbol("Either", meta.uses_either), cond_import_symbol("FrozenDict", meta.uses_frozen_dict), cond_import_symbol("Just", meta.uses_just), cond_import_symbol("Left", meta.uses_left), cond_import_symbol("Maybe", meta.uses_maybe), cond_import_symbol("Node", meta.uses_node), cond_import_symbol("Nothing", meta.uses_nothing), cond_import_symbol("Right", meta.uses_right), cond_import_symbol("frozenlist", meta.uses_frozen_list))), ("typing", (cond_import_symbol("Annotated", meta.uses_annotated), cond_import_symbol("Generic", meta.uses_generic), cond_import_symbol("TypeAlias", meta.uses_type_alias), cond_import_symbol("TypeVar", meta.uses_type_var), cond_import_symbol("cast", meta.uses_cast))))
|
|
1275
|
+
@lru_cache(1)
|
|
1276
|
+
def simplified() -> frozenlist[tuple[str, frozenlist[str]]]:
|
|
1277
|
+
return hydra.lib.maybes.cat(hydra.lib.lists.map((lambda p: (mod_name := hydra.lib.pairs.first(p), symbols := hydra.lib.maybes.cat(hydra.lib.pairs.second(p)), hydra.lib.logic.if_else(hydra.lib.lists.null(symbols), (lambda : Nothing()), (lambda : Just((mod_name, symbols)))))[2]), pairs()))
|
|
1278
|
+
return hydra.lib.lists.map((lambda p: standard_import_statement(hydra.lib.pairs.first(p), hydra.lib.pairs.second(p))), simplified())
|
|
1279
|
+
def module_imports(namespaces: hydra.packaging.Namespaces[hydra.python.syntax.DottedName], meta: hydra.python.environment.PythonModuleMetadata) -> frozenlist[hydra.python.syntax.Statement]:
|
|
1280
|
+
r"""Generate all import statements for a Python module."""
|
|
1281
|
+
return hydra.lib.lists.map((lambda imp: hydra.python.utils.py_simple_statement_to_py_statement(cast(hydra.python.syntax.SimpleStatement, hydra.python.syntax.SimpleStatementImport(imp)))), hydra.lib.lists.concat((module_standard_imports(meta), module_domain_imports(namespaces))))
|
|
1282
|
+
def set_meta_uses_type_alias(m: hydra.python.environment.PythonModuleMetadata, b: bool) -> hydra.python.environment.PythonModuleMetadata:
|
|
1283
|
+
return hydra.python.environment.PythonModuleMetadata(m.namespaces, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, b, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1284
|
+
def tvar_statement(name: hydra.python.syntax.Name) -> hydra.python.syntax.Statement:
|
|
1285
|
+
r"""Create a TypeVar assignment statement for a type variable name."""
|
|
1286
|
+
return hydra.python.utils.assignment_statement(name, hydra.python.utils.function_call(cast(hydra.python.syntax.Primary, hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("TypeVar"))))), (hydra.python.utils.double_quoted_string(name.value),)))
|
|
1287
|
+
def with_let(v1: hydra.python.environment.PythonEnvironment, v2: hydra.core.Let, v3: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
|
|
1288
|
+
r"""Execute a computation with let context (adds let bindings to Graph)."""
|
|
1289
|
+
return hydra.environment.with_let_context((lambda x1: python_environment_get_graph(x1)), (lambda x1, x2: python_environment_set_graph(x1, x2)), (lambda x1, x2: python_binding_metadata(x1, x2)), v1, v2, v3)
|
|
1290
|
+
def with_definitions(env: hydra.python.environment.PythonEnvironment, defs: frozenlist[hydra.packaging.Definition], body: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
|
|
1291
|
+
r"""Execute a computation with definitions in scope."""
|
|
1292
|
+
@lru_cache(1)
|
|
1293
|
+
def bindings():
|
|
1294
|
+
def _hoist_bindings_1(v1):
|
|
1295
|
+
match v1:
|
|
1296
|
+
case hydra.packaging.DefinitionTerm(value=td):
|
|
1297
|
+
return Just(hydra.core.Binding(td.name, td.term, td.type_scheme))
|
|
1298
|
+
case hydra.packaging.DefinitionType():
|
|
1299
|
+
return Nothing()
|
|
1300
|
+
case _:
|
|
1301
|
+
return Nothing()
|
|
1302
|
+
return hydra.lib.maybes.cat(hydra.lib.lists.map((lambda def_: _hoist_bindings_1(def_)), defs))
|
|
1303
|
+
@lru_cache(1)
|
|
1304
|
+
def dummy_let() -> hydra.core.Let:
|
|
1305
|
+
return hydra.core.Let(bindings(), cast(hydra.core.Term, hydra.core.TermLiteral(cast(hydra.core.Literal, hydra.core.LiteralString("dummy")))))
|
|
1306
|
+
return with_let(env, dummy_let(), body)
|
|
1307
|
+
def encode_python_module(cx: hydra.context.Context, g: hydra.graph.Graph, mod: hydra.packaging.Module, defs0: frozenlist[hydra.packaging.Definition]) -> Either[hydra.errors.Error, hydra.python.syntax.Module]:
|
|
1308
|
+
r"""Encode a Hydra module to a Python module AST."""
|
|
1309
|
+
@lru_cache(1)
|
|
1310
|
+
def defs() -> frozenlist[hydra.packaging.Definition]:
|
|
1311
|
+
return hydra.environment.reorder_defs(defs0)
|
|
1312
|
+
@lru_cache(1)
|
|
1313
|
+
def meta0() -> hydra.python.environment.PythonModuleMetadata:
|
|
1314
|
+
return gather_metadata(mod.namespace, defs())
|
|
1315
|
+
namespaces0 = meta0().namespaces
|
|
1316
|
+
@lru_cache(1)
|
|
1317
|
+
def env0() -> hydra.python.environment.PythonEnvironment:
|
|
1318
|
+
return initial_environment(namespaces0, g)
|
|
1319
|
+
@lru_cache(1)
|
|
1320
|
+
def is_type_mod() -> bool:
|
|
1321
|
+
return is_type_module_check(defs0)
|
|
1322
|
+
return with_definitions(env0(), defs(), (lambda env: hydra.lib.eithers.bind(hydra.lib.eithers.map((lambda xs: hydra.lib.lists.concat(xs)), hydra.lib.eithers.map_list((lambda d: encode_definition(cx, env, d)), defs())), (lambda def_stmts: (meta2 := hydra.lib.logic.if_else(hydra.lib.logic.and_(hydra.lib.logic.not_(is_type_mod()), use_inline_type_params()), (lambda : set_meta_uses_type_var(meta0(), False)), (lambda : meta0())), meta := hydra.lib.logic.if_else(hydra.lib.logic.and_(is_type_mod(), hydra.lib.equality.equal(target_python_version, hydra.python.environment.PythonVersion.PYTHON310)), (lambda : set_meta_uses_type_alias(meta2, True)), (lambda : meta2)), namespaces := meta0().namespaces, comment_stmts := hydra.lib.maybes.maybe((lambda : ()), (lambda c: (hydra.python.utils.comment_statement(c),)), hydra.lib.maybes.map(hydra.formatting.normalize_comment, mod.description)), import_stmts := module_imports(namespaces, meta), tvars := hydra.lib.logic.if_else(hydra.lib.logic.or_(is_type_mod(), hydra.lib.logic.not_(use_inline_type_params())), (lambda : meta.type_variables), (lambda : hydra.lib.sets.empty())), tvar_stmts := hydra.lib.lists.map((lambda tv: tvar_statement(hydra.python.names.encode_type_variable(tv))), hydra.lib.sets.to_list(tvars)), body := hydra.lib.lists.filter((lambda group: hydra.lib.logic.not_(hydra.lib.lists.null(group))), hydra.lib.lists.concat(((comment_stmts, import_stmts, tvar_stmts), def_stmts))), Right(hydra.python.syntax.Module(body)))[8]))))
|
|
1323
|
+
def set_meta_namespaces(ns: hydra.packaging.Namespaces[hydra.python.syntax.DottedName], m: hydra.python.environment.PythonModuleMetadata) -> hydra.python.environment.PythonModuleMetadata:
|
|
1324
|
+
return hydra.python.environment.PythonModuleMetadata(ns, m.type_variables, m.uses_annotated, m.uses_callable, m.uses_cast, m.uses_lru_cache, m.uses_type_alias, m.uses_dataclass, m.uses_decimal, m.uses_either, m.uses_enum, m.uses_frozen_dict, m.uses_frozen_list, m.uses_generic, m.uses_just, m.uses_left, m.uses_maybe, m.uses_name, m.uses_node, m.uses_nothing, m.uses_right, m.uses_type_var)
|
|
1325
|
+
def extend_meta_for_types(types: frozenlist[hydra.core.Type], meta: hydra.python.environment.PythonModuleMetadata) -> hydra.python.environment.PythonModuleMetadata:
|
|
1326
|
+
r"""Extend metadata for a list of types."""
|
|
1327
|
+
@lru_cache(1)
|
|
1328
|
+
def names() -> frozenset[hydra.core.Name]:
|
|
1329
|
+
return hydra.lib.sets.unions(hydra.lib.lists.map((lambda t: hydra.dependencies.type_dependency_names(False, t)), types))
|
|
1330
|
+
current_ns = meta.namespaces
|
|
1331
|
+
@lru_cache(1)
|
|
1332
|
+
def updated_ns() -> hydra.packaging.Namespaces[hydra.python.syntax.DottedName]:
|
|
1333
|
+
return hydra.analysis.add_names_to_namespaces((lambda x1: hydra.python.names.encode_namespace(x1)), names(), current_ns)
|
|
1334
|
+
@lru_cache(1)
|
|
1335
|
+
def meta1() -> hydra.python.environment.PythonModuleMetadata:
|
|
1336
|
+
return set_meta_namespaces(updated_ns(), meta)
|
|
1337
|
+
return hydra.lib.lists.foldl((lambda m, t: extend_meta_for_type(True, False, t, m)), meta1(), types)
|
|
1338
|
+
def initial_metadata(ns: hydra.packaging.Namespace) -> hydra.python.environment.PythonModuleMetadata:
|
|
1339
|
+
r"""Create initial empty metadata for a Python module."""
|
|
1340
|
+
@lru_cache(1)
|
|
1341
|
+
def dotted_ns() -> hydra.python.syntax.DottedName:
|
|
1342
|
+
return hydra.python.names.encode_namespace(ns)
|
|
1343
|
+
@lru_cache(1)
|
|
1344
|
+
def empty_ns() -> hydra.packaging.Namespaces[hydra.python.syntax.DottedName]:
|
|
1345
|
+
return hydra.packaging.Namespaces((ns, dotted_ns()), hydra.lib.maps.empty())
|
|
1346
|
+
return hydra.python.environment.PythonModuleMetadata(empty_ns(), hydra.lib.sets.empty(), False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False)
|
|
1347
|
+
def make_py_graph(g: hydra.graph.Graph, m: hydra.python.environment.PythonModuleMetadata) -> hydra.python.environment.PyGraph:
|
|
1348
|
+
r"""Constructor for PyGraph record."""
|
|
1349
|
+
return hydra.python.environment.PyGraph(g, m)
|
|
1350
|
+
def module_to_python(mod: hydra.packaging.Module, defs: frozenlist[hydra.packaging.Definition], cx: hydra.context.Context, g: hydra.graph.Graph) -> Either[hydra.errors.Error, FrozenDict[str, str]]:
|
|
1351
|
+
r"""Convert a Hydra module to Python source files."""
|
|
1352
|
+
return hydra.lib.eithers.bind(encode_python_module(cx, g, mod, defs), (lambda file: (s := hydra.serialization.print_expr(hydra.serialization.parenthesize(hydra.python.serde.encode_module(file))), path := hydra.names.namespace_to_file_path(hydra.util.CaseConvention.LOWER_SNAKE, hydra.packaging.FileExtension("py"), mod.namespace), Right(hydra.lib.maps.singleton(path, s)))[2]))
|
|
1353
|
+
def py_graph_graph(pyg: hydra.python.environment.PyGraph) -> hydra.graph.Graph:
|
|
1354
|
+
r"""Accessor for the graph field of PyGraph."""
|
|
1355
|
+
return pyg.graph
|
|
1356
|
+
def py_graph_metadata(pyg: hydra.python.environment.PyGraph) -> hydra.python.environment.PythonModuleMetadata:
|
|
1357
|
+
r"""Accessor for the metadata field of PyGraph."""
|
|
1358
|
+
return pyg.metadata
|
|
1359
|
+
def wildcard_case_block(stmt: hydra.python.syntax.Statement) -> hydra.python.syntax.CaseBlock:
|
|
1360
|
+
r"""Create a wildcard case block with a given body statement."""
|
|
1361
|
+
return hydra.python.syntax.CaseBlock(hydra.python.utils.py_closed_pattern_to_py_patterns(cast(hydra.python.syntax.ClosedPattern, hydra.python.syntax.ClosedPatternWildcard())), Nothing(), hydra.python.utils.indented_block(Nothing(), ((stmt,),)))
|
|
1362
|
+
def with_lambda(v1: hydra.python.environment.PythonEnvironment, v2: hydra.core.Lambda, v3: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
|
|
1363
|
+
r"""Execute a computation with lambda context (adds lambda parameter to Graph)."""
|
|
1364
|
+
return hydra.environment.with_lambda_context((lambda x1: python_environment_get_graph(x1)), (lambda x1, x2: python_environment_set_graph(x1, x2)), v1, v2, v3)
|