hydra-python 0.15.0__py3-none-any.whl

hydra/python/environment.py

@@ -0,0 +1,91 @@
+# Note: this is an automatically generated file. Do not edit.
+r"""Environment types for Python code generation."""
+from __future__ import annotations
+from dataclasses import dataclass
+from enum import Enum
+from functools import lru_cache
+from hydra.dsl.python import FrozenDict, frozenlist
+from typing import Annotated, TypeAlias, cast
+import hydra.core
+import hydra.graph
+import hydra.packaging
+import hydra.python.syntax
+class PythonVersion(Enum):
+    r"""Target Python version for code generation."""
+    PYTHON310 = hydra.core.Name("python310")
+    PYTHON312 = hydra.core.Name("python312")
+PythonVersion.TYPE_ = hydra.core.Name("hydra.python.environment.PythonVersion")
+@dataclass(frozen=True)
+class PythonEnvironment:
+    r"""Environment for Python code generation."""
+    namespaces: Annotated[hydra.packaging.Namespaces[hydra.python.syntax.DottedName], "Namespace mapping for imports"]
+    bound_type_variables: Annotated[tuple[frozenlist[hydra.core.Name], FrozenDict[hydra.core.Name, hydra.python.syntax.Name]], "Type variables in scope, with their Python names"]
+    graph: Annotated[hydra.graph.Graph, "Graph context for type inference"]
+    nullary_bindings: Annotated[frozenset[hydra.core.Name], "Set of nullary bindings (need call syntax)"]
+    version: Annotated[PythonVersion, "Target Python version"]
+    skip_casts: Annotated[bool, "When True, skip generating cast() calls for reduced memory usage"]
+    inline_variables: Annotated[frozenset[hydra.core.Name], "Variables that are inline let bindings (walrus operators)"]
+    TYPE_ = hydra.core.Name("hydra.python.environment.PythonEnvironment")
+    NAMESPACES = hydra.core.Name("namespaces")
+    BOUND_TYPE_VARIABLES = hydra.core.Name("boundTypeVariables")
+    GRAPH = hydra.core.Name("graph")
+    NULLARY_BINDINGS = hydra.core.Name("nullaryBindings")
+    VERSION = hydra.core.Name("version")
+    SKIP_CASTS = hydra.core.Name("skipCasts")
+    INLINE_VARIABLES = hydra.core.Name("inlineVariables")
+@dataclass(frozen=True)
+class PythonModuleMetadata:
+    r"""Temporary metadata used to create the header section of a Python file."""
+    namespaces: Annotated[hydra.packaging.Namespaces[hydra.python.syntax.DottedName], "Namespace mapping for imports"]
+    type_variables: Annotated[frozenset[hydra.core.Name], "Type variables used in the module"]
+    uses_annotated: bool
+    uses_callable: bool
+    uses_cast: bool
+    uses_lru_cache: bool
+    uses_type_alias: bool
+    uses_dataclass: bool
+    uses_decimal: bool
+    uses_either: bool
+    uses_enum: bool
+    uses_frozen_dict: bool
+    uses_frozen_list: bool
+    uses_generic: bool
+    uses_just: bool
+    uses_left: bool
+    uses_maybe: bool
+    uses_name: bool
+    uses_node: bool
+    uses_nothing: bool
+    uses_right: bool
+    uses_type_var: bool
+    TYPE_ = hydra.core.Name("hydra.python.environment.PythonModuleMetadata")
+    NAMESPACES = hydra.core.Name("namespaces")
+    TYPE_VARIABLES = hydra.core.Name("typeVariables")
+    USES_ANNOTATED = hydra.core.Name("usesAnnotated")
+    USES_CALLABLE = hydra.core.Name("usesCallable")
+    USES_CAST = hydra.core.Name("usesCast")
+    USES_LRU_CACHE = hydra.core.Name("usesLruCache")
+    USES_TYPE_ALIAS = hydra.core.Name("usesTypeAlias")
+    USES_DATACLASS = hydra.core.Name("usesDataclass")
+    USES_DECIMAL = hydra.core.Name("usesDecimal")
+    USES_EITHER = hydra.core.Name("usesEither")
+    USES_ENUM = hydra.core.Name("usesEnum")
+    USES_FROZEN_DICT = hydra.core.Name("usesFrozenDict")
+    USES_FROZEN_LIST = hydra.core.Name("usesFrozenList")
+    USES_GENERIC = hydra.core.Name("usesGeneric")
+    USES_JUST = hydra.core.Name("usesJust")
+    USES_LEFT = hydra.core.Name("usesLeft")
+    USES_MAYBE = hydra.core.Name("usesMaybe")
+    USES_NAME = hydra.core.Name("usesName")
+    USES_NODE = hydra.core.Name("usesNode")
+    USES_NOTHING = hydra.core.Name("usesNothing")
+    USES_RIGHT = hydra.core.Name("usesRight")
+    USES_TYPE_VAR = hydra.core.Name("usesTypeVar")
+@dataclass(frozen=True)
+class PyGraph:
+    r"""Combined graph and metadata state for Python code generation."""
+    graph: Annotated[hydra.graph.Graph, "The Hydra graph being processed"]
+    metadata: Annotated[PythonModuleMetadata, "Accumulated module metadata"]
+    TYPE_ = hydra.core.Name("hydra.python.environment.PyGraph")
+    GRAPH = hydra.core.Name("graph")
+    METADATA = hydra.core.Name("metadata")

