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()