hydra-python
  • hydra
    • hydra namespace
      • Subpackages
        • hydra.python namespace
          • Submodules
            • hydra.python.coder module
              • analyze_python_function()
              • builder_setter_name()
              • case_block_to_expr()
              • class_variant_pattern_unit()
              • class_variant_pattern_with_capture()
              • collect_type_variables()
              • cond_import_symbol()
              • dataclass_decorator()
              • deconflict_variant_name()
              • deduplicate_case_variables()
              • dig_for_wrap()
              • eliminate_unit_var()
              • empty_metadata()
              • encode_application()
              • encode_application_inner()
              • encode_application_type()
              • encode_binding_as()
              • encode_binding_as_assignment()
              • encode_bindings_as_defs()
              • encode_default_case_block()
              • encode_definition()
              • encode_enum_value_assignment()
              • encode_field()
              • encode_field_type()
              • encode_float_value()
              • encode_float_value_encode_float32()
              • encode_float_value_encode_float64()
              • encode_float_value_py_special_float()
              • encode_forall_type()
              • encode_function_type()
              • encode_integer_value()
              • encode_literal()
              • encode_literal_type()
              • encode_name_constants()
              • encode_python_module()
              • encode_record_type()
              • encode_term_assignment()
              • encode_term_inline()
              • encode_term_multiline()
              • encode_term_multiline_t_c_o()
              • encode_type()
              • encode_type_assignment()
              • encode_type_assignment_inner()
              • encode_type_def_single()
              • encode_type_quoted()
              • encode_union_elimination_inline()
              • encode_union_field()
              • encode_union_field_alt()
              • encode_union_type()
              • encode_variable()
              • encode_wrapped_type()
              • enum_variant_pattern()
              • environment_type_parameters()
              • extend_env_with_lambda_params()
              • extend_env_with_type_var()
              • extend_meta_for_term()
              • extend_meta_for_type()
              • extend_meta_for_types()
              • extract_case_elimination()
              • fill_doms_from_signature()
              • find_type_params()
              • function_definition_to_expr()
              • gather_lambdas()
              • gather_metadata()
              • generic_arg()
              • initial_environment()
              • initial_metadata()
              • is_case_statement_application()
              • is_cases_full()
              • is_type_module_check()
              • is_type_variable_name()
              • is_variant_unit_type()
              • lazy_dot_get()
              • lazy_flags_for_primitive()
              • lru_cache_decorator()
              • make_curried_lambda()
              • make_lazy()
              • make_py_graph()
              • make_simple_lambda()
              • make_thunk()
              • make_uncurried_lambda()
              • module_domain_imports()
              • module_imports()
              • module_standard_imports()
              • module_to_python()
              • py_graph_graph()
              • py_graph_metadata()
              • py_int()
              • python_binding_metadata()
              • python_environment_get_graph()
              • python_environment_set_graph()
              • record_builder_class()
              • record_builder_setter()
              • record_with_method()
              • set_meta_namespaces()
              • set_meta_type_variables()
              • set_meta_uses_annotated()
              • set_meta_uses_callable()
              • set_meta_uses_cast()
              • set_meta_uses_dataclass()
              • set_meta_uses_decimal()
              • set_meta_uses_either()
              • set_meta_uses_enum()
              • set_meta_uses_frozen_dict()
              • set_meta_uses_frozen_list()
              • set_meta_uses_frozen_set()
              • set_meta_uses_generic()
              • set_meta_uses_just()
              • set_meta_uses_left()
              • set_meta_uses_lru_cache()
              • set_meta_uses_maybe()
              • set_meta_uses_name()
              • set_meta_uses_node()
              • set_meta_uses_nothing()
              • set_meta_uses_right()
              • set_meta_uses_type_alias()
              • set_meta_uses_type_var()
              • should_thunk_binding()
              • standard_import_statement()
              • term_arity_with_primitives()
              • tvar_statement()
              • type_alias_statement_for()
              • union_type_statements_for()
              • unsupported_expression()
              • use_inline_type_params()
              • use_inline_type_params_for()
              • variant_args()
              • variant_closed_pattern()
              • wildcard_case_block()
              • with_definitions()
              • with_lambda()
              • with_let()
              • with_let_inline()
              • with_type_lambda()
              • wrap_in_nullary_lambda()
              • wrap_lazy_arguments()
            • hydra.python.environment module
              • PyGraph
                • PyGraph.Builder
                  • PyGraph.Builder.build()
                  • PyGraph.Builder.graph()
                  • PyGraph.Builder.metadata()
                • PyGraph.GRAPH
                • PyGraph.METADATA
                • PyGraph.TYPE_
                • PyGraph.builder()
                • PyGraph.graph
                • PyGraph.metadata
                • PyGraph.with_graph()
                • PyGraph.with_metadata()
              • PythonEnvironment
                • PythonEnvironment.BOUND_TYPE_VARIABLES
                • PythonEnvironment.Builder
                  • PythonEnvironment.Builder.bound_type_variables()
                  • PythonEnvironment.Builder.build()
                  • PythonEnvironment.Builder.graph()
                  • PythonEnvironment.Builder.inline_variables()
                  • PythonEnvironment.Builder.namespaces()
                  • PythonEnvironment.Builder.nullary_bindings()
                  • PythonEnvironment.Builder.overlay_subs()
                  • PythonEnvironment.Builder.skip_casts()
                  • PythonEnvironment.Builder.version()
                • PythonEnvironment.GRAPH
                • PythonEnvironment.INLINE_VARIABLES
                • PythonEnvironment.NAMESPACES
                • PythonEnvironment.NULLARY_BINDINGS
                • PythonEnvironment.OVERLAY_SUBS
                • PythonEnvironment.SKIP_CASTS
                • PythonEnvironment.TYPE_
                • PythonEnvironment.VERSION
                • PythonEnvironment.bound_type_variables
                • PythonEnvironment.builder()
                • PythonEnvironment.graph
                • PythonEnvironment.inline_variables
                • PythonEnvironment.namespaces
                • PythonEnvironment.nullary_bindings
                • PythonEnvironment.overlay_subs
                • PythonEnvironment.skip_casts
                • PythonEnvironment.version
                • PythonEnvironment.with_bound_type_variables()
                • PythonEnvironment.with_graph()
                • PythonEnvironment.with_inline_variables()
                • PythonEnvironment.with_namespaces()
                • PythonEnvironment.with_nullary_bindings()
                • PythonEnvironment.with_overlay_subs()
                • PythonEnvironment.with_skip_casts()
                • PythonEnvironment.with_version()
              • PythonModuleMetadata
                • PythonModuleMetadata.Builder
                  • PythonModuleMetadata.Builder.build()
                  • PythonModuleMetadata.Builder.namespaces()
                  • PythonModuleMetadata.Builder.type_variables()
                  • PythonModuleMetadata.Builder.uses_annotated()
                  • PythonModuleMetadata.Builder.uses_callable()
                  • PythonModuleMetadata.Builder.uses_cast()
                  • PythonModuleMetadata.Builder.uses_dataclass()
                  • PythonModuleMetadata.Builder.uses_decimal()
                  • PythonModuleMetadata.Builder.uses_either()
                  • PythonModuleMetadata.Builder.uses_enum()
                  • PythonModuleMetadata.Builder.uses_frozen_dict()
                  • PythonModuleMetadata.Builder.uses_frozen_list()
                  • PythonModuleMetadata.Builder.uses_frozen_set()
                  • PythonModuleMetadata.Builder.uses_generic()
                  • PythonModuleMetadata.Builder.uses_just()
                  • PythonModuleMetadata.Builder.uses_left()
                  • PythonModuleMetadata.Builder.uses_lru_cache()
                  • PythonModuleMetadata.Builder.uses_maybe()
                  • PythonModuleMetadata.Builder.uses_name()
                  • PythonModuleMetadata.Builder.uses_node()
                  • PythonModuleMetadata.Builder.uses_nothing()
                  • PythonModuleMetadata.Builder.uses_right()
                  • PythonModuleMetadata.Builder.uses_type_alias()
                  • PythonModuleMetadata.Builder.uses_type_var()
                • PythonModuleMetadata.NAMESPACES
                • PythonModuleMetadata.TYPE_
                • PythonModuleMetadata.TYPE_VARIABLES
                • PythonModuleMetadata.USES_ANNOTATED
                • PythonModuleMetadata.USES_CALLABLE
                • PythonModuleMetadata.USES_CAST
                • PythonModuleMetadata.USES_DATACLASS
                • PythonModuleMetadata.USES_DECIMAL
                • PythonModuleMetadata.USES_EITHER
                • PythonModuleMetadata.USES_ENUM
                • PythonModuleMetadata.USES_FROZEN_DICT
                • PythonModuleMetadata.USES_FROZEN_LIST
                • PythonModuleMetadata.USES_FROZEN_SET
                • PythonModuleMetadata.USES_GENERIC
                • PythonModuleMetadata.USES_JUST
                • PythonModuleMetadata.USES_LEFT
                • PythonModuleMetadata.USES_LRU_CACHE
                • PythonModuleMetadata.USES_MAYBE
                • PythonModuleMetadata.USES_NAME
                • PythonModuleMetadata.USES_NODE
                • PythonModuleMetadata.USES_NOTHING
                • PythonModuleMetadata.USES_RIGHT
                • PythonModuleMetadata.USES_TYPE_ALIAS
                • PythonModuleMetadata.USES_TYPE_VAR
                • PythonModuleMetadata.builder()
                • PythonModuleMetadata.namespaces
                • PythonModuleMetadata.type_variables
                • PythonModuleMetadata.uses_annotated
                • PythonModuleMetadata.uses_callable
                • PythonModuleMetadata.uses_cast
                • PythonModuleMetadata.uses_dataclass
                • PythonModuleMetadata.uses_decimal
                • PythonModuleMetadata.uses_either
                • PythonModuleMetadata.uses_enum
                • PythonModuleMetadata.uses_frozen_dict
                • PythonModuleMetadata.uses_frozen_list
                • PythonModuleMetadata.uses_frozen_set
                • PythonModuleMetadata.uses_generic
                • PythonModuleMetadata.uses_just
                • PythonModuleMetadata.uses_left
                • PythonModuleMetadata.uses_lru_cache
                • PythonModuleMetadata.uses_maybe
                • PythonModuleMetadata.uses_name
                • PythonModuleMetadata.uses_node
                • PythonModuleMetadata.uses_nothing
                • PythonModuleMetadata.uses_right
                • PythonModuleMetadata.uses_type_alias
                • PythonModuleMetadata.uses_type_var
                • PythonModuleMetadata.with_namespaces()
                • PythonModuleMetadata.with_type_variables()
                • PythonModuleMetadata.with_uses_annotated()
                • PythonModuleMetadata.with_uses_callable()
                • PythonModuleMetadata.with_uses_cast()
                • PythonModuleMetadata.with_uses_dataclass()
                • PythonModuleMetadata.with_uses_decimal()
                • PythonModuleMetadata.with_uses_either()
                • PythonModuleMetadata.with_uses_enum()
                • PythonModuleMetadata.with_uses_frozen_dict()
                • PythonModuleMetadata.with_uses_frozen_list()
                • PythonModuleMetadata.with_uses_frozen_set()
                • PythonModuleMetadata.with_uses_generic()
                • PythonModuleMetadata.with_uses_just()
                • PythonModuleMetadata.with_uses_left()
                • PythonModuleMetadata.with_uses_lru_cache()
                • PythonModuleMetadata.with_uses_maybe()
                • PythonModuleMetadata.with_uses_name()
                • PythonModuleMetadata.with_uses_node()
                • PythonModuleMetadata.with_uses_nothing()
                • PythonModuleMetadata.with_uses_right()
                • PythonModuleMetadata.with_uses_type_alias()
                • PythonModuleMetadata.with_uses_type_var()
              • PythonVersion
                • PythonVersion.PYTHON310
                • PythonVersion.PYTHON312
                • PythonVersion.TYPE_
            • hydra.python.language module
              • python_language()
              • python_reserved_words()
            • hydra.python.names module
              • encode_constant_for_field_name()
              • encode_constant_for_type_name()
              • encode_enum_value()
              • encode_field_name()
              • encode_name()
              • encode_name_qualified()
              • encode_namespace()
              • encode_namespace_string_with_overrides()
              • encode_namespace_with_overrides()
              • encode_type_variable()
              • overlay_python_module_aliases()
              • sanitize_python_name()
              • term_variable_reference()
              • type_variable_reference()
              • variable_reference()
              • variant_name()
            • hydra.python.pyproject module
              • PyProjectBuildConfiguration
                • PyProjectBuildConfiguration.Builder
                  • PyProjectBuildConfiguration.Builder.build()
                  • PyProjectBuildConfiguration.Builder.dependencies()
                • PyProjectBuildConfiguration.DEPENDENCIES
                • PyProjectBuildConfiguration.TYPE_
                • PyProjectBuildConfiguration.builder()
                • PyProjectBuildConfiguration.dependencies
                • PyProjectBuildConfiguration.with_dependencies()
            • hydra.python.serde module
              • annotated_rhs_to_expr()
              • annotated_statement_to_expr()
              • annotation_to_expr()
              • args_to_expr()
              • assignment_expression_to_expr()
              • assignment_to_expr()
              • atom_to_expr()
              • attribute_to_expr()
              • await_primary_to_expr()
              • bitwise_and_to_expr()
              • bitwise_or_to_expr()
              • bitwise_xor_to_expr()
              • block_to_expr()
              • capture_pattern_to_expr()
              • case_block_to_expr()
              • class_definition_to_expr()
              • class_pattern_to_expr()
              • closed_pattern_to_expr()
              • compare_op_bitwise_or_pair_to_expr()
              • compare_op_to_string()
              • comparison_to_expr()
              • compound_statement_to_expr()
              • conditional_to_expr()
              • conjunction_to_expr()
              • decorators_to_expr()
              • dict_to_expr()
              • disjunction_to_expr()
              • dotted_as_name_to_expr()
              • dotted_name_to_expr()
              • double_starred_kvpair_to_expr()
              • escape_python_string()
              • expression_to_expr()
              • factor_to_expr()
              • function_def_raw_to_expr()
              • function_definition_to_expr()
              • group_to_expr()
              • guard_to_expr()
              • import_from_as_name_to_expr()
              • import_from_targets_to_expr()
              • import_from_to_expr()
              • import_name_to_expr()
              • import_statement_to_expr()
              • inversion_to_expr()
              • keyword_pattern_to_expr()
              • keyword_patterns_to_expr()
              • kvpair_to_expr()
              • kwarg_or_double_starred_to_expr()
              • kwarg_or_starred_to_expr()
              • kwarg_to_expr()
              • lambda_param_no_default_to_expr()
              • lambda_parameters_to_expr()
              • lambda_star_etc_to_expr()
              • lambda_to_expr()
              • list_to_expr()
              • match_statement_to_expr()
              • module_to_expr()
              • name_or_attribute_to_expr()
              • name_to_expr()
              • named_expression_to_expr()
              • number_to_expr()
              • or_pattern_to_expr()
              • param_no_default_parameters_to_expr()
              • param_no_default_to_expr()
              • param_to_expr()
              • parameters_to_expr()
              • pattern_capture_target_to_expr()
              • pattern_to_expr()
              • patterns_to_expr()
              • pos_arg_to_expr()
              • positional_patterns_to_expr()
              • power_to_expr()
              • primary_rhs_to_expr()
              • primary_to_expr()
              • primary_with_rhs_to_expr()
              • python_doc_entity_ref()
              • python_float_literal_text()
              • raise_expression_to_expr()
              • raise_statement_to_expr()
              • relative_import_prefix_to_expr()
              • return_statement_to_expr()
              • set_to_expr()
              • shift_expression_to_expr()
              • simple_statement_to_expr()
              • simple_type_parameter_to_expr()
              • single_target_to_expr()
              • slice_or_starred_expression_to_expr()
              • slice_to_expr()
              • slices_to_expr()
              • star_atom_to_expr()
              • star_expression_to_expr()
              • star_named_expression_to_expr()
              • star_target_to_expr()
              • starred_expression_to_expr()
              • statement_to_expr()
              • string_prefix_to_text()
              • string_to_expr()
              • subject_expression_to_expr()
              • sum_to_expr()
              • t_primary_and_name_to_expr()
              • t_primary_to_expr()
              • target_with_star_atom_to_expr()
              • term_to_expr()
              • to_python_comments()
              • tuple_to_expr()
              • type_alias_to_expr()
              • type_parameter_to_expr()
              • typed_assignment_to_expr()
              • untyped_assignment_to_expr()
              • value_pattern_to_expr()
              • while_statement_to_expr()
            • hydra.python.syntax module
              • AnnotatedRhs
                • AnnotatedRhs.STAR
                • AnnotatedRhs.TYPE_
                • AnnotatedRhs.YIELD
              • AnnotatedRhsStar
              • AnnotatedRhsYield
              • AnnotatedStatement
                • AnnotatedStatement.Builder
                  • AnnotatedStatement.Builder.build()
                  • AnnotatedStatement.Builder.comment()
                  • AnnotatedStatement.Builder.statement()
                • AnnotatedStatement.COMMENT
                • AnnotatedStatement.STATEMENT
                • AnnotatedStatement.TYPE_
                • AnnotatedStatement.builder()
                • AnnotatedStatement.comment
                • AnnotatedStatement.statement
                • AnnotatedStatement.with_comment()
                • AnnotatedStatement.with_statement()
              • Annotation
                • Annotation.TYPE_
              • Args
                • Args.Builder
                  • Args.Builder.build()
                  • Args.Builder.kwarg_or_double_starred()
                  • Args.Builder.kwarg_or_starred()
                  • Args.Builder.positional()
                • Args.KWARG_OR_DOUBLE_STARRED
                • Args.KWARG_OR_STARRED
                • Args.POSITIONAL
                • Args.TYPE_
                • Args.builder()
                • Args.kwarg_or_double_starred
                • Args.kwarg_or_starred
                • Args.positional
                • Args.with_kwarg_or_double_starred()
                • Args.with_kwarg_or_starred()
                • Args.with_positional()
              • AsPattern
                • AsPattern.AS
                • AsPattern.Builder
                  • AsPattern.Builder.as_()
                  • AsPattern.Builder.build()
                  • AsPattern.Builder.pattern()
                • AsPattern.PATTERN
                • AsPattern.TYPE_
                • AsPattern.as_
                • AsPattern.builder()
                • AsPattern.pattern
                • AsPattern.with_as_()
                • AsPattern.with_pattern()
              • AssertStatement
                • AssertStatement.Builder
                  • AssertStatement.Builder.build()
                  • AssertStatement.Builder.expression1()
                  • AssertStatement.Builder.expression2()
                • AssertStatement.EXPRESSION1
                • AssertStatement.EXPRESSION2
                • AssertStatement.TYPE_
                • AssertStatement.builder()
                • AssertStatement.expression1
                • AssertStatement.expression2
                • AssertStatement.with_expression1()
                • AssertStatement.with_expression2()
              • Assignment
                • Assignment.AUG
                • Assignment.TYPED
                • Assignment.TYPE_
                • Assignment.UNTYPED
              • AssignmentAug
              • AssignmentExpression
                • AssignmentExpression.Builder
                  • AssignmentExpression.Builder.build()
                  • AssignmentExpression.Builder.expression()
                  • AssignmentExpression.Builder.name()
                • AssignmentExpression.EXPRESSION
                • AssignmentExpression.NAME
                • AssignmentExpression.TYPE_
                • AssignmentExpression.builder()
                • AssignmentExpression.expression
                • AssignmentExpression.name
                • AssignmentExpression.with_expression()
                • AssignmentExpression.with_name()
              • AssignmentTyped
              • AssignmentUntyped
              • Atom
                • Atom.DICT
                • Atom.DICTCOMP
                • Atom.ELLIPSIS
                • Atom.FALSE
                • Atom.GENEXP
                • Atom.GROUP
                • Atom.LIST
                • Atom.LISTCOMP
                • Atom.NAME
                • Atom.NONE
                • Atom.NUMBER
                • Atom.SET
                • Atom.SETCOMP
                • Atom.STRING
                • Atom.TRUE
                • Atom.TUPLE
                • Atom.TYPE_
              • AtomDict
              • AtomDictcomp
              • AtomEllipsis
              • AtomFalse
              • AtomGenexp
              • AtomGroup
              • AtomList
              • AtomListcomp
              • AtomName
              • AtomNone
              • AtomNumber
              • AtomSet
              • AtomSetcomp
              • AtomString
              • AtomTrue
              • AtomTuple
              • Attribute
                • Attribute.TYPE_
              • AugAssign
                • AugAssign.AMPERSAND_EQUAL
                • AugAssign.AT_EQUAL
                • AugAssign.BAR_EQUAL
                • AugAssign.CARET_EQUAL
                • AugAssign.DOUBLE_SLASH_EQUAL
                • AugAssign.LEFT_SHIFT_EQUAL
                • AugAssign.MINUS_EQUAL
                • AugAssign.PERCENT_EQUAL
                • AugAssign.PLUS_EQUAL
                • AugAssign.RIGHT_SHIFT_EQUAL
                • AugAssign.SLASH_EQUAL
                • AugAssign.STAR_STAR_EQUAL
                • AugAssign.TIMES_EQUAL
                • AugAssign.TYPE_
              • AugAssignment
                • AugAssignment.AUGASSIGN
                • AugAssignment.Builder
                  • AugAssignment.Builder.augassign()
                  • AugAssignment.Builder.build()
                  • AugAssignment.Builder.lhs()
                  • AugAssignment.Builder.rhs()
                • AugAssignment.LHS
                • AugAssignment.RHS
                • AugAssignment.TYPE_
                • AugAssignment.augassign
                • AugAssignment.builder()
                • AugAssignment.lhs
                • AugAssignment.rhs
                • AugAssignment.with_augassign()
                • AugAssignment.with_lhs()
                • AugAssignment.with_rhs()
              • AwaitPrimary
                • AwaitPrimary.AWAIT
                • AwaitPrimary.Builder
                  • AwaitPrimary.Builder.await_()
                  • AwaitPrimary.Builder.build()
                  • AwaitPrimary.Builder.primary()
                • AwaitPrimary.PRIMARY
                • AwaitPrimary.TYPE_
                • AwaitPrimary.await_
                • AwaitPrimary.builder()
                • AwaitPrimary.primary
                • AwaitPrimary.with_await_()
                • AwaitPrimary.with_primary()
              • BitwiseAnd
                • BitwiseAnd.Builder
                  • BitwiseAnd.Builder.build()
                  • BitwiseAnd.Builder.lhs()
                  • BitwiseAnd.Builder.rhs()
                • BitwiseAnd.LHS
                • BitwiseAnd.RHS
                • BitwiseAnd.TYPE_
                • BitwiseAnd.builder()
                • BitwiseAnd.lhs
                • BitwiseAnd.rhs
                • BitwiseAnd.with_lhs()
                • BitwiseAnd.with_rhs()
              • BitwiseOr
                • BitwiseOr.Builder
                  • BitwiseOr.Builder.build()
                  • BitwiseOr.Builder.lhs()
                  • BitwiseOr.Builder.rhs()
                • BitwiseOr.LHS
                • BitwiseOr.RHS
                • BitwiseOr.TYPE_
                • BitwiseOr.builder()
                • BitwiseOr.lhs
                • BitwiseOr.rhs
                • BitwiseOr.with_lhs()
                • BitwiseOr.with_rhs()
              • BitwiseXor
                • BitwiseXor.Builder
                  • BitwiseXor.Builder.build()
                  • BitwiseXor.Builder.lhs()
                  • BitwiseXor.Builder.rhs()
                • BitwiseXor.LHS
                • BitwiseXor.RHS
                • BitwiseXor.TYPE_
                • BitwiseXor.builder()
                • BitwiseXor.lhs
                • BitwiseXor.rhs
                • BitwiseXor.with_lhs()
                • BitwiseXor.with_rhs()
              • Block
                • Block.INDENTED
                • Block.SIMPLE
                • Block.TYPE_
              • BlockIndented
              • BlockSimple
              • CapturePattern
                • CapturePattern.TYPE_
              • CaseBlock
                • CaseBlock.BODY
                • CaseBlock.Builder
                  • CaseBlock.Builder.body()
                  • CaseBlock.Builder.build()
                  • CaseBlock.Builder.guard()
                  • CaseBlock.Builder.patterns()
                • CaseBlock.GUARD
                • CaseBlock.PATTERNS
                • CaseBlock.TYPE_
                • CaseBlock.body
                • CaseBlock.builder()
                • CaseBlock.guard
                • CaseBlock.patterns
                • CaseBlock.with_body()
                • CaseBlock.with_guard()
                • CaseBlock.with_patterns()
              • ClassDefinition
                • ClassDefinition.ARGUMENTS
                • ClassDefinition.BODY
                • ClassDefinition.Builder
                  • ClassDefinition.Builder.arguments()
                  • ClassDefinition.Builder.body()
                  • ClassDefinition.Builder.build()
                  • ClassDefinition.Builder.decorators()
                  • ClassDefinition.Builder.name()
                  • ClassDefinition.Builder.type_params()
                • ClassDefinition.DECORATORS
                • ClassDefinition.NAME
                • ClassDefinition.TYPE_
                • ClassDefinition.TYPE_PARAMS
                • ClassDefinition.arguments
                • ClassDefinition.body
                • ClassDefinition.builder()
                • ClassDefinition.decorators
                • ClassDefinition.name
                • ClassDefinition.type_params
                • ClassDefinition.with_arguments()
                • ClassDefinition.with_body()
                • ClassDefinition.with_decorators()
                • ClassDefinition.with_name()
                • ClassDefinition.with_type_params()
              • ClassPattern
                • ClassPattern.Builder
                  • ClassPattern.Builder.build()
                  • ClassPattern.Builder.keyword_patterns()
                  • ClassPattern.Builder.name_or_attribute()
                  • ClassPattern.Builder.positional_patterns()
                • ClassPattern.KEYWORD_PATTERNS
                • ClassPattern.NAME_OR_ATTRIBUTE
                • ClassPattern.POSITIONAL_PATTERNS
                • ClassPattern.TYPE_
                • ClassPattern.builder()
                • ClassPattern.keyword_patterns
                • ClassPattern.name_or_attribute
                • ClassPattern.positional_patterns
                • ClassPattern.with_keyword_patterns()
                • ClassPattern.with_name_or_attribute()
                • ClassPattern.with_positional_patterns()
              • ClosedPattern
                • ClosedPattern.CAPTURE
                • ClosedPattern.CLASS
                • ClosedPattern.GROUP
                • ClosedPattern.LITERAL
                • ClosedPattern.MAPPING
                • ClosedPattern.SEQUENCE
                • ClosedPattern.TYPE_
                • ClosedPattern.VALUE
                • ClosedPattern.WILDCARD
              • ClosedPatternCapture
              • ClosedPatternClass
              • ClosedPatternGroup
              • ClosedPatternLiteral
              • ClosedPatternMapping
              • ClosedPatternSequence
              • ClosedPatternValue
              • ClosedPatternWildcard
              • CommaStarEtc
                • CommaStarEtc.Builder
                  • CommaStarEtc.Builder.build()
                  • CommaStarEtc.Builder.keywords()
                  • CommaStarEtc.Builder.param_maybe_default()
                • CommaStarEtc.KEYWORDS
                • CommaStarEtc.PARAM_MAYBE_DEFAULT
                • CommaStarEtc.TYPE_
                • CommaStarEtc.builder()
                • CommaStarEtc.keywords
                • CommaStarEtc.param_maybe_default
                • CommaStarEtc.with_keywords()
                • CommaStarEtc.with_param_maybe_default()
              • CompareOp
                • CompareOp.EQ
                • CompareOp.GT
                • CompareOp.GTE
                • CompareOp.IN
                • CompareOp.IS
                • CompareOp.ISNOT
                • CompareOp.LT
                • CompareOp.LTE
                • CompareOp.NOTEQ
                • CompareOp.NOTIN
                • CompareOp.TYPE_
              • CompareOpBitwiseOrPair
                • CompareOpBitwiseOrPair.Builder
                  • CompareOpBitwiseOrPair.Builder.build()
                  • CompareOpBitwiseOrPair.Builder.operator()
                  • CompareOpBitwiseOrPair.Builder.rhs()
                • CompareOpBitwiseOrPair.OPERATOR
                • CompareOpBitwiseOrPair.RHS
                • CompareOpBitwiseOrPair.TYPE_
                • CompareOpBitwiseOrPair.builder()
                • CompareOpBitwiseOrPair.operator
                • CompareOpBitwiseOrPair.rhs
                • CompareOpBitwiseOrPair.with_operator()
                • CompareOpBitwiseOrPair.with_rhs()
              • Comparison
                • Comparison.Builder
                  • Comparison.Builder.build()
                  • Comparison.Builder.lhs()
                  • Comparison.Builder.rhs()
                • Comparison.LHS
                • Comparison.RHS
                • Comparison.TYPE_
                • Comparison.builder()
                • Comparison.lhs
                • Comparison.rhs
                • Comparison.with_lhs()
                • Comparison.with_rhs()
              • ComplexNumber
                • ComplexNumber.Builder
                  • ComplexNumber.Builder.build()
                  • ComplexNumber.Builder.imaginary()
                  • ComplexNumber.Builder.plus_or_minus()
                  • ComplexNumber.Builder.real()
                • ComplexNumber.IMAGINARY
                • ComplexNumber.PLUS_OR_MINUS
                • ComplexNumber.REAL
                • ComplexNumber.TYPE_
                • ComplexNumber.builder()
                • ComplexNumber.imaginary
                • ComplexNumber.plus_or_minus
                • ComplexNumber.real
                • ComplexNumber.with_imaginary()
                • ComplexNumber.with_plus_or_minus()
                • ComplexNumber.with_real()
              • CompoundStatement
                • CompoundStatement.CLASS_DEF
                • CompoundStatement.FOR
                • CompoundStatement.FUNCTION
                • CompoundStatement.IF
                • CompoundStatement.MATCH
                • CompoundStatement.TRY
                • CompoundStatement.TYPE_
                • CompoundStatement.WHILE
                • CompoundStatement.WITH
              • CompoundStatementClassDef
              • CompoundStatementFor
              • CompoundStatementFunction
              • CompoundStatementIf
              • CompoundStatementMatch
              • CompoundStatementTry
              • CompoundStatementWhile
              • CompoundStatementWith
              • Conditional
                • Conditional.BODY
                • Conditional.Builder
                  • Conditional.Builder.body()
                  • Conditional.Builder.build()
                  • Conditional.Builder.else_()
                  • Conditional.Builder.if_()
                • Conditional.ELSE
                • Conditional.IF
                • Conditional.TYPE_
                • Conditional.body
                • Conditional.builder()
                • Conditional.else_
                • Conditional.if_
                • Conditional.with_body()
                • Conditional.with_else_()
                • Conditional.with_if_()
              • Conjunction
                • Conjunction.TYPE_
              • Decorators
                • Decorators.TYPE_
              • Default
                • Default.TYPE_
              • DelStatement
                • DelStatement.TYPE_
              • DelTAtom
                • DelTAtom.NAME
                • DelTAtom.TARGET
                • DelTAtom.TARGETS
                • DelTAtom.TYPE_
              • DelTAtomName
              • DelTAtomTarget
              • DelTAtomTargets
              • DelTarget
                • DelTarget.DEL_T_ATOM
                • DelTarget.PRIMARY_AND_NAME
                • DelTarget.PRIMARY_AND_SLICES
                • DelTarget.TYPE_
              • DelTargetDelTAtom
              • DelTargetPrimaryAndName
              • DelTargetPrimaryAndSlices
              • DelTargets
                • DelTargets.TYPE_
              • Dict
                • Dict.TYPE_
              • Dictcomp
                • Dictcomp.Builder
                  • Dictcomp.Builder.build()
                  • Dictcomp.Builder.for_if_clauses()
                  • Dictcomp.Builder.kvpair()
                • Dictcomp.FOR_IF_CLAUSES
                • Dictcomp.KVPAIR
                • Dictcomp.TYPE_
                • Dictcomp.builder()
                • Dictcomp.for_if_clauses
                • Dictcomp.kvpair
                • Dictcomp.with_for_if_clauses()
                • Dictcomp.with_kvpair()
              • Disjunction
                • Disjunction.TYPE_
              • DottedAsName
                • DottedAsName.AS
                • DottedAsName.Builder
                  • DottedAsName.Builder.as_()
                  • DottedAsName.Builder.build()
                  • DottedAsName.Builder.name()
                • DottedAsName.NAME
                • DottedAsName.TYPE_
                • DottedAsName.as_
                • DottedAsName.builder()
                • DottedAsName.name
                • DottedAsName.with_as_()
                • DottedAsName.with_name()
              • DottedName
                • DottedName.TYPE_
              • DoubleStarPattern
                • DoubleStarPattern.TYPE_
              • DoubleStarTypeParameter
                • DoubleStarTypeParameter.Builder
                  • DoubleStarTypeParameter.Builder.build()
                  • DoubleStarTypeParameter.Builder.default()
                  • DoubleStarTypeParameter.Builder.name()
                • DoubleStarTypeParameter.DEFAULT
                • DoubleStarTypeParameter.NAME
                • DoubleStarTypeParameter.TYPE_
                • DoubleStarTypeParameter.builder()
                • DoubleStarTypeParameter.default
                • DoubleStarTypeParameter.name
                • DoubleStarTypeParameter.with_default()
                • DoubleStarTypeParameter.with_name()
              • DoubleStarredKvpair
                • DoubleStarredKvpair.PAIR
                • DoubleStarredKvpair.STARRED
                • DoubleStarredKvpair.TYPE_
              • DoubleStarredKvpairPair
              • DoubleStarredKvpairStarred
              • Eval
                • Eval.TYPE_
              • ExceptBlock
                • ExceptBlock.BODY
                • ExceptBlock.Builder
                  • ExceptBlock.Builder.body()
                  • ExceptBlock.Builder.build()
                  • ExceptBlock.Builder.expression()
                • ExceptBlock.EXPRESSION
                • ExceptBlock.TYPE_
                • ExceptBlock.body
                • ExceptBlock.builder()
                • ExceptBlock.expression
                • ExceptBlock.with_body()
                • ExceptBlock.with_expression()
              • ExceptExpression
                • ExceptExpression.AS
                • ExceptExpression.Builder
                  • ExceptExpression.Builder.as_()
                  • ExceptExpression.Builder.build()
                  • ExceptExpression.Builder.expression()
                • ExceptExpression.EXPRESSION
                • ExceptExpression.TYPE_
                • ExceptExpression.as_
                • ExceptExpression.builder()
                • ExceptExpression.expression
                • ExceptExpression.with_as_()
                • ExceptExpression.with_expression()
              • ExceptStarBlock
                • ExceptStarBlock.AS
                • ExceptStarBlock.BODY
                • ExceptStarBlock.Builder
                  • ExceptStarBlock.Builder.as_()
                  • ExceptStarBlock.Builder.body()
                  • ExceptStarBlock.Builder.build()
                  • ExceptStarBlock.Builder.expression()
                • ExceptStarBlock.EXPRESSION
                • ExceptStarBlock.TYPE_
                • ExceptStarBlock.as_
                • ExceptStarBlock.body
                • ExceptStarBlock.builder()
                • ExceptStarBlock.expression
                • ExceptStarBlock.with_as_()
                • ExceptStarBlock.with_body()
                • ExceptStarBlock.with_expression()
              • Expression
                • Expression.CONDITIONAL
                • Expression.LAMBDA
                • Expression.SIMPLE
                • Expression.TYPE_
              • ExpressionConditional
              • ExpressionLambda
              • ExpressionSimple
              • Factor
                • Factor.COMPLEMENT
                • Factor.NEGATIVE
                • Factor.POSITIVE
                • Factor.SIMPLE
                • Factor.TYPE_
              • FactorComplement
              • FactorNegative
              • FactorPositive
              • FactorSimple
              • File
                • File.TYPE_
              • ForIfClause
                • ForIfClause.ASYNC
                • ForIfClause.Builder
                  • ForIfClause.Builder.async_()
                  • ForIfClause.Builder.build()
                  • ForIfClause.Builder.ifs()
                  • ForIfClause.Builder.in_()
                  • ForIfClause.Builder.targets()
                • ForIfClause.IFS
                • ForIfClause.IN
                • ForIfClause.TARGETS
                • ForIfClause.TYPE_
                • ForIfClause.async_
                • ForIfClause.builder()
                • ForIfClause.ifs
                • ForIfClause.in_
                • ForIfClause.targets
                • ForIfClause.with_async_()
                • ForIfClause.with_ifs()
                • ForIfClause.with_in_()
                • ForIfClause.with_targets()
              • ForIfClauses
                • ForIfClauses.TYPE_
              • ForStatement
                • ForStatement.ASYNC
                • ForStatement.BODY
                • ForStatement.Builder
                  • ForStatement.Builder.async_()
                  • ForStatement.Builder.body()
                  • ForStatement.Builder.build()
                  • ForStatement.Builder.else_()
                  • ForStatement.Builder.expressions()
                  • ForStatement.Builder.targets()
                  • ForStatement.Builder.type_comment()
                • ForStatement.ELSE
                • ForStatement.EXPRESSIONS
                • ForStatement.TARGETS
                • ForStatement.TYPE_
                • ForStatement.TYPE_COMMENT
                • ForStatement.async_
                • ForStatement.body
                • ForStatement.builder()
                • ForStatement.else_
                • ForStatement.expressions
                • ForStatement.targets
                • ForStatement.type_comment
                • ForStatement.with_async_()
                • ForStatement.with_body()
                • ForStatement.with_else_()
                • ForStatement.with_expressions()
                • ForStatement.with_targets()
                • ForStatement.with_type_comment()
              • FuncTypeComment
                • FuncTypeComment.TYPE_
              • FunctionDefRaw
                • FunctionDefRaw.ASYNC
                • FunctionDefRaw.BLOCK
                • FunctionDefRaw.Builder
                  • FunctionDefRaw.Builder.async_()
                  • FunctionDefRaw.Builder.block()
                  • FunctionDefRaw.Builder.build()
                  • FunctionDefRaw.Builder.func_type_comment()
                  • FunctionDefRaw.Builder.name()
                  • FunctionDefRaw.Builder.params()
                  • FunctionDefRaw.Builder.return_type()
                  • FunctionDefRaw.Builder.type_params()
                • FunctionDefRaw.FUNC_TYPE_COMMENT
                • FunctionDefRaw.NAME
                • FunctionDefRaw.PARAMS
                • FunctionDefRaw.RETURN_TYPE
                • FunctionDefRaw.TYPE_
                • FunctionDefRaw.TYPE_PARAMS
                • FunctionDefRaw.async_
                • FunctionDefRaw.block
                • FunctionDefRaw.builder()
                • FunctionDefRaw.func_type_comment
                • FunctionDefRaw.name
                • FunctionDefRaw.params
                • FunctionDefRaw.return_type
                • FunctionDefRaw.type_params
                • FunctionDefRaw.with_async_()
                • FunctionDefRaw.with_block()
                • FunctionDefRaw.with_func_type_comment()
                • FunctionDefRaw.with_name()
                • FunctionDefRaw.with_params()
                • FunctionDefRaw.with_return_type()
                • FunctionDefRaw.with_type_params()
              • FunctionDefinition
                • FunctionDefinition.Builder
                  • FunctionDefinition.Builder.build()
                  • FunctionDefinition.Builder.decorators()
                  • FunctionDefinition.Builder.raw()
                • FunctionDefinition.DECORATORS
                • FunctionDefinition.RAW
                • FunctionDefinition.TYPE_
                • FunctionDefinition.builder()
                • FunctionDefinition.decorators
                • FunctionDefinition.raw
                • FunctionDefinition.with_decorators()
                • FunctionDefinition.with_raw()
              • Genexp
                • Genexp.Builder
                  • Genexp.Builder.build()
                  • Genexp.Builder.head()
                  • Genexp.Builder.tail()
                • Genexp.HEAD
                • Genexp.TAIL
                • Genexp.TYPE_
                • Genexp.builder()
                • Genexp.head
                • Genexp.tail
                • Genexp.with_head()
                • Genexp.with_tail()
              • GenexpHead
                • GenexpHead.ASSIGNMENT
                • GenexpHead.EXPRESSION
                • GenexpHead.TYPE_
              • GenexpHeadAssignment
              • GenexpHeadExpression
              • Group
                • Group.EXPRESSION
                • Group.TYPE_
                • Group.YIELD
              • GroupExpression
              • GroupPattern
                • GroupPattern.TYPE_
              • GroupYield
              • Guard
                • Guard.TYPE_
              • IfStatement
                • IfStatement.BODY
                • IfStatement.Builder
                  • IfStatement.Builder.body()
                  • IfStatement.Builder.build()
                  • IfStatement.Builder.condition()
                  • IfStatement.Builder.continuation()
                • IfStatement.CONDITION
                • IfStatement.CONTINUATION
                • IfStatement.TYPE_
                • IfStatement.body
                • IfStatement.builder()
                • IfStatement.condition
                • IfStatement.continuation
                • IfStatement.with_body()
                • IfStatement.with_condition()
                • IfStatement.with_continuation()
              • IfTail
                • IfTail.ELIF
                • IfTail.ELSE
                • IfTail.TYPE_
              • IfTailElif
              • IfTailElse
              • ImaginaryNumber
                • ImaginaryNumber.TYPE_
              • ImportFrom
                • ImportFrom.Builder
                  • ImportFrom.Builder.build()
                  • ImportFrom.Builder.dotted_name()
                  • ImportFrom.Builder.prefixes()
                  • ImportFrom.Builder.targets()
                • ImportFrom.DOTTED_NAME
                • ImportFrom.PREFIXES
                • ImportFrom.TARGETS
                • ImportFrom.TYPE_
                • ImportFrom.builder()
                • ImportFrom.dotted_name
                • ImportFrom.prefixes
                • ImportFrom.targets
                • ImportFrom.with_dotted_name()
                • ImportFrom.with_prefixes()
                • ImportFrom.with_targets()
              • ImportFromAsName
                • ImportFromAsName.AS
                • ImportFromAsName.Builder
                  • ImportFromAsName.Builder.as_()
                  • ImportFromAsName.Builder.build()
                  • ImportFromAsName.Builder.name()
                • ImportFromAsName.NAME
                • ImportFromAsName.TYPE_
                • ImportFromAsName.as_
                • ImportFromAsName.builder()
                • ImportFromAsName.name
                • ImportFromAsName.with_as_()
                • ImportFromAsName.with_name()
              • ImportFromTargets
                • ImportFromTargets.PARENS
                • ImportFromTargets.SIMPLE
                • ImportFromTargets.STAR
                • ImportFromTargets.TYPE_
              • ImportFromTargetsParens
              • ImportFromTargetsSimple
              • ImportFromTargetsStar
              • ImportName
                • ImportName.TYPE_
              • ImportStatement
                • ImportStatement.FROM
                • ImportStatement.NAME
                • ImportStatement.TYPE_
              • ImportStatementFrom
              • ImportStatementName
              • Interactive
                • Interactive.TYPE_
              • Inversion
                • Inversion.NOT
                • Inversion.SIMPLE
                • Inversion.TYPE_
              • InversionNot
              • InversionSimple
              • ItemsPattern
                • ItemsPattern.TYPE_
              • KeyValuePattern
                • KeyValuePattern.Builder
                  • KeyValuePattern.Builder.build()
                  • KeyValuePattern.Builder.key()
                  • KeyValuePattern.Builder.value()
                • KeyValuePattern.KEY
                • KeyValuePattern.TYPE_
                • KeyValuePattern.VALUE
                • KeyValuePattern.builder()
                • KeyValuePattern.key
                • KeyValuePattern.value
                • KeyValuePattern.with_key()
                • KeyValuePattern.with_value()
              • KeywordPattern
                • KeywordPattern.Builder
                  • KeywordPattern.Builder.build()
                  • KeywordPattern.Builder.name()
                  • KeywordPattern.Builder.pattern()
                • KeywordPattern.NAME
                • KeywordPattern.PATTERN
                • KeywordPattern.TYPE_
                • KeywordPattern.builder()
                • KeywordPattern.name
                • KeywordPattern.pattern
                • KeywordPattern.with_name()
                • KeywordPattern.with_pattern()
              • KeywordPatterns
                • KeywordPatterns.TYPE_
              • Keywords
                • Keywords.TYPE_
              • Kvpair
                • Kvpair.Builder
                  • Kvpair.Builder.build()
                  • Kvpair.Builder.key()
                  • Kvpair.Builder.value()
                • Kvpair.KEY
                • Kvpair.TYPE_
                • Kvpair.VALUE
                • Kvpair.builder()
                • Kvpair.key
                • Kvpair.value
                • Kvpair.with_key()
                • Kvpair.with_value()
              • Kwarg
                • Kwarg.Builder
                  • Kwarg.Builder.build()
                  • Kwarg.Builder.name()
                  • Kwarg.Builder.value()
                • Kwarg.NAME
                • Kwarg.TYPE_
                • Kwarg.VALUE
                • Kwarg.builder()
                • Kwarg.name
                • Kwarg.value
                • Kwarg.with_name()
                • Kwarg.with_value()
              • KwargOrDoubleStarred
                • KwargOrDoubleStarred.DOUBLE_STARRED
                • KwargOrDoubleStarred.KWARG
                • KwargOrDoubleStarred.TYPE_
              • KwargOrDoubleStarredDoubleStarred
              • KwargOrDoubleStarredKwarg
              • KwargOrStarred
                • KwargOrStarred.KWARG
                • KwargOrStarred.STARRED
                • KwargOrStarred.TYPE_
              • KwargOrStarredKwarg
              • KwargOrStarredStarred
              • Lambda
                • Lambda.BODY
                • Lambda.Builder
                  • Lambda.Builder.body()
                  • Lambda.Builder.build()
                  • Lambda.Builder.params()
                • Lambda.PARAMS
                • Lambda.TYPE_
                • Lambda.body
                • Lambda.builder()
                • Lambda.params
                • Lambda.with_body()
                • Lambda.with_params()
              • LambdaKwds
                • LambdaKwds.TYPE_
              • LambdaParamMaybeDefault
                • LambdaParamMaybeDefault.Builder
                  • LambdaParamMaybeDefault.Builder.build()
                  • LambdaParamMaybeDefault.Builder.default()
                  • LambdaParamMaybeDefault.Builder.param()
                • LambdaParamMaybeDefault.DEFAULT
                • LambdaParamMaybeDefault.PARAM
                • LambdaParamMaybeDefault.TYPE_
                • LambdaParamMaybeDefault.builder()
                • LambdaParamMaybeDefault.default
                • LambdaParamMaybeDefault.param
                • LambdaParamMaybeDefault.with_default()
                • LambdaParamMaybeDefault.with_param()
              • LambdaParamNoDefault
                • LambdaParamNoDefault.TYPE_
              • LambdaParamWithDefault
                • LambdaParamWithDefault.Builder
                  • LambdaParamWithDefault.Builder.build()
                  • LambdaParamWithDefault.Builder.default()
                  • LambdaParamWithDefault.Builder.param()
                • LambdaParamWithDefault.DEFAULT
                • LambdaParamWithDefault.PARAM
                • LambdaParamWithDefault.TYPE_
                • LambdaParamWithDefault.builder()
                • LambdaParamWithDefault.default
                • LambdaParamWithDefault.param
                • LambdaParamWithDefault.with_default()
                • LambdaParamWithDefault.with_param()
              • LambdaParameters
                • LambdaParameters.Builder
                  • LambdaParameters.Builder.build()
                  • LambdaParameters.Builder.param_no_default()
                  • LambdaParameters.Builder.param_with_default()
                  • LambdaParameters.Builder.slash_no_default()
                  • LambdaParameters.Builder.star_etc()
                • LambdaParameters.PARAM_NO_DEFAULT
                • LambdaParameters.PARAM_WITH_DEFAULT
                • LambdaParameters.SLASH_NO_DEFAULT
                • LambdaParameters.STAR_ETC
                • LambdaParameters.TYPE_
                • LambdaParameters.builder()
                • LambdaParameters.param_no_default
                • LambdaParameters.param_with_default
                • LambdaParameters.slash_no_default
                • LambdaParameters.star_etc
                • LambdaParameters.with_param_no_default()
                • LambdaParameters.with_param_with_default()
                • LambdaParameters.with_slash_no_default()
                • LambdaParameters.with_star_etc()
              • LambdaSlashNoDefault
                • LambdaSlashNoDefault.Builder
                  • LambdaSlashNoDefault.Builder.build()
                  • LambdaSlashNoDefault.Builder.parameters()
                • LambdaSlashNoDefault.PARAMETERS
                • LambdaSlashNoDefault.TYPE_
                • LambdaSlashNoDefault.builder()
                • LambdaSlashNoDefault.parameters
                • LambdaSlashNoDefault.with_parameters()
              • LambdaSlashWithDefault
                • LambdaSlashWithDefault.Builder
                  • LambdaSlashWithDefault.Builder.build()
                  • LambdaSlashWithDefault.Builder.param_no_default()
                  • LambdaSlashWithDefault.Builder.param_with_default()
                • LambdaSlashWithDefault.PARAM_NO_DEFAULT
                • LambdaSlashWithDefault.PARAM_WITH_DEFAULT
                • LambdaSlashWithDefault.TYPE_
                • LambdaSlashWithDefault.builder()
                • LambdaSlashWithDefault.param_no_default
                • LambdaSlashWithDefault.param_with_default
                • LambdaSlashWithDefault.with_param_no_default()
                • LambdaSlashWithDefault.with_param_with_default()
              • LambdaStarEtc
                • LambdaStarEtc.KWDS
                • LambdaStarEtc.PARAM_MAYBE_DEFAULT
                • LambdaStarEtc.PARAM_NO_DEFAULT
                • LambdaStarEtc.STAR
                • LambdaStarEtc.TYPE_
              • LambdaStarEtcKwds
              • LambdaStarEtcParamMaybeDefault
              • LambdaStarEtcParamNoDefault
              • LambdaStarEtcStar
              • List
                • List.TYPE_
              • Listcomp
                • Listcomp.Builder
                  • Listcomp.Builder.build()
                  • Listcomp.Builder.expression()
                  • Listcomp.Builder.for_if_clauses()
                • Listcomp.EXPRESSION
                • Listcomp.FOR_IF_CLAUSES
                • Listcomp.TYPE_
                • Listcomp.builder()
                • Listcomp.expression
                • Listcomp.for_if_clauses
                • Listcomp.with_expression()
                • Listcomp.with_for_if_clauses()
              • LiteralExpression
                • LiteralExpression.COMPLEX
                • LiteralExpression.FALSE
                • LiteralExpression.NONE
                • LiteralExpression.NUMBER
                • LiteralExpression.STRING
                • LiteralExpression.TRUE
                • LiteralExpression.TYPE_
              • LiteralExpressionComplex
              • LiteralExpressionFalse
              • LiteralExpressionNone
              • LiteralExpressionNumber
              • LiteralExpressionOrAttribute
                • LiteralExpressionOrAttribute.ATTRIBUTE
                • LiteralExpressionOrAttribute.LITERAL
                • LiteralExpressionOrAttribute.TYPE_
              • LiteralExpressionOrAttributeAttribute
              • LiteralExpressionOrAttributeLiteral
              • LiteralExpressionString
              • LiteralExpressionTrue
              • MappingPattern
                • MappingPattern.Builder
                  • MappingPattern.Builder.build()
                  • MappingPattern.Builder.double_star()
                  • MappingPattern.Builder.items()
                • MappingPattern.DOUBLE_STAR
                • MappingPattern.ITEMS
                • MappingPattern.TYPE_
                • MappingPattern.builder()
                • MappingPattern.double_star
                • MappingPattern.items
                • MappingPattern.with_double_star()
                • MappingPattern.with_items()
              • MatchStatement
                • MatchStatement.Builder
                  • MatchStatement.Builder.build()
                  • MatchStatement.Builder.cases()
                  • MatchStatement.Builder.subject()
                • MatchStatement.CASES
                • MatchStatement.SUBJECT
                • MatchStatement.TYPE_
                • MatchStatement.builder()
                • MatchStatement.cases
                • MatchStatement.subject
                • MatchStatement.with_cases()
                • MatchStatement.with_subject()
              • MaybeSequencePattern
                • MaybeSequencePattern.TYPE_
              • MaybeStarPattern
                • MaybeStarPattern.PATTERN
                • MaybeStarPattern.STAR
                • MaybeStarPattern.TYPE_
              • MaybeStarPatternPattern
              • MaybeStarPatternStar
              • Module
                • Module.TYPE_
              • Name
                • Name.TYPE_
              • NameOrAttribute
                • NameOrAttribute.TYPE_
              • NamedExpression
                • NamedExpression.ASSIGNMENT
                • NamedExpression.SIMPLE
                • NamedExpression.TYPE_
              • NamedExpressionAssignment
              • NamedExpressionSimple
              • NoDefaultStarAnnotationStarEtc
                • NoDefaultStarAnnotationStarEtc.Builder
                  • NoDefaultStarAnnotationStarEtc.Builder.build()
                  • NoDefaultStarAnnotationStarEtc.Builder.keywords()
                  • NoDefaultStarAnnotationStarEtc.Builder.param_maybe_default()
                  • NoDefaultStarAnnotationStarEtc.Builder.param_no_default_star_annotation()
                • NoDefaultStarAnnotationStarEtc.KEYWORDS
                • NoDefaultStarAnnotationStarEtc.PARAM_MAYBE_DEFAULT
                • NoDefaultStarAnnotationStarEtc.PARAM_NO_DEFAULT_STAR_ANNOTATION
                • NoDefaultStarAnnotationStarEtc.TYPE_
                • NoDefaultStarAnnotationStarEtc.builder()
                • NoDefaultStarAnnotationStarEtc.keywords
                • NoDefaultStarAnnotationStarEtc.param_maybe_default
                • NoDefaultStarAnnotationStarEtc.param_no_default_star_annotation
                • NoDefaultStarAnnotationStarEtc.with_keywords()
                • NoDefaultStarAnnotationStarEtc.with_param_maybe_default()
                • NoDefaultStarAnnotationStarEtc.with_param_no_default_star_annotation()
              • NoDefaultStarEtc
                • NoDefaultStarEtc.Builder
                  • NoDefaultStarEtc.Builder.build()
                  • NoDefaultStarEtc.Builder.keywords()
                  • NoDefaultStarEtc.Builder.param_maybe_default()
                  • NoDefaultStarEtc.Builder.param_no_default()
                • NoDefaultStarEtc.KEYWORDS
                • NoDefaultStarEtc.PARAM_MAYBE_DEFAULT
                • NoDefaultStarEtc.PARAM_NO_DEFAULT
                • NoDefaultStarEtc.TYPE_
                • NoDefaultStarEtc.builder()
                • NoDefaultStarEtc.keywords
                • NoDefaultStarEtc.param_maybe_default
                • NoDefaultStarEtc.param_no_default
                • NoDefaultStarEtc.with_keywords()
                • NoDefaultStarEtc.with_param_maybe_default()
                • NoDefaultStarEtc.with_param_no_default()
              • Number
                • Number.FLOAT
                • Number.IMAGINARY
                • Number.INTEGER
                • Number.TYPE_
              • NumberFloat
              • NumberImaginary
              • NumberInteger
              • OpenSequencePattern
                • OpenSequencePattern.Builder
                  • OpenSequencePattern.Builder.build()
                  • OpenSequencePattern.Builder.head()
                  • OpenSequencePattern.Builder.tail()
                • OpenSequencePattern.HEAD
                • OpenSequencePattern.TAIL
                • OpenSequencePattern.TYPE_
                • OpenSequencePattern.builder()
                • OpenSequencePattern.head
                • OpenSequencePattern.tail
                • OpenSequencePattern.with_head()
                • OpenSequencePattern.with_tail()
              • OrPattern
                • OrPattern.TYPE_
              • Param
                • Param.ANNOTATION
                • Param.Builder
                  • Param.Builder.annotation()
                  • Param.Builder.build()
                  • Param.Builder.name()
                • Param.NAME
                • Param.TYPE_
                • Param.annotation
                • Param.builder()
                • Param.name
                • Param.with_annotation()
                • Param.with_name()
              • ParamMaybeDefault
                • ParamMaybeDefault.Builder
                  • ParamMaybeDefault.Builder.build()
                  • ParamMaybeDefault.Builder.default()
                  • ParamMaybeDefault.Builder.param()
                  • ParamMaybeDefault.Builder.type_comment()
                • ParamMaybeDefault.DEFAULT
                • ParamMaybeDefault.PARAM
                • ParamMaybeDefault.TYPE_
                • ParamMaybeDefault.TYPE_COMMENT
                • ParamMaybeDefault.builder()
                • ParamMaybeDefault.default
                • ParamMaybeDefault.param
                • ParamMaybeDefault.type_comment
                • ParamMaybeDefault.with_default()
                • ParamMaybeDefault.with_param()
                • ParamMaybeDefault.with_type_comment()
              • ParamNoDefault
                • ParamNoDefault.Builder
                  • ParamNoDefault.Builder.build()
                  • ParamNoDefault.Builder.param()
                  • ParamNoDefault.Builder.type_comment()
                • ParamNoDefault.PARAM
                • ParamNoDefault.TYPE_
                • ParamNoDefault.TYPE_COMMENT
                • ParamNoDefault.builder()
                • ParamNoDefault.param
                • ParamNoDefault.type_comment
                • ParamNoDefault.with_param()
                • ParamNoDefault.with_type_comment()
              • ParamNoDefaultParameters
                • ParamNoDefaultParameters.Builder
                  • ParamNoDefaultParameters.Builder.build()
                  • ParamNoDefaultParameters.Builder.param_no_default()
                  • ParamNoDefaultParameters.Builder.param_with_default()
                  • ParamNoDefaultParameters.Builder.star_etc()
                • ParamNoDefaultParameters.PARAM_NO_DEFAULT
                • ParamNoDefaultParameters.PARAM_WITH_DEFAULT
                • ParamNoDefaultParameters.STAR_ETC
                • ParamNoDefaultParameters.TYPE_
                • ParamNoDefaultParameters.builder()
                • ParamNoDefaultParameters.param_no_default
                • ParamNoDefaultParameters.param_with_default
                • ParamNoDefaultParameters.star_etc
                • ParamNoDefaultParameters.with_param_no_default()
                • ParamNoDefaultParameters.with_param_with_default()
                • ParamNoDefaultParameters.with_star_etc()
              • ParamNoDefaultStarAnnotation
                • ParamNoDefaultStarAnnotation.Builder
                  • ParamNoDefaultStarAnnotation.Builder.build()
                  • ParamNoDefaultStarAnnotation.Builder.param_star_annotation()
                  • ParamNoDefaultStarAnnotation.Builder.type_comment()
                • ParamNoDefaultStarAnnotation.PARAM_STAR_ANNOTATION
                • ParamNoDefaultStarAnnotation.TYPE_
                • ParamNoDefaultStarAnnotation.TYPE_COMMENT
                • ParamNoDefaultStarAnnotation.builder()
                • ParamNoDefaultStarAnnotation.param_star_annotation
                • ParamNoDefaultStarAnnotation.type_comment
                • ParamNoDefaultStarAnnotation.with_param_star_annotation()
                • ParamNoDefaultStarAnnotation.with_type_comment()
              • ParamStarAnnotation
                • ParamStarAnnotation.ANNOTATION
                • ParamStarAnnotation.Builder
                  • ParamStarAnnotation.Builder.annotation()
                  • ParamStarAnnotation.Builder.build()
                  • ParamStarAnnotation.Builder.name()
                • ParamStarAnnotation.NAME
                • ParamStarAnnotation.TYPE_
                • ParamStarAnnotation.annotation
                • ParamStarAnnotation.builder()
                • ParamStarAnnotation.name
                • ParamStarAnnotation.with_annotation()
                • ParamStarAnnotation.with_name()
              • ParamWithDefault
                • ParamWithDefault.Builder
                  • ParamWithDefault.Builder.build()
                  • ParamWithDefault.Builder.default()
                  • ParamWithDefault.Builder.param()
                  • ParamWithDefault.Builder.type_comment()
                • ParamWithDefault.DEFAULT
                • ParamWithDefault.PARAM
                • ParamWithDefault.TYPE_
                • ParamWithDefault.TYPE_COMMENT
                • ParamWithDefault.builder()
                • ParamWithDefault.default
                • ParamWithDefault.param
                • ParamWithDefault.type_comment
                • ParamWithDefault.with_default()
                • ParamWithDefault.with_param()
                • ParamWithDefault.with_type_comment()
              • ParamWithDefaultParameters
                • ParamWithDefaultParameters.Builder
                  • ParamWithDefaultParameters.Builder.build()
                  • ParamWithDefaultParameters.Builder.param_with_default()
                  • ParamWithDefaultParameters.Builder.star_etc()
                • ParamWithDefaultParameters.PARAM_WITH_DEFAULT
                • ParamWithDefaultParameters.STAR_ETC
                • ParamWithDefaultParameters.TYPE_
                • ParamWithDefaultParameters.builder()
                • ParamWithDefaultParameters.param_with_default
                • ParamWithDefaultParameters.star_etc
                • ParamWithDefaultParameters.with_param_with_default()
                • ParamWithDefaultParameters.with_star_etc()
              • Parameters
                • Parameters.PARAM_NO_DEFAULT
                • Parameters.PARAM_WITH_DEFAULT
                • Parameters.SLASH_NO_DEFAULT
                • Parameters.SLASH_WITH_DEFAULT
                • Parameters.STAR_ETC
                • Parameters.TYPE_
              • ParametersParamNoDefault
              • ParametersParamWithDefault
              • ParametersSlashNoDefault
              • ParametersSlashWithDefault
              • ParametersStarEtc
              • Pattern
                • Pattern.AS
                • Pattern.OR
                • Pattern.TYPE_
              • PatternAs
              • PatternCaptureTarget
                • PatternCaptureTarget.TYPE_
              • PatternOr
              • Patterns
                • Patterns.PATTERN
                • Patterns.SEQUENCE
                • Patterns.TYPE_
              • PatternsPattern
              • PatternsSequence
              • PlusOrMinus
                • PlusOrMinus.MINUS
                • PlusOrMinus.PLUS
                • PlusOrMinus.TYPE_
              • PosArg
                • PosArg.ASSIGNMENT
                • PosArg.EXPRESSION
                • PosArg.STARRED
                • PosArg.TYPE_
              • PosArgAssignment
              • PosArgExpression
              • PosArgStarred
              • PositionalPatterns
                • PositionalPatterns.TYPE_
              • Power
                • Power.Builder
                  • Power.Builder.build()
                  • Power.Builder.lhs()
                  • Power.Builder.rhs()
                • Power.LHS
                • Power.RHS
                • Power.TYPE_
                • Power.builder()
                • Power.lhs
                • Power.rhs
                • Power.with_lhs()
                • Power.with_rhs()
              • Primary
                • Primary.COMPOUND
                • Primary.SIMPLE
                • Primary.TYPE_
              • PrimaryCompound
              • PrimaryRhs
                • PrimaryRhs.CALL
                • PrimaryRhs.GENEXP
                • PrimaryRhs.PROJECT
                • PrimaryRhs.SLICES
                • PrimaryRhs.TYPE_
              • PrimaryRhsCall
              • PrimaryRhsGenexp
              • PrimaryRhsProject
              • PrimaryRhsSlices
              • PrimarySimple
              • PrimaryWithRhs
                • PrimaryWithRhs.Builder
                  • PrimaryWithRhs.Builder.build()
                  • PrimaryWithRhs.Builder.primary()
                  • PrimaryWithRhs.Builder.rhs()
                • PrimaryWithRhs.PRIMARY
                • PrimaryWithRhs.RHS
                • PrimaryWithRhs.TYPE_
                • PrimaryWithRhs.builder()
                • PrimaryWithRhs.primary
                • PrimaryWithRhs.rhs
                • PrimaryWithRhs.with_primary()
                • PrimaryWithRhs.with_rhs()
              • QuoteStyle
                • QuoteStyle.DOUBLE
                • QuoteStyle.SINGLE
                • QuoteStyle.TRIPLE_DOUBLE
                • QuoteStyle.TRIPLE_SINGLE
                • QuoteStyle.TYPE_
              • RaiseExpression
                • RaiseExpression.Builder
                  • RaiseExpression.Builder.build()
                  • RaiseExpression.Builder.expression()
                  • RaiseExpression.Builder.from_()
                • RaiseExpression.EXPRESSION
                • RaiseExpression.FROM
                • RaiseExpression.TYPE_
                • RaiseExpression.builder()
                • RaiseExpression.expression
                • RaiseExpression.from_
                • RaiseExpression.with_expression()
                • RaiseExpression.with_from_()
              • RaiseStatement
                • RaiseStatement.TYPE_
              • RealNumber
                • RealNumber.FLOAT
                • RealNumber.INTEGER
                • RealNumber.TYPE_
              • RealNumberFloat
              • RealNumberInteger
              • RelativeImportPrefix
                • RelativeImportPrefix.DOT
                • RelativeImportPrefix.ELLIPSIS
                • RelativeImportPrefix.TYPE_
              • ReturnStatement
                • ReturnStatement.TYPE_
              • SequencePattern
                • SequencePattern.LIST
                • SequencePattern.TUPLE
                • SequencePattern.TYPE_
              • SequencePatternList
              • SequencePatternTuple
              • Set
                • Set.TYPE_
              • Setcomp
                • Setcomp.Builder
                  • Setcomp.Builder.build()
                  • Setcomp.Builder.expression()
                  • Setcomp.Builder.for_if_clauses()
                • Setcomp.EXPRESSION
                • Setcomp.FOR_IF_CLAUSES
                • Setcomp.TYPE_
                • Setcomp.builder()
                • Setcomp.expression
                • Setcomp.for_if_clauses
                • Setcomp.with_expression()
                • Setcomp.with_for_if_clauses()
              • ShiftExpression
                • ShiftExpression.Builder
                  • ShiftExpression.Builder.build()
                  • ShiftExpression.Builder.lhs()
                  • ShiftExpression.Builder.rhs()
                • ShiftExpression.LHS
                • ShiftExpression.RHS
                • ShiftExpression.TYPE_
                • ShiftExpression.builder()
                • ShiftExpression.lhs
                • ShiftExpression.rhs
                • ShiftExpression.with_lhs()
                • ShiftExpression.with_rhs()
              • ShiftLhs
                • ShiftLhs.Builder
                  • ShiftLhs.Builder.build()
                  • ShiftLhs.Builder.operand()
                  • ShiftLhs.Builder.operator()
                • ShiftLhs.OPERAND
                • ShiftLhs.OPERATOR
                • ShiftLhs.TYPE_
                • ShiftLhs.builder()
                • ShiftLhs.operand
                • ShiftLhs.operator
                • ShiftLhs.with_operand()
                • ShiftLhs.with_operator()
              • ShiftOp
                • ShiftOp.LEFT
                • ShiftOp.RIGHT
                • ShiftOp.TYPE_
              • SignedNumber
                • SignedNumber.NUMBER
                • SignedNumber.SIGN
                • SignedNumber.TYPE_
              • SignedNumberNumber
              • SignedNumberSign
              • SignedRealNumber
                • SignedRealNumber.NUMBER
                • SignedRealNumber.SIGN
                • SignedRealNumber.TYPE_
              • SignedRealNumberNumber
              • SignedRealNumberSign
              • SimpleStatement
                • SimpleStatement.ASSERT
                • SimpleStatement.ASSIGNMENT
                • SimpleStatement.BREAK
                • SimpleStatement.CONTINUE
                • SimpleStatement.DEL
                • SimpleStatement.GLOBAL
                • SimpleStatement.IMPORT
                • SimpleStatement.NONLOCAL
                • SimpleStatement.PASS
                • SimpleStatement.RAISE
                • SimpleStatement.RETURN
                • SimpleStatement.STAR_EXPRESSIONS
                • SimpleStatement.TYPE_
                • SimpleStatement.TYPE_ALIAS
                • SimpleStatement.YIELD
              • SimpleStatementAssert
              • SimpleStatementAssignment
              • SimpleStatementBreak
              • SimpleStatementContinue
              • SimpleStatementDel
              • SimpleStatementGlobal
              • SimpleStatementImport
              • SimpleStatementNonlocal
              • SimpleStatementPass
              • SimpleStatementRaise
              • SimpleStatementReturn
              • SimpleStatementStarExpressions
              • SimpleStatementTypeAlias
              • SimpleStatementYield
              • SimpleTypeParameter
                • SimpleTypeParameter.BOUND
                • SimpleTypeParameter.Builder
                  • SimpleTypeParameter.Builder.bound()
                  • SimpleTypeParameter.Builder.build()
                  • SimpleTypeParameter.Builder.default()
                  • SimpleTypeParameter.Builder.name()
                • SimpleTypeParameter.DEFAULT
                • SimpleTypeParameter.NAME
                • SimpleTypeParameter.TYPE_
                • SimpleTypeParameter.bound
                • SimpleTypeParameter.builder()
                • SimpleTypeParameter.default
                • SimpleTypeParameter.name
                • SimpleTypeParameter.with_bound()
                • SimpleTypeParameter.with_default()
                • SimpleTypeParameter.with_name()
              • SingleSubscriptAttributeTarget
                • SingleSubscriptAttributeTarget.PRIMARY_AND_NAME
                • SingleSubscriptAttributeTarget.PRIMARY_AND_SLICES
                • SingleSubscriptAttributeTarget.TYPE_
              • SingleSubscriptAttributeTargetPrimaryAndName
              • SingleSubscriptAttributeTargetPrimaryAndSlices
              • SingleTarget
                • SingleTarget.NAME
                • SingleTarget.PARENS
                • SingleTarget.SUBSCRIPT_ATTRIBUTE_TARGET
                • SingleTarget.TYPE_
              • SingleTargetName
              • SingleTargetParens
              • SingleTargetSubscriptAttributeTarget
              • SlashNoDefault
                • SlashNoDefault.TYPE_
              • SlashNoDefaultParameters
                • SlashNoDefaultParameters.Builder
                  • SlashNoDefaultParameters.Builder.build()
                  • SlashNoDefaultParameters.Builder.param_no_default()
                  • SlashNoDefaultParameters.Builder.param_with_default()
                  • SlashNoDefaultParameters.Builder.slash()
                  • SlashNoDefaultParameters.Builder.star_etc()
                • SlashNoDefaultParameters.PARAM_NO_DEFAULT
                • SlashNoDefaultParameters.PARAM_WITH_DEFAULT
                • SlashNoDefaultParameters.SLASH
                • SlashNoDefaultParameters.STAR_ETC
                • SlashNoDefaultParameters.TYPE_
                • SlashNoDefaultParameters.builder()
                • SlashNoDefaultParameters.param_no_default
                • SlashNoDefaultParameters.param_with_default
                • SlashNoDefaultParameters.slash
                • SlashNoDefaultParameters.star_etc
                • SlashNoDefaultParameters.with_param_no_default()
                • SlashNoDefaultParameters.with_param_with_default()
                • SlashNoDefaultParameters.with_slash()
                • SlashNoDefaultParameters.with_star_etc()
              • SlashWithDefault
                • SlashWithDefault.Builder
                  • SlashWithDefault.Builder.build()
                  • SlashWithDefault.Builder.param_no_default()
                  • SlashWithDefault.Builder.param_with_default()
                • SlashWithDefault.PARAM_NO_DEFAULT
                • SlashWithDefault.PARAM_WITH_DEFAULT
                • SlashWithDefault.TYPE_
                • SlashWithDefault.builder()
                • SlashWithDefault.param_no_default
                • SlashWithDefault.param_with_default
                • SlashWithDefault.with_param_no_default()
                • SlashWithDefault.with_param_with_default()
              • SlashWithDefaultParameters
                • SlashWithDefaultParameters.Builder
                  • SlashWithDefaultParameters.Builder.build()
                  • SlashWithDefaultParameters.Builder.param_no_default()
                  • SlashWithDefaultParameters.Builder.param_with_default()
                  • SlashWithDefaultParameters.Builder.star_etc()
                • SlashWithDefaultParameters.PARAM_NO_DEFAULT
                • SlashWithDefaultParameters.PARAM_WITH_DEFAULT
                • SlashWithDefaultParameters.STAR_ETC
                • SlashWithDefaultParameters.TYPE_
                • SlashWithDefaultParameters.builder()
                • SlashWithDefaultParameters.param_no_default
                • SlashWithDefaultParameters.param_with_default
                • SlashWithDefaultParameters.star_etc
                • SlashWithDefaultParameters.with_param_no_default()
                • SlashWithDefaultParameters.with_param_with_default()
                • SlashWithDefaultParameters.with_star_etc()
              • Slice
                • Slice.NAMED
                • Slice.SLICE_
                • Slice.TYPE_
              • SliceExpression
                • SliceExpression.Builder
                  • SliceExpression.Builder.build()
                  • SliceExpression.Builder.start()
                  • SliceExpression.Builder.step()
                  • SliceExpression.Builder.stop()
                • SliceExpression.START
                • SliceExpression.STEP
                • SliceExpression.STOP
                • SliceExpression.TYPE_
                • SliceExpression.builder()
                • SliceExpression.start
                • SliceExpression.step
                • SliceExpression.stop
                • SliceExpression.with_start()
                • SliceExpression.with_step()
                • SliceExpression.with_stop()
              • SliceNamed
              • SliceOrStarredExpression
                • SliceOrStarredExpression.SLICE
                • SliceOrStarredExpression.STARRED
                • SliceOrStarredExpression.TYPE_
              • SliceOrStarredExpressionSlice
              • SliceOrStarredExpressionStarred
              • SliceSlice_
              • Slices
                • Slices.Builder
                  • Slices.Builder.build()
                  • Slices.Builder.head()
                  • Slices.Builder.tail()
                • Slices.HEAD
                • Slices.TAIL
                • Slices.TYPE_
                • Slices.builder()
                • Slices.head
                • Slices.tail
                • Slices.with_head()
                • Slices.with_tail()
              • StarAnnotation
                • StarAnnotation.TYPE_
              • StarAtom
                • StarAtom.NAME
                • StarAtom.STAR_TARGETS_LIST_SEQ
                • StarAtom.STAR_TARGETS_TUPLE_SEQ
                • StarAtom.TARGET_WITH_STAR_ATOM
                • StarAtom.TYPE_
              • StarAtomName
              • StarAtomStarTargetsListSeq
              • StarAtomStarTargetsTupleSeq
              • StarAtomTargetWithStarAtom
              • StarEtc
                • StarEtc.KEYWORDS
                • StarEtc.STAR_COMMA
                • StarEtc.STAR_NO_DEFAULT
                • StarEtc.STAR_NO_DEFAULT_STAR_ANNOTATION
                • StarEtc.TYPE_
              • StarEtcKeywords
              • StarEtcStarComma
              • StarEtcStarNoDefault
              • StarEtcStarNoDefaultStarAnnotation
              • StarExpression
                • StarExpression.SIMPLE
                • StarExpression.STAR
                • StarExpression.TYPE_
              • StarExpressionSimple
              • StarExpressionStar
              • StarNamedExpression
                • StarNamedExpression.SIMPLE
                • StarNamedExpression.STAR
                • StarNamedExpression.TYPE_
              • StarNamedExpressionSimple
              • StarNamedExpressionStar
              • StarNamedExpressions
                • StarNamedExpressions.TYPE_
              • StarPattern
                • StarPattern.CAPTURE
                • StarPattern.TYPE_
                • StarPattern.WILDCARD
              • StarPatternCapture
              • StarPatternWildcard
              • StarTarget
                • StarTarget.STARRED
                • StarTarget.TYPE_
                • StarTarget.UNSTARRED
              • StarTargetStarred
              • StarTargetUnstarred
              • StarTargetsListSeq
                • StarTargetsListSeq.TYPE_
              • StarTargetsTupleSeq
                • StarTargetsTupleSeq.TYPE_
              • StarTypeParameter
                • StarTypeParameter.Builder
                  • StarTypeParameter.Builder.build()
                  • StarTypeParameter.Builder.default()
                  • StarTypeParameter.Builder.name()
                • StarTypeParameter.DEFAULT
                • StarTypeParameter.NAME
                • StarTypeParameter.TYPE_
                • StarTypeParameter.builder()
                • StarTypeParameter.default
                • StarTypeParameter.name
                • StarTypeParameter.with_default()
                • StarTypeParameter.with_name()
              • StarredExpression
                • StarredExpression.TYPE_
              • Statement
                • Statement.ANNOTATED
                • Statement.COMPOUND
                • Statement.SIMPLE
                • Statement.TYPE_
              • StatementAnnotated
              • StatementCompound
              • StatementSimple
              • String
                • String.Builder
                  • String.Builder.build()
                  • String.Builder.prefix()
                  • String.Builder.quote_style()
                  • String.Builder.value()
                • String.PREFIX
                • String.QUOTE_STYLE
                • String.TYPE_
                • String.VALUE
                • String.builder()
                • String.prefix
                • String.quote_style
                • String.value
                • String.with_prefix()
                • String.with_quote_style()
                • String.with_value()
              • StringPrefix
                • StringPrefix.BYTES
                • StringPrefix.RAW
                • StringPrefix.RAW_BYTES
                • StringPrefix.TYPE_
                • StringPrefix.UNICODE
              • SubjectExpression
                • SubjectExpression.SIMPLE
                • SubjectExpression.TUPLE
                • SubjectExpression.TYPE_
              • SubjectExpressionSimple
              • SubjectExpressionTuple
              • Sum
                • Sum.Builder
                  • Sum.Builder.build()
                  • Sum.Builder.lhs()
                  • Sum.Builder.rhs()
                • Sum.LHS
                • Sum.RHS
                • Sum.TYPE_
                • Sum.builder()
                • Sum.lhs
                • Sum.rhs
                • Sum.with_lhs()
                • Sum.with_rhs()
              • SumLhs
                • SumLhs.Builder
                  • SumLhs.Builder.build()
                  • SumLhs.Builder.operand()
                  • SumLhs.Builder.operator()
                • SumLhs.OPERAND
                • SumLhs.OPERATOR
                • SumLhs.TYPE_
                • SumLhs.builder()
                • SumLhs.operand
                • SumLhs.operator
                • SumLhs.with_operand()
                • SumLhs.with_operator()
              • SumOp
                • SumOp.ADD
                • SumOp.SUB
                • SumOp.TYPE_
              • TPrimary
                • TPrimary.ATOM
                • TPrimary.PRIMARY_AND_ARGUMENTS
                • TPrimary.PRIMARY_AND_GENEXP
                • TPrimary.PRIMARY_AND_NAME
                • TPrimary.PRIMARY_AND_SLICES
                • TPrimary.TYPE_
              • TPrimaryAndArguments
                • TPrimaryAndArguments.ARGUMENTS
                • TPrimaryAndArguments.Builder
                  • TPrimaryAndArguments.Builder.arguments()
                  • TPrimaryAndArguments.Builder.build()
                  • TPrimaryAndArguments.Builder.primary()
                • TPrimaryAndArguments.PRIMARY
                • TPrimaryAndArguments.TYPE_
                • TPrimaryAndArguments.arguments
                • TPrimaryAndArguments.builder()
                • TPrimaryAndArguments.primary
                • TPrimaryAndArguments.with_arguments()
                • TPrimaryAndArguments.with_primary()
              • TPrimaryAndGenexp
                • TPrimaryAndGenexp.Builder
                  • TPrimaryAndGenexp.Builder.build()
                  • TPrimaryAndGenexp.Builder.genexp()
                  • TPrimaryAndGenexp.Builder.primary()
                • TPrimaryAndGenexp.GENEXP
                • TPrimaryAndGenexp.PRIMARY
                • TPrimaryAndGenexp.TYPE_
                • TPrimaryAndGenexp.builder()
                • TPrimaryAndGenexp.genexp
                • TPrimaryAndGenexp.primary
                • TPrimaryAndGenexp.with_genexp()
                • TPrimaryAndGenexp.with_primary()
              • TPrimaryAndName
                • TPrimaryAndName.Builder
                  • TPrimaryAndName.Builder.build()
                  • TPrimaryAndName.Builder.name()
                  • TPrimaryAndName.Builder.primary()
                • TPrimaryAndName.NAME
                • TPrimaryAndName.PRIMARY
                • TPrimaryAndName.TYPE_
                • TPrimaryAndName.builder()
                • TPrimaryAndName.name
                • TPrimaryAndName.primary
                • TPrimaryAndName.with_name()
                • TPrimaryAndName.with_primary()
              • TPrimaryAndSlices
                • TPrimaryAndSlices.Builder
                  • TPrimaryAndSlices.Builder.build()
                  • TPrimaryAndSlices.Builder.primary()
                  • TPrimaryAndSlices.Builder.slices()
                • TPrimaryAndSlices.PRIMARY
                • TPrimaryAndSlices.SLICES
                • TPrimaryAndSlices.TYPE_
                • TPrimaryAndSlices.builder()
                • TPrimaryAndSlices.primary
                • TPrimaryAndSlices.slices
                • TPrimaryAndSlices.with_primary()
                • TPrimaryAndSlices.with_slices()
              • TPrimaryAtom
              • TPrimaryPrimaryAndArguments
              • TPrimaryPrimaryAndGenexp
              • TPrimaryPrimaryAndName
              • TPrimaryPrimaryAndSlices
              • TargetWithStarAtom
                • TargetWithStarAtom.ATOM
                • TargetWithStarAtom.PROJECT
                • TargetWithStarAtom.SLICES
                • TargetWithStarAtom.TYPE_
              • TargetWithStarAtomAtom
              • TargetWithStarAtomProject
              • TargetWithStarAtomSlices
              • Term
                • Term.Builder
                  • Term.Builder.build()
                  • Term.Builder.lhs()
                  • Term.Builder.rhs()
                • Term.LHS
                • Term.RHS
                • Term.TYPE_
                • Term.builder()
                • Term.lhs
                • Term.rhs
                • Term.with_lhs()
                • Term.with_rhs()
              • TermLhs
                • TermLhs.Builder
                  • TermLhs.Builder.build()
                  • TermLhs.Builder.operand()
                  • TermLhs.Builder.operator()
                • TermLhs.OPERAND
                • TermLhs.OPERATOR
                • TermLhs.TYPE_
                • TermLhs.builder()
                • TermLhs.operand
                • TermLhs.operator
                • TermLhs.with_operand()
                • TermLhs.with_operator()
              • TermOp
                • TermOp.DIV
                • TermOp.FLOORDIV
                • TermOp.MATMUL
                • TermOp.MOD
                • TermOp.MUL
                • TermOp.TYPE_
              • TryExceptStarStatement
                • TryExceptStarStatement.BODY
                • TryExceptStarStatement.Builder
                  • TryExceptStarStatement.Builder.body()
                  • TryExceptStarStatement.Builder.build()
                  • TryExceptStarStatement.Builder.else_()
                  • TryExceptStarStatement.Builder.excepts()
                  • TryExceptStarStatement.Builder.finally_()
                • TryExceptStarStatement.ELSE
                • TryExceptStarStatement.EXCEPTS
                • TryExceptStarStatement.FINALLY
                • TryExceptStarStatement.TYPE_
                • TryExceptStarStatement.body
                • TryExceptStarStatement.builder()
                • TryExceptStarStatement.else_
                • TryExceptStarStatement.excepts
                • TryExceptStarStatement.finally_
                • TryExceptStarStatement.with_body()
                • TryExceptStarStatement.with_else_()
                • TryExceptStarStatement.with_excepts()
                • TryExceptStarStatement.with_finally_()
              • TryExceptStatement
                • TryExceptStatement.BODY
                • TryExceptStatement.Builder
                  • TryExceptStatement.Builder.body()
                  • TryExceptStatement.Builder.build()
                  • TryExceptStatement.Builder.else_()
                  • TryExceptStatement.Builder.excepts()
                  • TryExceptStatement.Builder.finally_()
                • TryExceptStatement.ELSE
                • TryExceptStatement.EXCEPTS
                • TryExceptStatement.FINALLY
                • TryExceptStatement.TYPE_
                • TryExceptStatement.body
                • TryExceptStatement.builder()
                • TryExceptStatement.else_
                • TryExceptStatement.excepts
                • TryExceptStatement.finally_
                • TryExceptStatement.with_body()
                • TryExceptStatement.with_else_()
                • TryExceptStatement.with_excepts()
                • TryExceptStatement.with_finally_()
              • TryFinallyStatement
                • TryFinallyStatement.BODY
                • TryFinallyStatement.Builder
                  • TryFinallyStatement.Builder.body()
                  • TryFinallyStatement.Builder.build()
                  • TryFinallyStatement.Builder.finally_()
                • TryFinallyStatement.FINALLY
                • TryFinallyStatement.TYPE_
                • TryFinallyStatement.body
                • TryFinallyStatement.builder()
                • TryFinallyStatement.finally_
                • TryFinallyStatement.with_body()
                • TryFinallyStatement.with_finally_()
              • TryStatement
                • TryStatement.EXCEPT
                • TryStatement.EXCEPT_STAR
                • TryStatement.FINALLY
                • TryStatement.TYPE_
              • TryStatementExcept
              • TryStatementExceptStar
              • TryStatementFinally
              • Tuple
                • Tuple.TYPE_
              • TypeAlias
                • TypeAlias.Builder
                  • TypeAlias.Builder.build()
                  • TypeAlias.Builder.expression()
                  • TypeAlias.Builder.name()
                  • TypeAlias.Builder.type_params()
                • TypeAlias.EXPRESSION
                • TypeAlias.NAME
                • TypeAlias.TYPE_
                • TypeAlias.TYPE_PARAMS
                • TypeAlias.builder()
                • TypeAlias.expression
                • TypeAlias.name
                • TypeAlias.type_params
                • TypeAlias.with_expression()
                • TypeAlias.with_name()
                • TypeAlias.with_type_params()
              • TypeComment
                • TypeComment.TYPE_
              • TypeExpression
                • TypeExpression.DOUBLE_STARRED_EXPRESSION
                • TypeExpression.EXPRESSION
                • TypeExpression.STARRED_EXPRESSION
                • TypeExpression.TYPE_
              • TypeExpressionDoubleStarredExpression
              • TypeExpressionExpression
              • TypeExpressionStarredExpression
              • TypeParameter
                • TypeParameter.DOUBLE_STAR
                • TypeParameter.SIMPLE
                • TypeParameter.STAR
                • TypeParameter.TYPE_
              • TypeParameterDoubleStar
              • TypeParameterSimple
              • TypeParameterStar
              • TypedAssignment
                • TypedAssignment.Builder
                  • TypedAssignment.Builder.build()
                  • TypedAssignment.Builder.lhs()
                  • TypedAssignment.Builder.rhs()
                  • TypedAssignment.Builder.type()
                • TypedAssignment.LHS
                • TypedAssignment.RHS
                • TypedAssignment.TYPE
                • TypedAssignment.TYPE_
                • TypedAssignment.builder()
                • TypedAssignment.lhs
                • TypedAssignment.rhs
                • TypedAssignment.type
                • TypedAssignment.with_lhs()
                • TypedAssignment.with_rhs()
                • TypedAssignment.with_type()
              • UntypedAssignment
                • UntypedAssignment.Builder
                  • UntypedAssignment.Builder.build()
                  • UntypedAssignment.Builder.rhs()
                  • UntypedAssignment.Builder.targets()
                  • UntypedAssignment.Builder.type_comment()
                • UntypedAssignment.RHS
                • UntypedAssignment.TARGETS
                • UntypedAssignment.TYPE_
                • UntypedAssignment.TYPE_COMMENT
                • UntypedAssignment.builder()
                • UntypedAssignment.rhs
                • UntypedAssignment.targets
                • UntypedAssignment.type_comment
                • UntypedAssignment.with_rhs()
                • UntypedAssignment.with_targets()
                • UntypedAssignment.with_type_comment()
              • ValuePattern
                • ValuePattern.TYPE_
              • WhileStatement
                • WhileStatement.BODY
                • WhileStatement.Builder
                  • WhileStatement.Builder.body()
                  • WhileStatement.Builder.build()
                  • WhileStatement.Builder.condition()
                  • WhileStatement.Builder.else_()
                • WhileStatement.CONDITION
                • WhileStatement.ELSE
                • WhileStatement.TYPE_
                • WhileStatement.body
                • WhileStatement.builder()
                • WhileStatement.condition
                • WhileStatement.else_
                • WhileStatement.with_body()
                • WhileStatement.with_condition()
                • WhileStatement.with_else_()
              • WithItem
                • WithItem.AS
                • WithItem.Builder
                  • WithItem.Builder.as_()
                  • WithItem.Builder.build()
                  • WithItem.Builder.expression()
                • WithItem.EXPRESSION
                • WithItem.TYPE_
                • WithItem.as_
                • WithItem.builder()
                • WithItem.expression
                • WithItem.with_as_()
                • WithItem.with_expression()
              • WithStatement
                • WithStatement.ASYNC
                • WithStatement.BODY
                • WithStatement.Builder
                  • WithStatement.Builder.async_()
                  • WithStatement.Builder.body()
                  • WithStatement.Builder.build()
                  • WithStatement.Builder.items()
                  • WithStatement.Builder.type_comment()
                • WithStatement.ITEMS
                • WithStatement.TYPE_
                • WithStatement.TYPE_COMMENT
                • WithStatement.async_
                • WithStatement.body
                • WithStatement.builder()
                • WithStatement.items
                • WithStatement.type_comment
                • WithStatement.with_async_()
                • WithStatement.with_body()
                • WithStatement.with_items()
                • WithStatement.with_type_comment()
              • YieldExpression
                • YieldExpression.FROM
                • YieldExpression.SIMPLE
                • YieldExpression.TYPE_
              • YieldExpressionFrom
              • YieldExpressionSimple
              • YieldStatement
                • YieldStatement.TYPE_
            • hydra.python.testing module
              • build_python_test_module()
              • format_python_test_name()
              • generate_python_test_case()
              • generate_python_test_file()
              • generate_python_test_group_hierarchy()
              • generate_test_file_with_python_codec()
            • hydra.python.utils module
              • annotated_expression()
              • annotated_statement()
              • assignment()
              • assignment_statement()
              • cast_to()
              • comment_statement()
              • decode_py_comparison_to_py_await_primary()
              • decode_py_conjunction_to_py_primary()
              • decode_py_expression_to_py_primary()
              • decode_py_inversion_to_py_primary()
              • decode_py_power_to_py_primary()
              • dotted_assignment_statement()
              • double_quoted_string()
              • find_namespaces()
              • function_call()
              • get_item_params()
              • indented_block()
              • name_and_params()
              • newtype_statement()
              • or_expression()
              • primary_and_params()
              • primary_with_expression_slices()
              • primary_with_rhs()
              • primary_with_slices()
              • project_from_expression()
              • py_assignment_to_py_statement()
              • py_atom_to_py_expression()
              • py_bitwise_or_to_py_conjunction()
              • py_bitwise_or_to_py_expression()
              • py_class_definition_to_py_statement()
              • py_closed_pattern_to_py_patterns()
              • py_conjunction_to_py_expression()
              • py_expression_to_bitwise_or()
              • py_expression_to_disjunction()
              • py_expression_to_py_annotated_rhs()
              • py_expression_to_py_primary()
              • py_expression_to_py_simple_statement()
              • py_expression_to_py_slice()
              • py_expression_to_py_star_named_expression()
              • py_expression_to_py_statement()
              • py_expressions_to_py_args()
              • py_list()
              • py_name_to_py_expression()
              • py_name_to_py_named_expression()
              • py_name_to_py_primary()
              • py_name_to_py_star_target()
              • py_name_to_py_type_parameter()
              • py_primary_to_py_bitwise_or()
              • py_primary_to_py_bitwise_xor()
              • py_primary_to_py_conjunction()
              • py_primary_to_py_expression()
              • py_primary_to_py_slice()
              • py_simple_statement_to_py_statement()
              • raise_assertion_error()
              • raise_type_error()
              • return_single()
              • self_only_params()
              • self_other_params()
              • single_quoted_string()
              • string_to_py_expression()
              • triple_quoted_string()
              • type_alias_statement()
              • type_alias_statement310()
              • union_type_class_statements310()
              • unit_variant_methods()
hydra-python
  • hydra
  • View page source

hydra

  • hydra namespace
    • Subpackages
      • hydra.python namespace
        • Submodules
Previous Next

© Copyright 2026, Hydra.

Built with Sphinx using a theme provided by Read the Docs.