hydra/python/language.py

@@ -0,0 +1,48 @@
+# Note: this is an automatically generated file. Do not edit.
+r"""Language constraints and reserved words for Python 3."""
+from __future__ import annotations
+from functools import lru_cache
+from typing import TypeVar, cast
+import hydra.coders
+import hydra.core
+import hydra.lib.lists
+import hydra.lib.sets
+import hydra.variants
+T0 = TypeVar("T0")
+@lru_cache(1)
+def python_language() -> hydra.coders.Language:
+    r"""Language constraints for Python 3."""
+    @lru_cache(1)
+    def elimination_variants() -> frozenset[hydra.variants.EliminationVariant]:
+        return hydra.lib.sets.from_list((hydra.variants.EliminationVariant.RECORD, hydra.variants.EliminationVariant.UNION, hydra.variants.EliminationVariant.WRAP))
+    @lru_cache(1)
+    def literal_variants() -> frozenset[hydra.variants.LiteralVariant]:
+        return hydra.lib.sets.from_list((hydra.variants.LiteralVariant.BINARY, hydra.variants.LiteralVariant.BOOLEAN, hydra.variants.LiteralVariant.DECIMAL, hydra.variants.LiteralVariant.FLOAT, hydra.variants.LiteralVariant.INTEGER, hydra.variants.LiteralVariant.STRING))
+    @lru_cache(1)
+    def float_types() -> frozenset[hydra.core.FloatType]:
+        return hydra.lib.sets.from_list((hydra.core.FloatType.BIGFLOAT, hydra.core.FloatType.FLOAT64))
+    @lru_cache(1)
+    def function_variants() -> frozenset[hydra.variants.FunctionVariant]:
+        return hydra.lib.sets.from_list((hydra.variants.FunctionVariant.ELIMINATION, hydra.variants.FunctionVariant.LAMBDA))
+    @lru_cache(1)
+    def integer_types() -> frozenset[hydra.core.IntegerType]:
+        return hydra.lib.sets.from_list((hydra.core.IntegerType.BIGINT,))
+    @lru_cache(1)
+    def term_variants() -> frozenset[hydra.variants.TermVariant]:
+        return hydra.lib.sets.from_list((hydra.variants.TermVariant.ANNOTATED, hydra.variants.TermVariant.APPLICATION, hydra.variants.TermVariant.EITHER, hydra.variants.TermVariant.CASES, hydra.variants.TermVariant.LAMBDA, hydra.variants.TermVariant.PROJECT, hydra.variants.TermVariant.UNWRAP, hydra.variants.TermVariant.LET, hydra.variants.TermVariant.LIST, hydra.variants.TermVariant.LITERAL, hydra.variants.TermVariant.MAP, hydra.variants.TermVariant.MAYBE, hydra.variants.TermVariant.PAIR, hydra.variants.TermVariant.RECORD, hydra.variants.TermVariant.SET, hydra.variants.TermVariant.TYPE_APPLICATION, hydra.variants.TermVariant.TYPE_LAMBDA, hydra.variants.TermVariant.INJECT, hydra.variants.TermVariant.UNIT, hydra.variants.TermVariant.VARIABLE, hydra.variants.TermVariant.WRAP))
+    @lru_cache(1)
+    def type_variants() -> frozenset[hydra.variants.TypeVariant]:
+        return hydra.lib.sets.from_list((hydra.variants.TypeVariant.ANNOTATED, hydra.variants.TypeVariant.APPLICATION, hydra.variants.TypeVariant.EITHER, hydra.variants.TypeVariant.FUNCTION, hydra.variants.TypeVariant.FORALL, hydra.variants.TypeVariant.LIST, hydra.variants.TypeVariant.LITERAL, hydra.variants.TypeVariant.MAP, hydra.variants.TypeVariant.MAYBE, hydra.variants.TypeVariant.PAIR, hydra.variants.TypeVariant.RECORD, hydra.variants.TypeVariant.SET, hydra.variants.TypeVariant.UNION, hydra.variants.TypeVariant.UNIT, hydra.variants.TypeVariant.VARIABLE, hydra.variants.TypeVariant.VOID, hydra.variants.TypeVariant.WRAP))
+    def type_predicate(_: T0) -> bool:
+        return True
+    return hydra.coders.Language(hydra.coders.LanguageName("hydra.python"), hydra.coders.LanguageConstraints(elimination_variants(), literal_variants(), float_types(), function_variants(), integer_types(), term_variants(), type_variants(), (lambda x1: type_predicate(x1))))
+@lru_cache(1)
+def python_reserved_words() -> frozenset[str]:
+    r"""A set of reserved words in Python."""
+    # Python keywords, as enumerated at https://docs.python.org/3.13/reference/lexical_analysis.html#keywords.
+    python_keywords = ("False", "None", "True", "and", "as", "assert", "async", "await", "break", "class", "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", "raise", "return", "try", "while", "with", "yield")
+    # Some additional keywords we reserve in order to avoid collision with built-in functions.
+    python_built_in_functions = ("range",)
+    # Reserved words which are specific to Hydra-Python.
+    hydra_python_keywords = ("Node", "FrozenDict")
+    return hydra.lib.sets.from_list(hydra.lib.lists.concat((python_keywords, python_built_in_functions, hydra_python_keywords)))

hydra/python/names.py

@@ -0,0 +1,120 @@
+# Note: this is an automatically generated file. Do not edit.
+r"""Python naming utilities: encoding Hydra names as Python names."""
+from __future__ import annotations
+from collections.abc import Callable
+from functools import lru_cache
+from hydra.dsl.python import Just, Nothing
+from typing import TypeVar, cast
+import hydra.core
+import hydra.formatting
+import hydra.lib.equality
+import hydra.lib.lists
+import hydra.lib.logic
+import hydra.lib.maps
+import hydra.lib.maybes
+import hydra.lib.pairs
+import hydra.lib.strings
+import hydra.names
+import hydra.packaging
+import hydra.python.environment
+import hydra.python.language
+import hydra.python.serde
+import hydra.python.syntax
+import hydra.util
+T0 = TypeVar("T0")
+T1 = TypeVar("T1")
+def encode_constant_for_field_name(env: T0, tname: T1, fname: hydra.core.Name) -> hydra.python.syntax.Name:
+    r"""Generate a constant name for a field definition."""
+    return hydra.python.syntax.Name(hydra.formatting.convert_case(hydra.util.CaseConvention.CAMEL, hydra.util.CaseConvention.UPPER_SNAKE, fname.value))
+def encode_constant_for_type_name(env: T0, tname: T1) -> hydra.python.syntax.Name:
+    r"""Generate a constant name for a type definition."""
+    return hydra.python.syntax.Name("TYPE_")
+def sanitize_python_name(v1: str) -> str:
+    r"""Sanitize a string to be a valid Python name."""
+    return hydra.formatting.sanitize_with_underscores(hydra.python.language.python_reserved_words(), v1)
+# Whether to use __future__ annotations for forward references.
+use_future_annotations = True
+def encode_name(is_qualified: bool, conv: hydra.util.CaseConvention, env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name) -> hydra.python.syntax.Name:
+    r"""Encode a Hydra name as a Python name."""
+    namespaces = env.namespaces
+    @lru_cache(1)
+    def focus_pair() -> tuple[hydra.packaging.Namespace, hydra.python.syntax.DottedName]:
+        return namespaces.focus
+    @lru_cache(1)
+    def focus_ns() -> hydra.packaging.Namespace:
+        return hydra.lib.pairs.first(focus_pair())
+    @lru_cache(1)
+    def bound_vars() -> FrozenDict[hydra.core.Name, hydra.python.syntax.Name]:
+        return hydra.lib.pairs.second(env.bound_type_variables)
+    @lru_cache(1)
+    def qual_name() -> hydra.packaging.QualifiedName:
+        return hydra.names.qualify_name(name)
+    mns = qual_name().namespace
+    local = qual_name().local
+    @lru_cache(1)
+    def py_local() -> str:
+        return sanitize_python_name(hydra.formatting.convert_case(hydra.util.CaseConvention.CAMEL, conv, local))
+    def py_ns(ns_val: hydra.packaging.Namespace) -> str:
+        return hydra.lib.strings.intercalate(".", hydra.lib.lists.map((lambda v1: hydra.formatting.convert_case(hydra.util.CaseConvention.CAMEL, hydra.util.CaseConvention.LOWER_SNAKE, v1)), hydra.lib.strings.split_on(".", ns_val.value)))
+    return hydra.lib.logic.if_else(is_qualified, (lambda : hydra.lib.maybes.maybe((lambda : hydra.lib.logic.if_else(hydra.lib.equality.equal(mns, Just(focus_ns())), (lambda : hydra.python.syntax.Name(hydra.lib.logic.if_else(use_future_annotations, (lambda : py_local()), (lambda : hydra.python.serde.escape_python_string(True, py_local()))))), (lambda : hydra.lib.maybes.maybe((lambda : hydra.python.syntax.Name(py_local())), (lambda ns_val: hydra.python.syntax.Name(hydra.lib.strings.cat2(py_ns(ns_val), hydra.lib.strings.cat2(".", py_local())))), mns)))), (lambda n: n), hydra.lib.maps.lookup(name, bound_vars()))), (lambda : hydra.python.syntax.Name(py_local())))
+def encode_enum_value(v1: hydra.python.environment.PythonEnvironment, v2: hydra.core.Name) -> hydra.python.syntax.Name:
+    r"""Encode a name as a Python enum value (UPPER_SNAKE case)."""
+    return encode_name(False, hydra.util.CaseConvention.UPPER_SNAKE, v1, v2)
+def encode_field_name(env: hydra.python.environment.PythonEnvironment, fname: hydra.core.Name) -> hydra.python.syntax.Name:
+    r"""Encode a name as a Python field name (lower_snake case)."""
+    return encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, fname)
+def encode_name_qualified(env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name) -> hydra.python.syntax.Name:
+    r"""Encode a name as a fully qualified Python name."""
+    namespaces = env.namespaces
+    @lru_cache(1)
+    def focus_pair() -> tuple[hydra.packaging.Namespace, hydra.python.syntax.DottedName]:
+        return namespaces.focus
+    @lru_cache(1)
+    def focus_ns() -> hydra.packaging.Namespace:
+        return hydra.lib.pairs.first(focus_pair())
+    @lru_cache(1)
+    def bound_vars() -> FrozenDict[hydra.core.Name, hydra.python.syntax.Name]:
+        return hydra.lib.pairs.second(env.bound_type_variables)
+    @lru_cache(1)
+    def qual_name() -> hydra.packaging.QualifiedName:
+        return hydra.names.qualify_name(name)
+    mns = qual_name().namespace
+    local = qual_name().local
+    return hydra.lib.maybes.maybe((lambda : hydra.lib.logic.if_else(hydra.lib.equality.equal(mns, Just(focus_ns())), (lambda : hydra.python.syntax.Name(hydra.lib.logic.if_else(use_future_annotations, (lambda : local), (lambda : hydra.python.serde.escape_python_string(True, local))))), (lambda : hydra.python.syntax.Name(hydra.lib.strings.intercalate(".", hydra.lib.lists.map(sanitize_python_name, hydra.lib.strings.split_on(".", name.value))))))), (lambda n: n), hydra.lib.maps.lookup(name, bound_vars()))
+def encode_namespace(ns_val: hydra.packaging.Namespace) -> hydra.python.syntax.DottedName:
+    r"""Encode a namespace as a Python dotted name."""
+    return hydra.python.syntax.DottedName(hydra.lib.lists.map((lambda part: hydra.python.syntax.Name(hydra.formatting.convert_case(hydra.util.CaseConvention.CAMEL, hydra.util.CaseConvention.LOWER_SNAKE, part))), hydra.lib.strings.split_on(".", ns_val.value)))
+def encode_type_variable(name: hydra.core.Name) -> hydra.python.syntax.Name:
+    r"""Encode a type variable name (capitalized)."""
+    return hydra.python.syntax.Name(hydra.formatting.capitalize(name.value))
+def variable_reference(conv: hydra.util.CaseConvention, quoted: bool, env: hydra.python.environment.PythonEnvironment, name: hydra.core.Name) -> hydra.python.syntax.Expression:
+    r"""Reference a variable as a Python expression."""
+    @lru_cache(1)
+    def py_name() -> hydra.python.syntax.Name:
+        return encode_name(True, conv, env, name)
+    @lru_cache(1)
+    def unquoted() -> hydra.python.syntax.Expression:
+        return 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(py_name()))))), Nothing()))))))))), ()))),)),))))
+    namespaces = env.namespaces
+    @lru_cache(1)
+    def focus_pair() -> tuple[hydra.packaging.Namespace, hydra.python.syntax.DottedName]:
+        return namespaces.focus
+    @lru_cache(1)
+    def focus_ns() -> hydra.packaging.Namespace:
+        return hydra.lib.pairs.first(focus_pair())
+    @lru_cache(1)
+    def mns() -> Maybe[hydra.packaging.Namespace]:
+        return hydra.names.namespace_of(name)
+    @lru_cache(1)
+    def same_namespace() -> bool:
+        return hydra.lib.maybes.maybe((lambda : False), (lambda ns: hydra.lib.equality.equal(ns, focus_ns())), mns())
+    return hydra.lib.logic.if_else(hydra.lib.logic.and_(quoted, same_namespace()), (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.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.AtomString(hydra.python.syntax.String(py_name().value, hydra.python.syntax.QuoteStyle.DOUBLE)))))), Nothing()))))))))), ()))),)),))))), (lambda : unquoted()))
+def term_variable_reference(v1: hydra.python.environment.PythonEnvironment, v2: hydra.core.Name) -> hydra.python.syntax.Expression:
+    r"""Reference a term variable as a Python expression."""
+    return variable_reference(hydra.util.CaseConvention.LOWER_SNAKE, False, v1, v2)
+def type_variable_reference(v1: hydra.python.environment.PythonEnvironment, v2: hydra.core.Name) -> hydra.python.syntax.Expression:
+    r"""Reference a type variable as a Python expression."""
+    return variable_reference(hydra.util.CaseConvention.PASCAL, False, v1, v2)
+def variant_name(is_qualified: bool, env: hydra.python.environment.PythonEnvironment, tname: hydra.core.Name, fname: hydra.core.Name) -> hydra.python.syntax.Name:
+    r"""Generate a variant name from type name and field name."""
+    return encode_name(is_qualified, hydra.util.CaseConvention.PASCAL, env, hydra.core.Name(hydra.lib.strings.cat2(tname.value, hydra.formatting.capitalize(fname.value))))