hydra.python.syntax module

A Python syntax model, tracking the Python 3.14 PEG grammar: https://docs.python.org/3.14/reference/grammar.html.

class hydra.python.syntax.AnnotatedRhs

Bases: object

AnnotatedRhsYield | AnnotatedRhsStar

STAR = Name(value='star')

TYPE_ = Name(value='hydra.python.syntax.AnnotatedRhs')

YIELD = Name(value='yield')

class hydra.python.syntax.AnnotatedRhsStar(value: T)

Bases: Node[Sequence[StarExpression]]

class hydra.python.syntax.AnnotatedRhsYield(value: T)

Bases: Node[YieldExpression]

class hydra.python.syntax.AnnotatedStatement(comment: 'str', statement: 'Statement')

Bases: object

class Builder(_comment: 'str' = None, _statement: 'Statement' = None)

Bases: object

build()

comment(comment)

statement(statement)

COMMENT = Name(value='comment')

STATEMENT = Name(value='statement')

TYPE_ = Name(value='hydra.python.syntax.AnnotatedStatement')

static builder()

comment: str

statement: Statement

with_comment(comment)

with_statement(statement)

class hydra.python.syntax.Annotation(value: T)

Bases: Node[Expression]

TYPE_ = Name(value='hydra.python.syntax.Annotation')

class hydra.python.syntax.Args(positional: 'Sequence[PosArg]', kwarg_or_starred: 'Sequence[KwargOrStarred]', kwarg_or_double_starred: 'Sequence[KwargOrDoubleStarred]')

Bases: object

class Builder(_positional: 'Sequence[PosArg]' = None, _kwarg_or_starred: 'Sequence[KwargOrStarred]' = None, _kwarg_or_double_starred: 'Sequence[KwargOrDoubleStarred]' = None)

Bases: object

build()

kwarg_or_double_starred(kwarg_or_double_starred)

kwarg_or_starred(kwarg_or_starred)

positional(positional)

KWARG_OR_DOUBLE_STARRED = Name(value='kwargOrDoubleStarred')

KWARG_OR_STARRED = Name(value='kwargOrStarred')

POSITIONAL = Name(value='positional')

TYPE_ = Name(value='hydra.python.syntax.Args')

static builder()

kwarg_or_double_starred: Sequence[KwargOrDoubleStarred]

kwarg_or_starred: Sequence[KwargOrStarred]

positional: Sequence[PosArg]

with_kwarg_or_double_starred(kwarg_or_double_starred)

with_kwarg_or_starred(kwarg_or_starred)

with_positional(positional)

class hydra.python.syntax.AsPattern(pattern: 'OrPattern', as_: 'PatternCaptureTarget')

Bases: object

AS = Name(value='as')

class Builder(_pattern: 'OrPattern' = None, _as_: 'PatternCaptureTarget' = None)

Bases: object

as_(as_)

build()

pattern(pattern)

PATTERN = Name(value='pattern')

TYPE_ = Name(value='hydra.python.syntax.AsPattern')

as_: PatternCaptureTarget

static builder()

pattern: OrPattern

with_as_(as_)

with_pattern(pattern)

class hydra.python.syntax.AssertStatement(expression1: 'Expression', expression2: 'Optional[Expression]')

Bases: object

class Builder(_expression1: 'Expression' = None, _expression2: 'Optional[Expression]' = None)

Bases: object

build()

expression1(expression1)

expression2(expression2)

EXPRESSION1 = Name(value='expression1')

EXPRESSION2 = Name(value='expression2')

TYPE_ = Name(value='hydra.python.syntax.AssertStatement')

static builder()

expression1: Expression

expression2: object

with_expression1(expression1)

with_expression2(expression2)

class hydra.python.syntax.Assignment

Bases: object

AssignmentTyped | AssignmentUntyped | AssignmentAug

AUG = Name(value='aug')

TYPED = Name(value='typed')

TYPE_ = Name(value='hydra.python.syntax.Assignment')

UNTYPED = Name(value='untyped')

class hydra.python.syntax.AssignmentAug(value: T)

Bases: Node[AugAssignment]

class hydra.python.syntax.AssignmentExpression(name: 'Name', expression: 'Expression')

Bases: object

class Builder(_name: 'Name' = None, _expression: 'Expression' = None)

Bases: object

build()

expression(expression)

name(name)

EXPRESSION = Name(value='expression')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.AssignmentExpression')

static builder()

expression: Expression

name: Name

with_expression(expression)

with_name(name)

class hydra.python.syntax.AssignmentTyped(value: T)

Bases: Node[TypedAssignment]

class hydra.python.syntax.AssignmentUntyped(value: T)

Bases: Node[UntypedAssignment]

class hydra.python.syntax.Atom

Bases: object

AtomName | AtomTrue | AtomFalse | AtomNone | AtomString | AtomNumber | AtomTuple | AtomGroup | AtomGenexp | AtomList | AtomListcomp | AtomDict | AtomSet | AtomDictcomp | AtomSetcomp | AtomEllipsis

DICT = Name(value='dict')

DICTCOMP = Name(value='dictcomp')

ELLIPSIS = Name(value='ellipsis')

FALSE = Name(value='false')

GENEXP = Name(value='genexp')

GROUP = Name(value='group')

LIST = Name(value='list')

LISTCOMP = Name(value='listcomp')

NAME = Name(value='name')

NONE = Name(value='none')

NUMBER = Name(value='number')

SET = Name(value='set')

SETCOMP = Name(value='setcomp')

STRING = Name(value='string')

TRUE = Name(value='true')

TUPLE = Name(value='tuple')

TYPE_ = Name(value='hydra.python.syntax.Atom')

class hydra.python.syntax.AtomDict(value: T)

Bases: Node[Dict]

class hydra.python.syntax.AtomDictcomp(value: T)

Bases: Node[Dictcomp]

class hydra.python.syntax.AtomEllipsis

Bases: object

class hydra.python.syntax.AtomFalse

Bases: object

class hydra.python.syntax.AtomGenexp(value: T)

Bases: Node[Genexp]

class hydra.python.syntax.AtomGroup(value: T)

Bases: Node[Group]

class hydra.python.syntax.AtomList(value: T)

Bases: Node[List]

class hydra.python.syntax.AtomListcomp(value: T)

Bases: Node[Listcomp]

class hydra.python.syntax.AtomName(value: T)

Bases: Node[Name]

class hydra.python.syntax.AtomNone

Bases: object

class hydra.python.syntax.AtomNumber(value: T)

Bases: Node[Number]

class hydra.python.syntax.AtomSet(value: T)

Bases: Node[Set]

class hydra.python.syntax.AtomSetcomp(value: T)

Bases: Node[Setcomp]

class hydra.python.syntax.AtomString(value: T)

Bases: Node[String]

class hydra.python.syntax.AtomTrue

Bases: object

class hydra.python.syntax.AtomTuple(value: T)

Bases: Node[Tuple]

class hydra.python.syntax.Attribute(value: T)

Bases: Node[Sequence[Name]]

TYPE_ = Name(value='hydra.python.syntax.Attribute')

class hydra.python.syntax.AugAssign(*values)

Bases: Enum

AMPERSAND_EQUAL = Name(value='ampersandEqual')

AT_EQUAL = Name(value='atEqual')

BAR_EQUAL = Name(value='barEqual')

CARET_EQUAL = Name(value='caretEqual')

DOUBLE_SLASH_EQUAL = Name(value='doubleSlashEqual')

LEFT_SHIFT_EQUAL = Name(value='leftShiftEqual')

MINUS_EQUAL = Name(value='minusEqual')

PERCENT_EQUAL = Name(value='percentEqual')

PLUS_EQUAL = Name(value='plusEqual')

RIGHT_SHIFT_EQUAL = Name(value='rightShiftEqual')

SLASH_EQUAL = Name(value='slashEqual')

STAR_STAR_EQUAL = Name(value='starStarEqual')

TIMES_EQUAL = Name(value='timesEqual')

TYPE_ = Name(value='hydra.python.syntax.AugAssign')

class hydra.python.syntax.AugAssignment(lhs: 'SingleTarget', augassign: 'AugAssign', rhs: 'AnnotatedRhs')

Bases: object

AUGASSIGN = Name(value='augassign')

class Builder(_lhs: 'SingleTarget' = None, _augassign: 'AugAssign' = None, _rhs: 'AnnotatedRhs' = None)

Bases: object

augassign(augassign)

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.AugAssignment')

augassign: AugAssign

static builder()

lhs: SingleTarget

rhs: AnnotatedRhs

with_augassign(augassign)

with_lhs(lhs)

with_rhs(rhs)

class hydra.python.syntax.AwaitPrimary(await_: 'bool', primary: 'Primary')

Bases: object

AWAIT = Name(value='await')

class Builder(_await_: 'bool' = None, _primary: 'Primary' = None)

Bases: object

await_(await_)

build()

primary(primary)

PRIMARY = Name(value='primary')

TYPE_ = Name(value='hydra.python.syntax.AwaitPrimary')

await_: bool

static builder()

primary: Primary

with_await_(await_)

with_primary(primary)

class hydra.python.syntax.BitwiseAnd(lhs: 'Optional[BitwiseAnd]', rhs: 'ShiftExpression')

Bases: object

class Builder(_lhs: 'Optional[BitwiseAnd]' = None, _rhs: 'ShiftExpression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.BitwiseAnd')

static builder()

lhs: object

rhs: ShiftExpression

with_lhs(lhs)

with_rhs(rhs)

class hydra.python.syntax.BitwiseOr(lhs: 'Optional[BitwiseOr]', rhs: 'BitwiseXor')

Bases: object

class Builder(_lhs: 'Optional[BitwiseOr]' = None, _rhs: 'BitwiseXor' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.BitwiseOr')

static builder()

lhs: object

rhs: BitwiseXor

with_lhs(lhs)

with_rhs(rhs)

class hydra.python.syntax.BitwiseXor(lhs: 'Optional[BitwiseXor]', rhs: 'BitwiseAnd')

Bases: object

class Builder(_lhs: 'Optional[BitwiseXor]' = None, _rhs: 'BitwiseAnd' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.BitwiseXor')

static builder()

lhs: object

rhs: BitwiseAnd

with_lhs(lhs)

with_rhs(rhs)

class hydra.python.syntax.Block

Bases: object

BlockIndented | BlockSimple

INDENTED = Name(value='indented')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.python.syntax.Block')

class hydra.python.syntax.BlockIndented(value: T)

Bases: Node[Sequence[Sequence[Statement]]]

class hydra.python.syntax.BlockSimple(value: T)

Bases: Node[Sequence[SimpleStatement]]

class hydra.python.syntax.CapturePattern(value: T)

Bases: Node[PatternCaptureTarget]

TYPE_ = Name(value='hydra.python.syntax.CapturePattern')

class hydra.python.syntax.CaseBlock(patterns: 'Patterns', guard: 'Optional[Guard]', body: 'Block')

Bases: object

BODY = Name(value='body')

class Builder(_patterns: 'Patterns' = None, _guard: 'Optional[Guard]' = None, _body: 'Block' = None)

Bases: object

body(body)

build()

guard(guard)

patterns(patterns)

GUARD = Name(value='guard')

PATTERNS = Name(value='patterns')

TYPE_ = Name(value='hydra.python.syntax.CaseBlock')

body: Block

static builder()

guard: object

patterns: Patterns

with_body(body)

with_guard(guard)

with_patterns(patterns)

class hydra.python.syntax.ClassDefinition(decorators: 'Optional[Decorators]', name: 'Name', type_params: 'Sequence[TypeParameter]', arguments: 'Optional[Args]', body: 'Block')

Bases: object

ARGUMENTS = Name(value='arguments')

BODY = Name(value='body')

class Builder(_decorators: 'Optional[Decorators]' = None, _name: 'Name' = None, _type_params: 'Sequence[TypeParameter]' = None, _arguments: 'Optional[Args]' = None, _body: 'Block' = None)

Bases: object

arguments(arguments)

body(body)

build()

decorators(decorators)

name(name)

type_params(type_params)

DECORATORS = Name(value='decorators')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.ClassDefinition')

TYPE_PARAMS = Name(value='typeParams')

arguments: object

body: Block

static builder()

decorators: object

name: Name

type_params: Sequence[TypeParameter]

with_arguments(arguments)

with_body(body)

with_decorators(decorators)

with_name(name)

with_type_params(type_params)

class hydra.python.syntax.ClassPattern(name_or_attribute: 'NameOrAttribute', positional_patterns: 'Optional[PositionalPatterns]', keyword_patterns: 'Optional[KeywordPatterns]')

Bases: object

class Builder(_name_or_attribute: 'NameOrAttribute' = None, _positional_patterns: 'Optional[PositionalPatterns]' = None, _keyword_patterns: 'Optional[KeywordPatterns]' = None)

Bases: object

build()

keyword_patterns(keyword_patterns)

name_or_attribute(name_or_attribute)

positional_patterns(positional_patterns)

KEYWORD_PATTERNS = Name(value='keywordPatterns')

NAME_OR_ATTRIBUTE = Name(value='nameOrAttribute')

POSITIONAL_PATTERNS = Name(value='positionalPatterns')

TYPE_ = Name(value='hydra.python.syntax.ClassPattern')

static builder()

keyword_patterns: object

name_or_attribute: NameOrAttribute

positional_patterns: object

with_keyword_patterns(keyword_patterns)

with_name_or_attribute(name_or_attribute)

with_positional_patterns(positional_patterns)

class hydra.python.syntax.ClosedPattern

Bases: object

ClosedPatternLiteral | ClosedPatternCapture | ClosedPatternWildcard | ClosedPatternValue | ClosedPatternGroup | ClosedPatternSequence | ClosedPatternMapping | ClosedPatternClass

CAPTURE = Name(value='capture')

CLASS = Name(value='class')

GROUP = Name(value='group')

LITERAL = Name(value='literal')

MAPPING = Name(value='mapping')

SEQUENCE = Name(value='sequence')

TYPE_ = Name(value='hydra.python.syntax.ClosedPattern')

VALUE = Name(value='value')

WILDCARD = Name(value='wildcard')

class hydra.python.syntax.ClosedPatternCapture(value: T)

Bases: Node[CapturePattern]

class hydra.python.syntax.ClosedPatternClass(value: T)

Bases: Node[ClassPattern]

class hydra.python.syntax.ClosedPatternGroup(value: T)

Bases: Node[GroupPattern]

class hydra.python.syntax.ClosedPatternLiteral(value: T)

Bases: Node[LiteralExpression]

class hydra.python.syntax.ClosedPatternMapping(value: T)

Bases: Node[MappingPattern]

class hydra.python.syntax.ClosedPatternSequence(value: T)

Bases: Node[SequencePattern]

class hydra.python.syntax.ClosedPatternValue(value: T)

Bases: Node[ValuePattern]

class hydra.python.syntax.ClosedPatternWildcard

Bases: object

class hydra.python.syntax.CommaStarEtc(param_maybe_default: 'Sequence[ParamMaybeDefault]', keywords: 'Optional[Keywords]')

Bases: object

class Builder(_param_maybe_default: 'Sequence[ParamMaybeDefault]' = None, _keywords: 'Optional[Keywords]' = None)

Bases: object

build()

keywords(keywords)

param_maybe_default(param_maybe_default)

KEYWORDS = Name(value='keywords')

PARAM_MAYBE_DEFAULT = Name(value='paramMaybeDefault')

TYPE_ = Name(value='hydra.python.syntax.CommaStarEtc')

static builder()

keywords: object

param_maybe_default: Sequence[ParamMaybeDefault]

with_keywords(keywords)

with_param_maybe_default(param_maybe_default)

class hydra.python.syntax.CompareOp(*values)

Bases: Enum

EQ = Name(value='eq')

GT = Name(value='gt')

GTE = Name(value='gte')

IN = Name(value='in')

IS = Name(value='is')

ISNOT = Name(value='isnot')

LT = Name(value='lt')

LTE = Name(value='lte')

NOTEQ = Name(value='noteq')

NOTIN = Name(value='notin')

TYPE_ = Name(value='hydra.python.syntax.CompareOp')

class hydra.python.syntax.CompareOpBitwiseOrPair(operator: 'CompareOp', rhs: 'BitwiseOr')

Bases: object

class Builder(_operator: 'CompareOp' = None, _rhs: 'BitwiseOr' = None)

Bases: object

build()

operator(operator)

rhs(rhs)

OPERATOR = Name(value='operator')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.CompareOpBitwiseOrPair')

static builder()

operator: CompareOp

rhs: BitwiseOr

with_operator(operator)

with_rhs(rhs)

class hydra.python.syntax.Comparison(lhs: 'BitwiseOr', rhs: 'Sequence[CompareOpBitwiseOrPair]')

Bases: object

class Builder(_lhs: 'BitwiseOr' = None, _rhs: 'Sequence[CompareOpBitwiseOrPair]' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.Comparison')

static builder()

lhs: BitwiseOr

rhs: Sequence[CompareOpBitwiseOrPair]

with_lhs(lhs)

with_rhs(rhs)

class hydra.python.syntax.ComplexNumber(real: 'SignedRealNumber', plus_or_minus: 'PlusOrMinus', imaginary: 'ImaginaryNumber')

Bases: object

class Builder(_real: 'SignedRealNumber' = None, _plus_or_minus: 'PlusOrMinus' = None, _imaginary: 'ImaginaryNumber' = None)

Bases: object

build()

imaginary(imaginary)

plus_or_minus(plus_or_minus)

real(real)

IMAGINARY = Name(value='imaginary')

PLUS_OR_MINUS = Name(value='plusOrMinus')

REAL = Name(value='real')

TYPE_ = Name(value='hydra.python.syntax.ComplexNumber')

static builder()

imaginary: ImaginaryNumber

plus_or_minus: PlusOrMinus

real: SignedRealNumber

with_imaginary(imaginary)

with_plus_or_minus(plus_or_minus)

with_real(real)

class hydra.python.syntax.CompoundStatement

Bases: object

CompoundStatementFunction | CompoundStatementIf | CompoundStatementClassDef | CompoundStatementWith | CompoundStatementFor | CompoundStatementTry | CompoundStatementWhile | CompoundStatementMatch

CLASS_DEF = Name(value='classDef')

FOR = Name(value='for')

FUNCTION = Name(value='function')

IF = Name(value='if')

MATCH = Name(value='match')

TRY = Name(value='try')

TYPE_ = Name(value='hydra.python.syntax.CompoundStatement')

WHILE = Name(value='while')

WITH = Name(value='with')

class hydra.python.syntax.CompoundStatementClassDef(value: T)

Bases: Node[ClassDefinition]

class hydra.python.syntax.CompoundStatementFor(value: T)

Bases: Node[ForStatement]

class hydra.python.syntax.CompoundStatementFunction(value: T)

Bases: Node[FunctionDefinition]

class hydra.python.syntax.CompoundStatementIf(value: T)

Bases: Node[IfStatement]

class hydra.python.syntax.CompoundStatementMatch(value: T)

Bases: Node[MatchStatement]

class hydra.python.syntax.CompoundStatementTry(value: T)

Bases: Node[TryStatement]

class hydra.python.syntax.CompoundStatementWhile(value: T)

Bases: Node[WhileStatement]

class hydra.python.syntax.CompoundStatementWith(value: T)

Bases: Node[WithStatement]

class hydra.python.syntax.Conditional(body: 'Disjunction', if_: 'Disjunction', else_: 'Expression')

Bases: object

BODY = Name(value='body')

class Builder(_body: 'Disjunction' = None, _if_: 'Disjunction' = None, _else_: 'Expression' = None)

Bases: object

body(body)

build()

else_(else_)

if_(if_)

ELSE = Name(value='else')

IF = Name(value='if')

TYPE_ = Name(value='hydra.python.syntax.Conditional')

body: Disjunction

static builder()

else_: Expression

if_: Disjunction

with_body(body)

with_else_(else_)

with_if_(if_)

class hydra.python.syntax.Conjunction(value: T)

Bases: Node[Sequence[Inversion]]

TYPE_ = Name(value='hydra.python.syntax.Conjunction')

class hydra.python.syntax.Decorators(value: T)

Bases: Node[Sequence[NamedExpression]]

TYPE_ = Name(value='hydra.python.syntax.Decorators')

class hydra.python.syntax.Default(value: T)

Bases: Node[Expression]

TYPE_ = Name(value='hydra.python.syntax.Default')

class hydra.python.syntax.DelStatement(value: T)

Bases: Node[DelTargets]

TYPE_ = Name(value='hydra.python.syntax.DelStatement')

class hydra.python.syntax.DelTAtom

Bases: object

DelTAtomName | DelTAtomTarget | DelTAtomTargets

NAME = Name(value='name')

TARGET = Name(value='target')

TARGETS = Name(value='targets')

TYPE_ = Name(value='hydra.python.syntax.DelTAtom')

class hydra.python.syntax.DelTAtomName(value: T)

Bases: Node[Name]

class hydra.python.syntax.DelTAtomTarget(value: T)

Bases: Node[DelTarget]

class hydra.python.syntax.DelTAtomTargets(value: T)

Bases: Node[DelTargets]

class hydra.python.syntax.DelTarget

Bases: object

DelTargetPrimaryAndName | DelTargetPrimaryAndSlices | DelTargetDelTAtom

DEL_T_ATOM = Name(value='delTAtom')

PRIMARY_AND_NAME = Name(value='primaryAndName')

PRIMARY_AND_SLICES = Name(value='primaryAndSlices')

TYPE_ = Name(value='hydra.python.syntax.DelTarget')

class hydra.python.syntax.DelTargetDelTAtom(value: T)

Bases: Node[DelTAtom]

class hydra.python.syntax.DelTargetPrimaryAndName(value: T)

Bases: Node[TPrimaryAndName]

class hydra.python.syntax.DelTargetPrimaryAndSlices(value: T)

Bases: Node[TPrimaryAndSlices]

class hydra.python.syntax.DelTargets(value: T)

Bases: Node[Sequence[DelTarget]]

TYPE_ = Name(value='hydra.python.syntax.DelTargets')

class hydra.python.syntax.Dict(value: T)

Bases: Node[Sequence[DoubleStarredKvpair]]

TYPE_ = Name(value='hydra.python.syntax.Dict')

class hydra.python.syntax.Dictcomp(kvpair: 'Kvpair', for_if_clauses: 'ForIfClauses')

Bases: object

class Builder(_kvpair: 'Kvpair' = None, _for_if_clauses: 'ForIfClauses' = None)

Bases: object

build()

for_if_clauses(for_if_clauses)

kvpair(kvpair)

FOR_IF_CLAUSES = Name(value='forIfClauses')

KVPAIR = Name(value='kvpair')

TYPE_ = Name(value='hydra.python.syntax.Dictcomp')

static builder()

for_if_clauses: ForIfClauses

kvpair: Kvpair

with_for_if_clauses(for_if_clauses)

with_kvpair(kvpair)

class hydra.python.syntax.Disjunction(value: T)

Bases: Node[Sequence[Conjunction]]

TYPE_ = Name(value='hydra.python.syntax.Disjunction')

class hydra.python.syntax.DottedAsName(name: 'DottedName', as_: 'Optional[Name]')

Bases: object

AS = Name(value='as')

class Builder(_name: 'DottedName' = None, _as_: 'Optional[Name]' = None)

Bases: object

as_(as_)

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.DottedAsName')

as_: object

static builder()

name: DottedName

with_as_(as_)

with_name(name)

class hydra.python.syntax.DottedName(value: T)

Bases: Node[Sequence[Name]]

TYPE_ = Name(value='hydra.python.syntax.DottedName')

class hydra.python.syntax.DoubleStarPattern(value: T)

Bases: Node[PatternCaptureTarget]

TYPE_ = Name(value='hydra.python.syntax.DoubleStarPattern')

class hydra.python.syntax.DoubleStarTypeParameter(name: 'Name', default: 'Optional[Expression]')

Bases: object

class Builder(_name: 'Name' = None, _default: 'Optional[Expression]' = None)

Bases: object

build()

default(default)

name(name)

DEFAULT = Name(value='default')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.DoubleStarTypeParameter')

static builder()

default: object

name: Name

with_default(default)

with_name(name)

class hydra.python.syntax.DoubleStarredKvpair

Bases: object

DoubleStarredKvpairStarred | DoubleStarredKvpairPair

PAIR = Name(value='pair')

STARRED = Name(value='starred')

TYPE_ = Name(value='hydra.python.syntax.DoubleStarredKvpair')

class hydra.python.syntax.DoubleStarredKvpairPair(value: T)

Bases: Node[Kvpair]

class hydra.python.syntax.DoubleStarredKvpairStarred(value: T)

Bases: Node[BitwiseOr]

class hydra.python.syntax.Eval(value: T)

Bases: Node[Sequence[Expression]]

TYPE_ = Name(value='hydra.python.syntax.Eval')

class hydra.python.syntax.ExceptBlock(expression: 'Optional[ExceptExpression]', body: 'Block')

Bases: object

BODY = Name(value='body')

class Builder(_expression: 'Optional[ExceptExpression]' = None, _body: 'Block' = None)

Bases: object

body(body)

build()

expression(expression)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.python.syntax.ExceptBlock')

body: Block

static builder()

expression: object

with_body(body)

with_expression(expression)

class hydra.python.syntax.ExceptExpression(expression: 'Expression', as_: 'Optional[Name]')

Bases: object

AS = Name(value='as')

class Builder(_expression: 'Expression' = None, _as_: 'Optional[Name]' = None)

Bases: object

as_(as_)

build()

expression(expression)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.python.syntax.ExceptExpression')

as_: object

static builder()

expression: Expression

with_as_(as_)

with_expression(expression)

class hydra.python.syntax.ExceptStarBlock(expression: 'Expression', as_: 'Optional[Name]', body: 'Block')

Bases: object

AS = Name(value='as')

BODY = Name(value='body')

class Builder(_expression: 'Expression' = None, _as_: 'Optional[Name]' = None, _body: 'Block' = None)

Bases: object

as_(as_)

body(body)

build()

expression(expression)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.python.syntax.ExceptStarBlock')

as_: object

body: Block

static builder()

expression: Expression

with_as_(as_)

with_body(body)

with_expression(expression)

class hydra.python.syntax.Expression

Bases: object

ExpressionConditional | ExpressionSimple | ExpressionLambda

CONDITIONAL = Name(value='conditional')

LAMBDA = Name(value='lambda')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.python.syntax.Expression')

class hydra.python.syntax.ExpressionConditional(value: T)

Bases: Node[Conditional]

class hydra.python.syntax.ExpressionLambda(value: T)

Bases: Node[Lambda]

class hydra.python.syntax.ExpressionSimple(value: T)

Bases: Node[Disjunction]

class hydra.python.syntax.Factor

Bases: object

FactorPositive | FactorNegative | FactorComplement | FactorSimple

COMPLEMENT = Name(value='complement')

NEGATIVE = Name(value='negative')

POSITIVE = Name(value='positive')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.python.syntax.Factor')

class hydra.python.syntax.FactorComplement(value: T)

Bases: Node[Factor]

class hydra.python.syntax.FactorNegative(value: T)

Bases: Node[Factor]

class hydra.python.syntax.FactorPositive(value: T)

Bases: Node[Factor]

class hydra.python.syntax.FactorSimple(value: T)

Bases: Node[Power]

class hydra.python.syntax.File(value: T)

Bases: Node[Sequence[Statement]]

TYPE_ = Name(value='hydra.python.syntax.File')

class hydra.python.syntax.ForIfClause(async_: 'bool', targets: 'Sequence[StarTarget]', in_: 'Disjunction', ifs: 'Sequence[Disjunction]')

Bases: object

ASYNC = Name(value='async')

class Builder(_async_: 'bool' = None, _targets: 'Sequence[StarTarget]' = None, _in_: 'Disjunction' = None, _ifs: 'Sequence[Disjunction]' = None)

Bases: object

async_(async_)

build()

ifs(ifs)

in_(in_)

targets(targets)

IFS = Name(value='ifs')

IN = Name(value='in')

TARGETS = Name(value='targets')

TYPE_ = Name(value='hydra.python.syntax.ForIfClause')

async_: bool

static builder()

ifs: Sequence[Disjunction]

in_: Disjunction

targets: Sequence[StarTarget]

with_async_(async_)

with_ifs(ifs)

with_in_(in_)

with_targets(targets)

class hydra.python.syntax.ForIfClauses(value: T)

Bases: Node[Sequence[ForIfClause]]

TYPE_ = Name(value='hydra.python.syntax.ForIfClauses')

class hydra.python.syntax.ForStatement(async_: 'bool', targets: 'Sequence[StarTarget]', expressions: 'Sequence[StarExpression]', type_comment: 'Optional[TypeComment]', body: 'Block', else_: 'Optional[Block]')

Bases: object

ASYNC = Name(value='async')

BODY = Name(value='body')

class Builder(_async_: 'bool' = None, _targets: 'Sequence[StarTarget]' = None, _expressions: 'Sequence[StarExpression]' = None, _type_comment: 'Optional[TypeComment]' = None, _body: 'Block' = None, _else_: 'Optional[Block]' = None)

Bases: object

async_(async_)

body(body)

build()

else_(else_)

expressions(expressions)

targets(targets)

type_comment(type_comment)

ELSE = Name(value='else')

EXPRESSIONS = Name(value='expressions')

TARGETS = Name(value='targets')

TYPE_ = Name(value='hydra.python.syntax.ForStatement')

TYPE_COMMENT = Name(value='typeComment')

async_: bool

body: Block

static builder()

else_: object

expressions: Sequence[StarExpression]

targets: Sequence[StarTarget]

type_comment: object

with_async_(async_)

with_body(body)

with_else_(else_)

with_expressions(expressions)

with_targets(targets)

with_type_comment(type_comment)

class hydra.python.syntax.FuncTypeComment(value: T)

Bases: Node[TypeComment]

TYPE_ = Name(value='hydra.python.syntax.FuncTypeComment')

class hydra.python.syntax.FunctionDefRaw(async_: 'bool', name: 'Name', type_params: 'Sequence[TypeParameter]', params: 'Optional[Parameters]', return_type: 'Optional[Expression]', func_type_comment: 'Optional[FuncTypeComment]', block: 'Block')

Bases: object

ASYNC = Name(value='async')

BLOCK = Name(value='block')

class Builder(_async_: 'bool' = None, _name: 'Name' = None, _type_params: 'Sequence[TypeParameter]' = None, _params: 'Optional[Parameters]' = None, _return_type: 'Optional[Expression]' = None, _func_type_comment: 'Optional[FuncTypeComment]' = None, _block: 'Block' = None)

Bases: object

async_(async_)

block(block)

build()

func_type_comment(func_type_comment)

name(name)

params(params)

return_type(return_type)

type_params(type_params)

FUNC_TYPE_COMMENT = Name(value='funcTypeComment')

NAME = Name(value='name')

PARAMS = Name(value='params')

RETURN_TYPE = Name(value='returnType')

TYPE_ = Name(value='hydra.python.syntax.FunctionDefRaw')

TYPE_PARAMS = Name(value='typeParams')

async_: bool

block: Block

static builder()

func_type_comment: object

name: Name

params: object

return_type: object

type_params: Sequence[TypeParameter]

with_async_(async_)

with_block(block)

with_func_type_comment(func_type_comment)

with_name(name)

with_params(params)

with_return_type(return_type)

with_type_params(type_params)

class hydra.python.syntax.FunctionDefinition(decorators: 'Optional[Decorators]', raw: 'FunctionDefRaw')

Bases: object

class Builder(_decorators: 'Optional[Decorators]' = None, _raw: 'FunctionDefRaw' = None)

Bases: object

build()

decorators(decorators)

raw(raw)

DECORATORS = Name(value='decorators')

RAW = Name(value='raw')

TYPE_ = Name(value='hydra.python.syntax.FunctionDefinition')

static builder()

decorators: object

raw: FunctionDefRaw

with_decorators(decorators)

with_raw(raw)

class hydra.python.syntax.Genexp(head: 'GenexpHead', tail: 'ForIfClauses')

Bases: object

class Builder(_head: 'GenexpHead' = None, _tail: 'ForIfClauses' = None)

Bases: object

build()

head(head)

tail(tail)

HEAD = Name(value='head')

TAIL = Name(value='tail')

TYPE_ = Name(value='hydra.python.syntax.Genexp')

static builder()

head: GenexpHead

tail: ForIfClauses

with_head(head)

with_tail(tail)

class hydra.python.syntax.GenexpHead

Bases: object

GenexpHeadAssignment | GenexpHeadExpression

ASSIGNMENT = Name(value='assignment')

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.python.syntax.GenexpHead')

class hydra.python.syntax.GenexpHeadAssignment(value: T)

Bases: Node[AssignmentExpression]

class hydra.python.syntax.GenexpHeadExpression(value: T)

Bases: Node[Expression]

class hydra.python.syntax.Group

Bases: object

GroupYield | GroupExpression

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.python.syntax.Group')

YIELD = Name(value='yield')

class hydra.python.syntax.GroupExpression(value: T)

Bases: Node[NamedExpression]

class hydra.python.syntax.GroupPattern(value: T)

Bases: Node[Pattern]

TYPE_ = Name(value='hydra.python.syntax.GroupPattern')

class hydra.python.syntax.GroupYield(value: T)

Bases: Node[YieldExpression]

class hydra.python.syntax.Guard(value: T)

Bases: Node[NamedExpression]

TYPE_ = Name(value='hydra.python.syntax.Guard')

class hydra.python.syntax.IfStatement(condition: 'NamedExpression', body: 'Block', continuation: 'Optional[IfTail]')

Bases: object

BODY = Name(value='body')

class Builder(_condition: 'NamedExpression' = None, _body: 'Block' = None, _continuation: 'Optional[IfTail]' = None)

Bases: object

body(body)

build()

condition(condition)

continuation(continuation)

CONDITION = Name(value='condition')

CONTINUATION = Name(value='continuation')

TYPE_ = Name(value='hydra.python.syntax.IfStatement')

body: Block

static builder()

condition: NamedExpression

continuation: object

with_body(body)

with_condition(condition)

with_continuation(continuation)

class hydra.python.syntax.IfTail

Bases: object

IfTailElif | IfTailElse

ELIF = Name(value='elif')

ELSE = Name(value='else')

TYPE_ = Name(value='hydra.python.syntax.IfTail')

class hydra.python.syntax.IfTailElif(value: T)

Bases: Node[IfStatement]

class hydra.python.syntax.IfTailElse(value: T)

Bases: Node[Block]

class hydra.python.syntax.ImaginaryNumber(value: T)

Bases: Node[float]

TYPE_ = Name(value='hydra.python.syntax.ImaginaryNumber')

class hydra.python.syntax.ImportFrom(prefixes: 'Sequence[RelativeImportPrefix]', dotted_name: 'Optional[DottedName]', targets: 'ImportFromTargets')

Bases: object

class Builder(_prefixes: 'Sequence[RelativeImportPrefix]' = None, _dotted_name: 'Optional[DottedName]' = None, _targets: 'ImportFromTargets' = None)

Bases: object

build()

dotted_name(dotted_name)

prefixes(prefixes)

targets(targets)

DOTTED_NAME = Name(value='dottedName')

PREFIXES = Name(value='prefixes')

TARGETS = Name(value='targets')

TYPE_ = Name(value='hydra.python.syntax.ImportFrom')

static builder()

dotted_name: object

prefixes: Sequence[RelativeImportPrefix]

targets: ImportFromTargets

with_dotted_name(dotted_name)

with_prefixes(prefixes)

with_targets(targets)

class hydra.python.syntax.ImportFromAsName(name: 'Name', as_: 'Optional[Name]')

Bases: object

AS = Name(value='as')

class Builder(_name: 'Name' = None, _as_: 'Optional[Name]' = None)

Bases: object

as_(as_)

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.ImportFromAsName')

as_: object

static builder()

name: Name

with_as_(as_)

with_name(name)

class hydra.python.syntax.ImportFromTargets

Bases: object

ImportFromTargetsSimple | ImportFromTargetsParens | ImportFromTargetsStar

PARENS = Name(value='parens')

SIMPLE = Name(value='simple')

STAR = Name(value='star')

TYPE_ = Name(value='hydra.python.syntax.ImportFromTargets')

class hydra.python.syntax.ImportFromTargetsParens(value: T)

Bases: Node[Sequence[ImportFromAsName]]

class hydra.python.syntax.ImportFromTargetsSimple(value: T)

Bases: Node[Sequence[ImportFromAsName]]

class hydra.python.syntax.ImportFromTargetsStar

Bases: object

class hydra.python.syntax.ImportName(value: T)

Bases: Node[Sequence[DottedAsName]]

TYPE_ = Name(value='hydra.python.syntax.ImportName')

class hydra.python.syntax.ImportStatement

Bases: object

ImportStatementName | ImportStatementFrom

FROM = Name(value='from')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.ImportStatement')

class hydra.python.syntax.ImportStatementFrom(value: T)

Bases: Node[ImportFrom]

class hydra.python.syntax.ImportStatementName(value: T)

Bases: Node[ImportName]

class hydra.python.syntax.Interactive(value: T)

Bases: Node[Statement]

TYPE_ = Name(value='hydra.python.syntax.Interactive')

class hydra.python.syntax.Inversion

Bases: object

InversionNot | InversionSimple

NOT = Name(value='not')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.python.syntax.Inversion')

class hydra.python.syntax.InversionNot(value: T)

Bases: Node[Inversion]

class hydra.python.syntax.InversionSimple(value: T)

Bases: Node[Comparison]

class hydra.python.syntax.ItemsPattern(value: T)

Bases: Node[Sequence[KeyValuePattern]]

TYPE_ = Name(value='hydra.python.syntax.ItemsPattern')

class hydra.python.syntax.KeyValuePattern(key: 'LiteralExpressionOrAttribute', value: 'Pattern')

Bases: object

class Builder(_key: 'LiteralExpressionOrAttribute' = None, _value: 'Pattern' = None)

Bases: object

build()

key(key)

value(value)

KEY = Name(value='key')

TYPE_ = Name(value='hydra.python.syntax.KeyValuePattern')

VALUE = Name(value='value')

static builder()

key: LiteralExpressionOrAttribute

value: Pattern

with_key(key)

with_value(value)

class hydra.python.syntax.KeywordPattern(name: 'Name', pattern: 'Pattern')

Bases: object

class Builder(_name: 'Name' = None, _pattern: 'Pattern' = None)

Bases: object

build()

name(name)

pattern(pattern)

NAME = Name(value='name')

PATTERN = Name(value='pattern')

TYPE_ = Name(value='hydra.python.syntax.KeywordPattern')

static builder()

name: Name

pattern: Pattern

with_name(name)

with_pattern(pattern)

class hydra.python.syntax.KeywordPatterns(value: T)

Bases: Node[Sequence[KeywordPattern]]

TYPE_ = Name(value='hydra.python.syntax.KeywordPatterns')

class hydra.python.syntax.Keywords(value: T)

Bases: Node[ParamNoDefault]

TYPE_ = Name(value='hydra.python.syntax.Keywords')

class hydra.python.syntax.Kvpair(key: 'Expression', value: 'Expression')

Bases: object

class Builder(_key: 'Expression' = None, _value: 'Expression' = None)

Bases: object

build()

key(key)

value(value)

KEY = Name(value='key')

TYPE_ = Name(value='hydra.python.syntax.Kvpair')

VALUE = Name(value='value')

static builder()

key: Expression

value: Expression

with_key(key)

with_value(value)

class hydra.python.syntax.Kwarg(name: 'Name', value: 'Expression')

Bases: object

class Builder(_name: 'Name' = None, _value: 'Expression' = None)

Bases: object

build()

name(name)

value(value)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.Kwarg')

VALUE = Name(value='value')

static builder()

name: Name

value: Expression

with_name(name)

with_value(value)

class hydra.python.syntax.KwargOrDoubleStarred

Bases: object

KwargOrDoubleStarredKwarg | KwargOrDoubleStarredDoubleStarred

DOUBLE_STARRED = Name(value='doubleStarred')

KWARG = Name(value='kwarg')

TYPE_ = Name(value='hydra.python.syntax.KwargOrDoubleStarred')

class hydra.python.syntax.KwargOrDoubleStarredDoubleStarred(value: T)

Bases: Node[Expression]

class hydra.python.syntax.KwargOrDoubleStarredKwarg(value: T)

Bases: Node[Kwarg]

class hydra.python.syntax.KwargOrStarred

Bases: object

KwargOrStarredKwarg | KwargOrStarredStarred

KWARG = Name(value='kwarg')

STARRED = Name(value='starred')

TYPE_ = Name(value='hydra.python.syntax.KwargOrStarred')

class hydra.python.syntax.KwargOrStarredKwarg(value: T)

Bases: Node[Kwarg]

class hydra.python.syntax.KwargOrStarredStarred(value: T)

Bases: Node[StarredExpression]

class hydra.python.syntax.Lambda(params: 'LambdaParameters', body: 'Expression')

Bases: object

BODY = Name(value='body')

class Builder(_params: 'LambdaParameters' = None, _body: 'Expression' = None)

Bases: object

body(body)

build()

params(params)

PARAMS = Name(value='params')

TYPE_ = Name(value='hydra.python.syntax.Lambda')

body: Expression

static builder()

params: LambdaParameters

with_body(body)

with_params(params)

class hydra.python.syntax.LambdaKwds(value: T)

Bases: Node[LambdaParamNoDefault]

TYPE_ = Name(value='hydra.python.syntax.LambdaKwds')

class hydra.python.syntax.LambdaParamMaybeDefault(param: 'Name', default: 'Optional[Default]')

Bases: object

class Builder(_param: 'Name' = None, _default: 'Optional[Default]' = None)

Bases: object

build()

default(default)

param(param)

DEFAULT = Name(value='default')

PARAM = Name(value='param')

TYPE_ = Name(value='hydra.python.syntax.LambdaParamMaybeDefault')

static builder()

default: object

param: Name

with_default(default)

with_param(param)

class hydra.python.syntax.LambdaParamNoDefault(value: T)

Bases: Node[Name]

TYPE_ = Name(value='hydra.python.syntax.LambdaParamNoDefault')

class hydra.python.syntax.LambdaParamWithDefault(param: 'Name', default: 'Optional[Default]')

Bases: object

class Builder(_param: 'Name' = None, _default: 'Optional[Default]' = None)

Bases: object

build()

default(default)

param(param)

DEFAULT = Name(value='default')

PARAM = Name(value='param')

TYPE_ = Name(value='hydra.python.syntax.LambdaParamWithDefault')

static builder()

default: object

param: Name

with_default(default)

with_param(param)

class hydra.python.syntax.LambdaParameters(slash_no_default: 'Optional[LambdaSlashNoDefault]', param_no_default: 'Sequence[LambdaParamNoDefault]', param_with_default: 'Sequence[LambdaParamWithDefault]', star_etc: 'Optional[LambdaStarEtc]')

Bases: object

class Builder(_slash_no_default: 'Optional[LambdaSlashNoDefault]' = None, _param_no_default: 'Sequence[LambdaParamNoDefault]' = None, _param_with_default: 'Sequence[LambdaParamWithDefault]' = None, _star_etc: 'Optional[LambdaStarEtc]' = None)

Bases: object

build()

param_no_default(param_no_default)

param_with_default(param_with_default)

slash_no_default(slash_no_default)

star_etc(star_etc)

PARAM_NO_DEFAULT = Name(value='paramNoDefault')

PARAM_WITH_DEFAULT = Name(value='paramWithDefault')

SLASH_NO_DEFAULT = Name(value='slashNoDefault')

STAR_ETC = Name(value='starEtc')

TYPE_ = Name(value='hydra.python.syntax.LambdaParameters')

static builder()

param_no_default: Sequence[LambdaParamNoDefault]

param_with_default: Sequence[LambdaParamWithDefault]

slash_no_default: object

star_etc: object

with_param_no_default(param_no_default)

with_param_with_default(param_with_default)

with_slash_no_default(slash_no_default)

with_star_etc(star_etc)

class hydra.python.syntax.LambdaSlashNoDefault(parameters: 'Sequence[LambdaParamNoDefault]')

Bases: object

class Builder(_parameters: 'Sequence[LambdaParamNoDefault]' = None)

Bases: object

build()

parameters(parameters)

PARAMETERS = Name(value='parameters')

TYPE_ = Name(value='hydra.python.syntax.LambdaSlashNoDefault')

static builder()

parameters: Sequence[LambdaParamNoDefault]

with_parameters(parameters)

class hydra.python.syntax.LambdaSlashWithDefault(param_no_default: 'Sequence[LambdaParamNoDefault]', param_with_default: 'Sequence[LambdaParamWithDefault]')

Bases: object

class Builder(_param_no_default: 'Sequence[LambdaParamNoDefault]' = None, _param_with_default: 'Sequence[LambdaParamWithDefault]' = None)

Bases: object

build()

param_no_default(param_no_default)

param_with_default(param_with_default)

PARAM_NO_DEFAULT = Name(value='paramNoDefault')

PARAM_WITH_DEFAULT = Name(value='paramWithDefault')

TYPE_ = Name(value='hydra.python.syntax.LambdaSlashWithDefault')

static builder()

param_no_default: Sequence[LambdaParamNoDefault]

param_with_default: Sequence[LambdaParamWithDefault]

with_param_no_default(param_no_default)

with_param_with_default(param_with_default)

class hydra.python.syntax.LambdaStarEtc

Bases: object

LambdaStarEtcStar | LambdaStarEtcParamNoDefault | LambdaStarEtcParamMaybeDefault | LambdaStarEtcKwds

KWDS = Name(value='kwds')

PARAM_MAYBE_DEFAULT = Name(value='paramMaybeDefault')

PARAM_NO_DEFAULT = Name(value='paramNoDefault')

STAR = Name(value='star')

TYPE_ = Name(value='hydra.python.syntax.LambdaStarEtc')

class hydra.python.syntax.LambdaStarEtcKwds(value: T)

Bases: Node[LambdaKwds]

class hydra.python.syntax.LambdaStarEtcParamMaybeDefault(value: T)

Bases: Node[Sequence[LambdaParamMaybeDefault]]

class hydra.python.syntax.LambdaStarEtcParamNoDefault(value: T)

Bases: Node[LambdaParamNoDefault]

class hydra.python.syntax.LambdaStarEtcStar(value: T)

Bases: Node[bool]

class hydra.python.syntax.List(value: T)

Bases: Node[Sequence[StarNamedExpression]]

TYPE_ = Name(value='hydra.python.syntax.List')

class hydra.python.syntax.Listcomp(expression: 'NamedExpression', for_if_clauses: 'ForIfClauses')

Bases: object

class Builder(_expression: 'NamedExpression' = None, _for_if_clauses: 'ForIfClauses' = None)

Bases: object

build()

expression(expression)

for_if_clauses(for_if_clauses)

EXPRESSION = Name(value='expression')

FOR_IF_CLAUSES = Name(value='forIfClauses')

TYPE_ = Name(value='hydra.python.syntax.Listcomp')

static builder()

expression: NamedExpression

for_if_clauses: ForIfClauses

with_expression(expression)

with_for_if_clauses(for_if_clauses)

class hydra.python.syntax.LiteralExpression

Bases: object

LiteralExpressionNumber | LiteralExpressionComplex | LiteralExpressionString | LiteralExpressionNone | LiteralExpressionTrue | LiteralExpressionFalse

COMPLEX = Name(value='complex')

FALSE = Name(value='false')

NONE = Name(value='none')

NUMBER = Name(value='number')

STRING = Name(value='string')

TRUE = Name(value='true')

TYPE_ = Name(value='hydra.python.syntax.LiteralExpression')

class hydra.python.syntax.LiteralExpressionComplex(value: T)

Bases: Node[ComplexNumber]

class hydra.python.syntax.LiteralExpressionFalse

Bases: object

class hydra.python.syntax.LiteralExpressionNone

Bases: object

class hydra.python.syntax.LiteralExpressionNumber(value: T)

Bases: Node[SignedNumber]

class hydra.python.syntax.LiteralExpressionOrAttribute

Bases: object

LiteralExpressionOrAttributeLiteral | LiteralExpressionOrAttributeAttribute

ATTRIBUTE = Name(value='attribute')

LITERAL = Name(value='literal')

TYPE_ = Name(value='hydra.python.syntax.LiteralExpressionOrAttribute')

class hydra.python.syntax.LiteralExpressionOrAttributeAttribute(value: T)

Bases: Node[Attribute]

class hydra.python.syntax.LiteralExpressionOrAttributeLiteral(value: T)

Bases: Node[LiteralExpression]

class hydra.python.syntax.LiteralExpressionString(value: T)

Bases: Node[String]

class hydra.python.syntax.LiteralExpressionTrue

Bases: object

class hydra.python.syntax.MappingPattern(items: 'Optional[ItemsPattern]', double_star: 'Optional[DoubleStarPattern]')

Bases: object

class Builder(_items: 'Optional[ItemsPattern]' = None, _double_star: 'Optional[DoubleStarPattern]' = None)

Bases: object

build()

double_star(double_star)

items(items)

DOUBLE_STAR = Name(value='doubleStar')

ITEMS = Name(value='items')

TYPE_ = Name(value='hydra.python.syntax.MappingPattern')

static builder()

double_star: object

items: object

with_double_star(double_star)

with_items(items)

class hydra.python.syntax.MatchStatement(subject: 'SubjectExpression', cases: 'Sequence[CaseBlock]')

Bases: object

class Builder(_subject: 'SubjectExpression' = None, _cases: 'Sequence[CaseBlock]' = None)

Bases: object

build()

cases(cases)

subject(subject)

CASES = Name(value='cases')

SUBJECT = Name(value='subject')

TYPE_ = Name(value='hydra.python.syntax.MatchStatement')

static builder()

cases: Sequence[CaseBlock]

subject: SubjectExpression

with_cases(cases)

with_subject(subject)

class hydra.python.syntax.MaybeSequencePattern(value: T)

Bases: Node[Sequence[MaybeStarPattern]]

TYPE_ = Name(value='hydra.python.syntax.MaybeSequencePattern')

class hydra.python.syntax.MaybeStarPattern

Bases: object

MaybeStarPatternStar | MaybeStarPatternPattern

PATTERN = Name(value='pattern')

STAR = Name(value='star')

TYPE_ = Name(value='hydra.python.syntax.MaybeStarPattern')

class hydra.python.syntax.MaybeStarPatternPattern(value: T)

Bases: Node[Pattern]

class hydra.python.syntax.MaybeStarPatternStar(value: T)

Bases: Node[StarPattern]

class hydra.python.syntax.Module(value: T)

Bases: Node[Sequence[Sequence[Statement]]]

TYPE_ = Name(value='hydra.python.syntax.Module')

class hydra.python.syntax.Name(value: T)

Bases: Node[str]

TYPE_ = Name(value='hydra.python.syntax.Name')

class hydra.python.syntax.NameOrAttribute(value: T)

Bases: Node[Sequence[Name]]

TYPE_ = Name(value='hydra.python.syntax.NameOrAttribute')

class hydra.python.syntax.NamedExpression

Bases: object

NamedExpressionAssignment | NamedExpressionSimple

ASSIGNMENT = Name(value='assignment')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.python.syntax.NamedExpression')

class hydra.python.syntax.NamedExpressionAssignment(value: T)

Bases: Node[AssignmentExpression]

class hydra.python.syntax.NamedExpressionSimple(value: T)

Bases: Node[Expression]

class hydra.python.syntax.NoDefaultStarAnnotationStarEtc(param_no_default_star_annotation: 'ParamNoDefaultStarAnnotation', param_maybe_default: 'Sequence[ParamMaybeDefault]', keywords: 'Optional[Keywords]')

Bases: object

class Builder(_param_no_default_star_annotation: 'ParamNoDefaultStarAnnotation' = None, _param_maybe_default: 'Sequence[ParamMaybeDefault]' = None, _keywords: 'Optional[Keywords]' = None)

Bases: object

build()

keywords(keywords)

param_maybe_default(param_maybe_default)

param_no_default_star_annotation(param_no_default_star_annotation)

KEYWORDS = Name(value='keywords')

PARAM_MAYBE_DEFAULT = Name(value='paramMaybeDefault')

PARAM_NO_DEFAULT_STAR_ANNOTATION = Name(value='paramNoDefaultStarAnnotation')

TYPE_ = Name(value='hydra.python.syntax.NoDefaultStarAnnotationStarEtc')

static builder()

keywords: object

param_maybe_default: Sequence[ParamMaybeDefault]

param_no_default_star_annotation: ParamNoDefaultStarAnnotation

with_keywords(keywords)

with_param_maybe_default(param_maybe_default)

with_param_no_default_star_annotation(param_no_default_star_annotation)

class hydra.python.syntax.NoDefaultStarEtc(param_no_default: 'ParamNoDefault', param_maybe_default: 'Sequence[ParamMaybeDefault]', keywords: 'Optional[Keywords]')

Bases: object

class Builder(_param_no_default: 'ParamNoDefault' = None, _param_maybe_default: 'Sequence[ParamMaybeDefault]' = None, _keywords: 'Optional[Keywords]' = None)

Bases: object

build()

keywords(keywords)

param_maybe_default(param_maybe_default)

param_no_default(param_no_default)

KEYWORDS = Name(value='keywords')

PARAM_MAYBE_DEFAULT = Name(value='paramMaybeDefault')

PARAM_NO_DEFAULT = Name(value='paramNoDefault')

TYPE_ = Name(value='hydra.python.syntax.NoDefaultStarEtc')

static builder()

keywords: object

param_maybe_default: Sequence[ParamMaybeDefault]

param_no_default: ParamNoDefault

with_keywords(keywords)

with_param_maybe_default(param_maybe_default)

with_param_no_default(param_no_default)

class hydra.python.syntax.Number

Bases: object

NumberInteger | NumberFloat | NumberImaginary

FLOAT = Name(value='float')

IMAGINARY = Name(value='imaginary')

INTEGER = Name(value='integer')

TYPE_ = Name(value='hydra.python.syntax.Number')

class hydra.python.syntax.NumberFloat(value: T)

Bases: Node[float]

class hydra.python.syntax.NumberImaginary(value: T)

Bases: Node[float]

class hydra.python.syntax.NumberInteger(value: T)

Bases: Node[int]

class hydra.python.syntax.OpenSequencePattern(head: 'MaybeStarPattern', tail: 'Optional[MaybeSequencePattern]')

Bases: object

class Builder(_head: 'MaybeStarPattern' = None, _tail: 'Optional[MaybeSequencePattern]' = None)

Bases: object

build()

head(head)

tail(tail)

HEAD = Name(value='head')

TAIL = Name(value='tail')

TYPE_ = Name(value='hydra.python.syntax.OpenSequencePattern')

static builder()

head: MaybeStarPattern

tail: object

with_head(head)

with_tail(tail)

class hydra.python.syntax.OrPattern(value: T)

Bases: Node[Sequence[ClosedPattern]]

TYPE_ = Name(value='hydra.python.syntax.OrPattern')

class hydra.python.syntax.Param(name: 'Name', annotation: 'Optional[Annotation]')

Bases: object

ANNOTATION = Name(value='annotation')

class Builder(_name: 'Name' = None, _annotation: 'Optional[Annotation]' = None)

Bases: object

annotation(annotation)

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.Param')

annotation: object

static builder()

name: Name

with_annotation(annotation)

with_name(name)

class hydra.python.syntax.ParamMaybeDefault(param: 'Param', default: 'Optional[Default]', type_comment: 'Optional[TypeComment]')

Bases: object

class Builder(_param: 'Param' = None, _default: 'Optional[Default]' = None, _type_comment: 'Optional[TypeComment]' = None)

Bases: object

build()

default(default)

param(param)

type_comment(type_comment)

DEFAULT = Name(value='default')

PARAM = Name(value='param')

TYPE_ = Name(value='hydra.python.syntax.ParamMaybeDefault')

TYPE_COMMENT = Name(value='typeComment')

static builder()

default: object

param: Param

type_comment: object

with_default(default)

with_param(param)

with_type_comment(type_comment)

class hydra.python.syntax.ParamNoDefault(param: 'Param', type_comment: 'Optional[TypeComment]')

Bases: object

class Builder(_param: 'Param' = None, _type_comment: 'Optional[TypeComment]' = None)

Bases: object

build()

param(param)

type_comment(type_comment)

PARAM = Name(value='param')

TYPE_ = Name(value='hydra.python.syntax.ParamNoDefault')

TYPE_COMMENT = Name(value='typeComment')

static builder()

param: Param

type_comment: object

with_param(param)

with_type_comment(type_comment)

class hydra.python.syntax.ParamNoDefaultParameters(param_no_default: 'Sequence[ParamNoDefault]', param_with_default: 'Sequence[ParamWithDefault]', star_etc: 'Optional[StarEtc]')

Bases: object

class Builder(_param_no_default: 'Sequence[ParamNoDefault]' = None, _param_with_default: 'Sequence[ParamWithDefault]' = None, _star_etc: 'Optional[StarEtc]' = None)

Bases: object

build()

param_no_default(param_no_default)

param_with_default(param_with_default)

star_etc(star_etc)

PARAM_NO_DEFAULT = Name(value='paramNoDefault')

PARAM_WITH_DEFAULT = Name(value='paramWithDefault')

STAR_ETC = Name(value='starEtc')

TYPE_ = Name(value='hydra.python.syntax.ParamNoDefaultParameters')

static builder()

param_no_default: Sequence[ParamNoDefault]

param_with_default: Sequence[ParamWithDefault]

star_etc: object

with_param_no_default(param_no_default)

with_param_with_default(param_with_default)

with_star_etc(star_etc)

class hydra.python.syntax.ParamNoDefaultStarAnnotation(param_star_annotation: 'ParamStarAnnotation', type_comment: 'Optional[TypeComment]')

Bases: object

class Builder(_param_star_annotation: 'ParamStarAnnotation' = None, _type_comment: 'Optional[TypeComment]' = None)

Bases: object

build()

param_star_annotation(param_star_annotation)

type_comment(type_comment)

PARAM_STAR_ANNOTATION = Name(value='paramStarAnnotation')

TYPE_ = Name(value='hydra.python.syntax.ParamNoDefaultStarAnnotation')

TYPE_COMMENT = Name(value='typeComment')

static builder()

param_star_annotation: ParamStarAnnotation

type_comment: object

with_param_star_annotation(param_star_annotation)

with_type_comment(type_comment)

class hydra.python.syntax.ParamStarAnnotation(name: 'Name', annotation: 'StarAnnotation')

Bases: object

ANNOTATION = Name(value='annotation')

class Builder(_name: 'Name' = None, _annotation: 'StarAnnotation' = None)

Bases: object

annotation(annotation)

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.ParamStarAnnotation')

annotation: StarAnnotation

static builder()

name: Name

with_annotation(annotation)

with_name(name)

class hydra.python.syntax.ParamWithDefault(param: 'Param', default: 'Default', type_comment: 'Optional[TypeComment]')

Bases: object

class Builder(_param: 'Param' = None, _default: 'Default' = None, _type_comment: 'Optional[TypeComment]' = None)

Bases: object

build()

default(default)

param(param)

type_comment(type_comment)

DEFAULT = Name(value='default')

PARAM = Name(value='param')

TYPE_ = Name(value='hydra.python.syntax.ParamWithDefault')

TYPE_COMMENT = Name(value='typeComment')

static builder()

default: Default

param: Param

type_comment: object

with_default(default)

with_param(param)

with_type_comment(type_comment)

class hydra.python.syntax.ParamWithDefaultParameters(param_with_default: 'Sequence[ParamWithDefault]', star_etc: 'Optional[StarEtc]')

Bases: object

class Builder(_param_with_default: 'Sequence[ParamWithDefault]' = None, _star_etc: 'Optional[StarEtc]' = None)

Bases: object

build()

param_with_default(param_with_default)

star_etc(star_etc)

PARAM_WITH_DEFAULT = Name(value='paramWithDefault')

STAR_ETC = Name(value='starEtc')

TYPE_ = Name(value='hydra.python.syntax.ParamWithDefaultParameters')

static builder()

param_with_default: Sequence[ParamWithDefault]

star_etc: object

with_param_with_default(param_with_default)

with_star_etc(star_etc)

class hydra.python.syntax.Parameters

Bases: object

ParametersSlashNoDefault | ParametersSlashWithDefault | ParametersParamNoDefault | ParametersParamWithDefault | ParametersStarEtc

PARAM_NO_DEFAULT = Name(value='paramNoDefault')

PARAM_WITH_DEFAULT = Name(value='paramWithDefault')

SLASH_NO_DEFAULT = Name(value='slashNoDefault')

SLASH_WITH_DEFAULT = Name(value='slashWithDefault')

STAR_ETC = Name(value='starEtc')

TYPE_ = Name(value='hydra.python.syntax.Parameters')

class hydra.python.syntax.ParametersParamNoDefault(value: T)

Bases: Node[ParamNoDefaultParameters]

class hydra.python.syntax.ParametersParamWithDefault(value: T)

Bases: Node[ParamWithDefaultParameters]

class hydra.python.syntax.ParametersSlashNoDefault(value: T)

Bases: Node[SlashNoDefaultParameters]

class hydra.python.syntax.ParametersSlashWithDefault(value: T)

Bases: Node[SlashWithDefaultParameters]

class hydra.python.syntax.ParametersStarEtc(value: T)

Bases: Node[StarEtc]

class hydra.python.syntax.Pattern

Bases: object

PatternAs | PatternOr

AS = Name(value='as')

OR = Name(value='or')

TYPE_ = Name(value='hydra.python.syntax.Pattern')

class hydra.python.syntax.PatternAs(value: T)

Bases: Node[AsPattern]

class hydra.python.syntax.PatternCaptureTarget(value: T)

Bases: Node[Name]

TYPE_ = Name(value='hydra.python.syntax.PatternCaptureTarget')

class hydra.python.syntax.PatternOr(value: T)

Bases: Node[OrPattern]

class hydra.python.syntax.Patterns

Bases: object

PatternsSequence | PatternsPattern

PATTERN = Name(value='pattern')

SEQUENCE = Name(value='sequence')

TYPE_ = Name(value='hydra.python.syntax.Patterns')

class hydra.python.syntax.PatternsPattern(value: T)

Bases: Node[Pattern]

class hydra.python.syntax.PatternsSequence(value: T)

Bases: Node[OpenSequencePattern]

class hydra.python.syntax.PlusOrMinus(*values)

Bases: Enum

MINUS = Name(value='minus')

PLUS = Name(value='plus')

TYPE_ = Name(value='hydra.python.syntax.PlusOrMinus')

class hydra.python.syntax.PosArg

Bases: object

PosArgStarred | PosArgAssignment | PosArgExpression

ASSIGNMENT = Name(value='assignment')

EXPRESSION = Name(value='expression')

STARRED = Name(value='starred')

TYPE_ = Name(value='hydra.python.syntax.PosArg')

class hydra.python.syntax.PosArgAssignment(value: T)

Bases: Node[AssignmentExpression]

class hydra.python.syntax.PosArgExpression(value: T)

Bases: Node[Expression]

class hydra.python.syntax.PosArgStarred(value: T)

Bases: Node[StarredExpression]

class hydra.python.syntax.PositionalPatterns(value: T)

Bases: Node[Sequence[Pattern]]

TYPE_ = Name(value='hydra.python.syntax.PositionalPatterns')

class hydra.python.syntax.Power(lhs: 'AwaitPrimary', rhs: 'Optional[Factor]')

Bases: object

class Builder(_lhs: 'AwaitPrimary' = None, _rhs: 'Optional[Factor]' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.Power')

static builder()

lhs: AwaitPrimary

rhs: object

with_lhs(lhs)

with_rhs(rhs)

class hydra.python.syntax.Primary

Bases: object

PrimarySimple | PrimaryCompound

COMPOUND = Name(value='compound')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.python.syntax.Primary')

class hydra.python.syntax.PrimaryCompound(value: T)

Bases: Node[PrimaryWithRhs]

class hydra.python.syntax.PrimaryRhs

Bases: object

PrimaryRhsProject | PrimaryRhsGenexp | PrimaryRhsCall | PrimaryRhsSlices

CALL = Name(value='call')

GENEXP = Name(value='genexp')

PROJECT = Name(value='project')

SLICES = Name(value='slices')

TYPE_ = Name(value='hydra.python.syntax.PrimaryRhs')

class hydra.python.syntax.PrimaryRhsCall(value: T)

Bases: Node[Args]

class hydra.python.syntax.PrimaryRhsGenexp(value: T)

Bases: Node[Genexp]

class hydra.python.syntax.PrimaryRhsProject(value: T)

Bases: Node[Name]

class hydra.python.syntax.PrimaryRhsSlices(value: T)

Bases: Node[Slices]

class hydra.python.syntax.PrimarySimple(value: T)

Bases: Node[Atom]

class hydra.python.syntax.PrimaryWithRhs(primary: 'Primary', rhs: 'PrimaryRhs')

Bases: object

class Builder(_primary: 'Primary' = None, _rhs: 'PrimaryRhs' = None)

Bases: object

build()

primary(primary)

rhs(rhs)

PRIMARY = Name(value='primary')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.PrimaryWithRhs')

static builder()

primary: Primary

rhs: PrimaryRhs

with_primary(primary)

with_rhs(rhs)

class hydra.python.syntax.QuoteStyle(*values)

Bases: Enum

DOUBLE = Name(value='double')

SINGLE = Name(value='single')

TRIPLE_DOUBLE = Name(value='tripleDouble')

TRIPLE_SINGLE = Name(value='tripleSingle')

TYPE_ = Name(value='hydra.python.syntax.QuoteStyle')

class hydra.python.syntax.RaiseExpression(expression: 'Expression', from_: 'Optional[Expression]')

Bases: object

class Builder(_expression: 'Expression' = None, _from_: 'Optional[Expression]' = None)

Bases: object

build()

expression(expression)

from_(from_)

EXPRESSION = Name(value='expression')

FROM = Name(value='from')

TYPE_ = Name(value='hydra.python.syntax.RaiseExpression')

static builder()

expression: Expression

from_: object

with_expression(expression)

with_from_(from_)

class hydra.python.syntax.RaiseStatement(value: T)

Bases: Node[Optional[RaiseExpression]]

TYPE_ = Name(value='hydra.python.syntax.RaiseStatement')

class hydra.python.syntax.RealNumber

Bases: object

RealNumberInteger | RealNumberFloat

FLOAT = Name(value='float')

INTEGER = Name(value='integer')

TYPE_ = Name(value='hydra.python.syntax.RealNumber')

class hydra.python.syntax.RealNumberFloat(value: T)

Bases: Node[float]

class hydra.python.syntax.RealNumberInteger(value: T)

Bases: Node[int]

class hydra.python.syntax.RelativeImportPrefix(*values)

Bases: Enum

DOT = Name(value='dot')

ELLIPSIS = Name(value='ellipsis')

TYPE_ = Name(value='hydra.python.syntax.RelativeImportPrefix')

class hydra.python.syntax.ReturnStatement(value: T)

Bases: Node[Sequence[StarExpression]]

TYPE_ = Name(value='hydra.python.syntax.ReturnStatement')

class hydra.python.syntax.SequencePattern

Bases: object

SequencePatternList | SequencePatternTuple

LIST = Name(value='list')

TUPLE = Name(value='tuple')

TYPE_ = Name(value='hydra.python.syntax.SequencePattern')

class hydra.python.syntax.SequencePatternList(value: T)

Bases: Node[Optional[MaybeSequencePattern]]

class hydra.python.syntax.SequencePatternTuple(value: T)

Bases: Node[Optional[OpenSequencePattern]]

class hydra.python.syntax.Set(value: T)

Bases: Node[Sequence[StarNamedExpression]]

TYPE_ = Name(value='hydra.python.syntax.Set')

class hydra.python.syntax.Setcomp(expression: 'NamedExpression', for_if_clauses: 'ForIfClauses')

Bases: object

class Builder(_expression: 'NamedExpression' = None, _for_if_clauses: 'ForIfClauses' = None)

Bases: object

build()

expression(expression)

for_if_clauses(for_if_clauses)

EXPRESSION = Name(value='expression')

FOR_IF_CLAUSES = Name(value='forIfClauses')

TYPE_ = Name(value='hydra.python.syntax.Setcomp')

static builder()

expression: NamedExpression

for_if_clauses: ForIfClauses

with_expression(expression)

with_for_if_clauses(for_if_clauses)

class hydra.python.syntax.ShiftExpression(lhs: 'Optional[ShiftLhs]', rhs: 'Sum')

Bases: object

class Builder(_lhs: 'Optional[ShiftLhs]' = None, _rhs: 'Sum' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.ShiftExpression')

static builder()

lhs: object

rhs: Sum

with_lhs(lhs)

with_rhs(rhs)

class hydra.python.syntax.ShiftLhs(operand: 'ShiftExpression', operator: 'ShiftOp')

Bases: object

class Builder(_operand: 'ShiftExpression' = None, _operator: 'ShiftOp' = None)

Bases: object

build()

operand(operand)

operator(operator)

OPERAND = Name(value='operand')

OPERATOR = Name(value='operator')

TYPE_ = Name(value='hydra.python.syntax.ShiftLhs')

static builder()

operand: ShiftExpression

operator: ShiftOp

with_operand(operand)

with_operator(operator)

class hydra.python.syntax.ShiftOp(*values)

Bases: Enum

LEFT = Name(value='left')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.python.syntax.ShiftOp')

class hydra.python.syntax.SignedNumber

Bases: object

SignedNumberSign | SignedNumberNumber

NUMBER = Name(value='number')

SIGN = Name(value='sign')

TYPE_ = Name(value='hydra.python.syntax.SignedNumber')

class hydra.python.syntax.SignedNumberNumber(value: T)

Bases: Node[Number]

class hydra.python.syntax.SignedNumberSign(value: T)

Bases: Node[PlusOrMinus]

class hydra.python.syntax.SignedRealNumber

Bases: object

SignedRealNumberSign | SignedRealNumberNumber

NUMBER = Name(value='number')

SIGN = Name(value='sign')

TYPE_ = Name(value='hydra.python.syntax.SignedRealNumber')

class hydra.python.syntax.SignedRealNumberNumber(value: T)

Bases: Node[RealNumber]

class hydra.python.syntax.SignedRealNumberSign(value: T)

Bases: Node[PlusOrMinus]

class hydra.python.syntax.SimpleStatement

Bases: object

SimpleStatementAssignment | SimpleStatementTypeAlias | SimpleStatementStarExpressions | SimpleStatementReturn | SimpleStatementImport | SimpleStatementRaise | SimpleStatementPass | SimpleStatementDel | SimpleStatementYield | SimpleStatementAssert | SimpleStatementBreak | SimpleStatementContinue | SimpleStatementGlobal | SimpleStatementNonlocal

ASSERT = Name(value='assert')

ASSIGNMENT = Name(value='assignment')

BREAK = Name(value='break')

CONTINUE = Name(value='continue')

DEL = Name(value='del')

GLOBAL = Name(value='global')

IMPORT = Name(value='import')

NONLOCAL = Name(value='nonlocal')

PASS = Name(value='pass')

RAISE = Name(value='raise')

RETURN = Name(value='return')

STAR_EXPRESSIONS = Name(value='starExpressions')

TYPE_ = Name(value='hydra.python.syntax.SimpleStatement')

TYPE_ALIAS = Name(value='typeAlias')

YIELD = Name(value='yield')

class hydra.python.syntax.SimpleStatementAssert(value: T)

Bases: Node[AssertStatement]

class hydra.python.syntax.SimpleStatementAssignment(value: T)

Bases: Node[Assignment]

class hydra.python.syntax.SimpleStatementBreak

Bases: object

class hydra.python.syntax.SimpleStatementContinue

Bases: object

class hydra.python.syntax.SimpleStatementDel(value: T)

Bases: Node[DelStatement]

class hydra.python.syntax.SimpleStatementGlobal(value: T)

Bases: Node[Sequence[Name]]

class hydra.python.syntax.SimpleStatementImport(value: T)

Bases: Node[ImportStatement]

class hydra.python.syntax.SimpleStatementNonlocal(value: T)

Bases: Node[Sequence[Name]]

class hydra.python.syntax.SimpleStatementPass

Bases: object

class hydra.python.syntax.SimpleStatementRaise(value: T)

Bases: Node[RaiseStatement]

class hydra.python.syntax.SimpleStatementReturn(value: T)

Bases: Node[ReturnStatement]

class hydra.python.syntax.SimpleStatementStarExpressions(value: T)

Bases: Node[Sequence[StarExpression]]

class hydra.python.syntax.SimpleStatementTypeAlias(value: T)

Bases: Node[TypeAlias]

class hydra.python.syntax.SimpleStatementYield(value: T)

Bases: Node[YieldStatement]

class hydra.python.syntax.SimpleTypeParameter(name: 'Name', bound: 'Optional[Expression]', default: 'Optional[Expression]')

Bases: object

BOUND = Name(value='bound')

class Builder(_name: 'Name' = None, _bound: 'Optional[Expression]' = None, _default: 'Optional[Expression]' = None)

Bases: object

bound(bound)

build()

default(default)

name(name)

DEFAULT = Name(value='default')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.SimpleTypeParameter')

bound: object

static builder()

default: object

name: Name

with_bound(bound)

with_default(default)

with_name(name)

class hydra.python.syntax.SingleSubscriptAttributeTarget

Bases: object

SingleSubscriptAttributeTargetPrimaryAndName | SingleSubscriptAttributeTargetPrimaryAndSlices

PRIMARY_AND_NAME = Name(value='primaryAndName')

PRIMARY_AND_SLICES = Name(value='primaryAndSlices')

TYPE_ = Name(value='hydra.python.syntax.SingleSubscriptAttributeTarget')

class hydra.python.syntax.SingleSubscriptAttributeTargetPrimaryAndName(value: T)

Bases: Node[TPrimaryAndName]

class hydra.python.syntax.SingleSubscriptAttributeTargetPrimaryAndSlices(value: T)

Bases: Node[TPrimaryAndSlices]

class hydra.python.syntax.SingleTarget

Bases: object

SingleTargetSubscriptAttributeTarget | SingleTargetName | SingleTargetParens

NAME = Name(value='name')

PARENS = Name(value='parens')

SUBSCRIPT_ATTRIBUTE_TARGET = Name(value='subscriptAttributeTarget')

TYPE_ = Name(value='hydra.python.syntax.SingleTarget')

class hydra.python.syntax.SingleTargetName(value: T)

Bases: Node[Name]

class hydra.python.syntax.SingleTargetParens(value: T)

Bases: Node[SingleTarget]

class hydra.python.syntax.SingleTargetSubscriptAttributeTarget(value: T)

Bases: Node[SingleSubscriptAttributeTarget]

class hydra.python.syntax.SlashNoDefault(value: T)

Bases: Node[Sequence[ParamNoDefault]]

TYPE_ = Name(value='hydra.python.syntax.SlashNoDefault')

class hydra.python.syntax.SlashNoDefaultParameters(slash: 'SlashNoDefault', param_no_default: 'Sequence[ParamNoDefault]', param_with_default: 'Sequence[ParamWithDefault]', star_etc: 'Optional[StarEtc]')

Bases: object

class Builder(_slash: 'SlashNoDefault' = None, _param_no_default: 'Sequence[ParamNoDefault]' = None, _param_with_default: 'Sequence[ParamWithDefault]' = None, _star_etc: 'Optional[StarEtc]' = None)

Bases: object

build()

param_no_default(param_no_default)

param_with_default(param_with_default)

slash(slash)

star_etc(star_etc)

PARAM_NO_DEFAULT = Name(value='paramNoDefault')

PARAM_WITH_DEFAULT = Name(value='paramWithDefault')

SLASH = Name(value='slash')

STAR_ETC = Name(value='starEtc')

TYPE_ = Name(value='hydra.python.syntax.SlashNoDefaultParameters')

static builder()

param_no_default: Sequence[ParamNoDefault]

param_with_default: Sequence[ParamWithDefault]

slash: SlashNoDefault

star_etc: object

with_param_no_default(param_no_default)

with_param_with_default(param_with_default)

with_slash(slash)

with_star_etc(star_etc)

class hydra.python.syntax.SlashWithDefault(param_no_default: 'Sequence[ParamNoDefault]', param_with_default: 'Sequence[ParamWithDefault]')

Bases: object

class Builder(_param_no_default: 'Sequence[ParamNoDefault]' = None, _param_with_default: 'Sequence[ParamWithDefault]' = None)

Bases: object

build()

param_no_default(param_no_default)

param_with_default(param_with_default)

PARAM_NO_DEFAULT = Name(value='paramNoDefault')

PARAM_WITH_DEFAULT = Name(value='paramWithDefault')

TYPE_ = Name(value='hydra.python.syntax.SlashWithDefault')

static builder()

param_no_default: Sequence[ParamNoDefault]

param_with_default: Sequence[ParamWithDefault]

with_param_no_default(param_no_default)

with_param_with_default(param_with_default)

class hydra.python.syntax.SlashWithDefaultParameters(param_no_default: 'Sequence[ParamNoDefault]', param_with_default: 'Sequence[ParamWithDefault]', star_etc: 'Optional[StarEtc]')

Bases: object

class Builder(_param_no_default: 'Sequence[ParamNoDefault]' = None, _param_with_default: 'Sequence[ParamWithDefault]' = None, _star_etc: 'Optional[StarEtc]' = None)

Bases: object

build()

param_no_default(param_no_default)

param_with_default(param_with_default)

star_etc(star_etc)

PARAM_NO_DEFAULT = Name(value='paramNoDefault')

PARAM_WITH_DEFAULT = Name(value='paramWithDefault')

STAR_ETC = Name(value='starEtc')

TYPE_ = Name(value='hydra.python.syntax.SlashWithDefaultParameters')

static builder()

param_no_default: Sequence[ParamNoDefault]

param_with_default: Sequence[ParamWithDefault]

star_etc: object

with_param_no_default(param_no_default)

with_param_with_default(param_with_default)

with_star_etc(star_etc)

class hydra.python.syntax.Slice

Bases: object

SliceNamed | SliceSlice_

NAMED = Name(value='named')

SLICE_ = Name(value='slice_')

TYPE_ = Name(value='hydra.python.syntax.Slice')

class hydra.python.syntax.SliceExpression(start: 'Optional[Expression]', stop: 'Optional[Expression]', step: 'Optional[Expression]')

Bases: object

class Builder(_start: 'Optional[Expression]' = None, _stop: 'Optional[Expression]' = None, _step: 'Optional[Expression]' = None)

Bases: object

build()

start(start)

step(step)

stop(stop)

START = Name(value='start')

STEP = Name(value='step')

STOP = Name(value='stop')

TYPE_ = Name(value='hydra.python.syntax.SliceExpression')

static builder()

start: object

step: object

stop: object

with_start(start)

with_step(step)

with_stop(stop)

class hydra.python.syntax.SliceNamed(value: T)

Bases: Node[NamedExpression]

class hydra.python.syntax.SliceOrStarredExpression

Bases: object

SliceOrStarredExpressionSlice | SliceOrStarredExpressionStarred

SLICE = Name(value='slice')

STARRED = Name(value='starred')

TYPE_ = Name(value='hydra.python.syntax.SliceOrStarredExpression')

class hydra.python.syntax.SliceOrStarredExpressionSlice(value: T)

Bases: Node[Slice]

class hydra.python.syntax.SliceOrStarredExpressionStarred(value: T)

Bases: Node[StarredExpression]

class hydra.python.syntax.SliceSlice_(value: T)

Bases: Node[SliceExpression]

class hydra.python.syntax.Slices(head: 'Slice', tail: 'Sequence[SliceOrStarredExpression]')

Bases: object

class Builder(_head: 'Slice' = None, _tail: 'Sequence[SliceOrStarredExpression]' = None)

Bases: object

build()

head(head)

tail(tail)

HEAD = Name(value='head')

TAIL = Name(value='tail')

TYPE_ = Name(value='hydra.python.syntax.Slices')

static builder()

head: Slice

tail: Sequence[SliceOrStarredExpression]

with_head(head)

with_tail(tail)

class hydra.python.syntax.StarAnnotation(value: T)

Bases: Node[StarExpression]

TYPE_ = Name(value='hydra.python.syntax.StarAnnotation')

class hydra.python.syntax.StarAtom

Bases: object

StarAtomName | StarAtomTargetWithStarAtom | StarAtomStarTargetsTupleSeq | StarAtomStarTargetsListSeq

NAME = Name(value='name')

STAR_TARGETS_LIST_SEQ = Name(value='starTargetsListSeq')

STAR_TARGETS_TUPLE_SEQ = Name(value='starTargetsTupleSeq')

TARGET_WITH_STAR_ATOM = Name(value='targetWithStarAtom')

TYPE_ = Name(value='hydra.python.syntax.StarAtom')

class hydra.python.syntax.StarAtomName(value: T)

Bases: Node[Name]

class hydra.python.syntax.StarAtomStarTargetsListSeq(value: T)

Bases: Node[Optional[StarTargetsListSeq]]

class hydra.python.syntax.StarAtomStarTargetsTupleSeq(value: T)

Bases: Node[Optional[StarTargetsTupleSeq]]

class hydra.python.syntax.StarAtomTargetWithStarAtom(value: T)

Bases: Node[TargetWithStarAtom]

class hydra.python.syntax.StarEtc

Bases: object

StarEtcStarNoDefault | StarEtcStarNoDefaultStarAnnotation | StarEtcStarComma | StarEtcKeywords

KEYWORDS = Name(value='keywords')

STAR_COMMA = Name(value='starComma')

STAR_NO_DEFAULT = Name(value='starNoDefault')

STAR_NO_DEFAULT_STAR_ANNOTATION = Name(value='starNoDefaultStarAnnotation')

TYPE_ = Name(value='hydra.python.syntax.StarEtc')

class hydra.python.syntax.StarEtcKeywords(value: T)

Bases: Node[Keywords]

class hydra.python.syntax.StarEtcStarComma(value: T)

Bases: Node[CommaStarEtc]

class hydra.python.syntax.StarEtcStarNoDefault(value: T)

Bases: Node[NoDefaultStarEtc]

class hydra.python.syntax.StarEtcStarNoDefaultStarAnnotation(value: T)

Bases: Node[NoDefaultStarAnnotationStarEtc]

class hydra.python.syntax.StarExpression

Bases: object

StarExpressionStar | StarExpressionSimple

SIMPLE = Name(value='simple')

STAR = Name(value='star')

TYPE_ = Name(value='hydra.python.syntax.StarExpression')

class hydra.python.syntax.StarExpressionSimple(value: T)

Bases: Node[Expression]

class hydra.python.syntax.StarExpressionStar(value: T)

Bases: Node[BitwiseOr]

class hydra.python.syntax.StarNamedExpression

Bases: object

StarNamedExpressionStar | StarNamedExpressionSimple

SIMPLE = Name(value='simple')

STAR = Name(value='star')

TYPE_ = Name(value='hydra.python.syntax.StarNamedExpression')

class hydra.python.syntax.StarNamedExpressionSimple(value: T)

Bases: Node[NamedExpression]

class hydra.python.syntax.StarNamedExpressionStar(value: T)

Bases: Node[BitwiseOr]

class hydra.python.syntax.StarNamedExpressions(value: T)

Bases: Node[Sequence[StarNamedExpression]]

TYPE_ = Name(value='hydra.python.syntax.StarNamedExpressions')

class hydra.python.syntax.StarPattern

Bases: object

StarPatternCapture | StarPatternWildcard

CAPTURE = Name(value='capture')

TYPE_ = Name(value='hydra.python.syntax.StarPattern')

WILDCARD = Name(value='wildcard')

class hydra.python.syntax.StarPatternCapture(value: T)

Bases: Node[PatternCaptureTarget]

class hydra.python.syntax.StarPatternWildcard

Bases: object

class hydra.python.syntax.StarTarget

Bases: object

StarTargetStarred | StarTargetUnstarred

STARRED = Name(value='starred')

TYPE_ = Name(value='hydra.python.syntax.StarTarget')

UNSTARRED = Name(value='unstarred')

class hydra.python.syntax.StarTargetStarred(value: T)

Bases: Node[StarTarget]

class hydra.python.syntax.StarTargetUnstarred(value: T)

Bases: Node[TargetWithStarAtom]

class hydra.python.syntax.StarTargetsListSeq(value: T)

Bases: Node[Sequence[StarTarget]]

TYPE_ = Name(value='hydra.python.syntax.StarTargetsListSeq')

class hydra.python.syntax.StarTargetsTupleSeq(value: T)

Bases: Node[Sequence[StarTarget]]

TYPE_ = Name(value='hydra.python.syntax.StarTargetsTupleSeq')

class hydra.python.syntax.StarTypeParameter(name: 'Name', default: 'Optional[StarExpression]')

Bases: object

class Builder(_name: 'Name' = None, _default: 'Optional[StarExpression]' = None)

Bases: object

build()

default(default)

name(name)

DEFAULT = Name(value='default')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.StarTypeParameter')

static builder()

default: object

name: Name

with_default(default)

with_name(name)

class hydra.python.syntax.StarredExpression(value: T)

Bases: Node[Expression]

TYPE_ = Name(value='hydra.python.syntax.StarredExpression')

class hydra.python.syntax.Statement

Bases: object

StatementCompound | StatementSimple | StatementAnnotated

ANNOTATED = Name(value='annotated')

COMPOUND = Name(value='compound')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.python.syntax.Statement')

class hydra.python.syntax.StatementAnnotated(value: T)

Bases: Node[AnnotatedStatement]

class hydra.python.syntax.StatementCompound(value: T)

Bases: Node[CompoundStatement]

class hydra.python.syntax.StatementSimple(value: T)

Bases: Node[Sequence[SimpleStatement]]

class hydra.python.syntax.String(value: 'str', prefix: 'Optional[StringPrefix]', quote_style: 'QuoteStyle')

Bases: object

class Builder(_value: 'str' = None, _prefix: 'Optional[StringPrefix]' = None, _quote_style: 'QuoteStyle' = None)

Bases: object

build()

prefix(prefix)

quote_style(quote_style)

value(value)

PREFIX = Name(value='prefix')

QUOTE_STYLE = Name(value='quoteStyle')

TYPE_ = Name(value='hydra.python.syntax.String')

VALUE = Name(value='value')

static builder()

prefix: object

quote_style: QuoteStyle

value: str

with_prefix(prefix)

with_quote_style(quote_style)

with_value(value)

class hydra.python.syntax.StringPrefix(*values)

Bases: Enum

BYTES = Name(value='bytes')

RAW = Name(value='raw')

RAW_BYTES = Name(value='rawBytes')

TYPE_ = Name(value='hydra.python.syntax.StringPrefix')

UNICODE = Name(value='unicode')

class hydra.python.syntax.SubjectExpression

Bases: object

SubjectExpressionTuple | SubjectExpressionSimple

SIMPLE = Name(value='simple')

TUPLE = Name(value='tuple')

TYPE_ = Name(value='hydra.python.syntax.SubjectExpression')

class hydra.python.syntax.SubjectExpressionSimple(value: T)

Bases: Node[NamedExpression]

class hydra.python.syntax.SubjectExpressionTuple(value: T)

Bases: Node[Sequence[StarNamedExpression]]

class hydra.python.syntax.Sum(lhs: 'Optional[SumLhs]', rhs: 'Term')

Bases: object

class Builder(_lhs: 'Optional[SumLhs]' = None, _rhs: 'Term' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.Sum')

static builder()

lhs: object

rhs: Term

with_lhs(lhs)

with_rhs(rhs)

class hydra.python.syntax.SumLhs(operand: 'Sum', operator: 'SumOp')

Bases: object

class Builder(_operand: 'Sum' = None, _operator: 'SumOp' = None)

Bases: object

build()

operand(operand)

operator(operator)

OPERAND = Name(value='operand')

OPERATOR = Name(value='operator')

TYPE_ = Name(value='hydra.python.syntax.SumLhs')

static builder()

operand: Sum

operator: SumOp

with_operand(operand)

with_operator(operator)

class hydra.python.syntax.SumOp(*values)

Bases: Enum

ADD = Name(value='add')

SUB = Name(value='sub')

TYPE_ = Name(value='hydra.python.syntax.SumOp')

class hydra.python.syntax.TPrimary

Bases: object

TPrimaryPrimaryAndName | TPrimaryPrimaryAndSlices | TPrimaryPrimaryAndGenexp | TPrimaryPrimaryAndArguments | TPrimaryAtom

ATOM = Name(value='atom')

PRIMARY_AND_ARGUMENTS = Name(value='primaryAndArguments')

PRIMARY_AND_GENEXP = Name(value='primaryAndGenexp')

PRIMARY_AND_NAME = Name(value='primaryAndName')

PRIMARY_AND_SLICES = Name(value='primaryAndSlices')

TYPE_ = Name(value='hydra.python.syntax.TPrimary')

class hydra.python.syntax.TPrimaryAndArguments(primary: 'TPrimary', arguments: 'Optional[Args]')

Bases: object

ARGUMENTS = Name(value='arguments')

class Builder(_primary: 'TPrimary' = None, _arguments: 'Optional[Args]' = None)

Bases: object

arguments(arguments)

build()

primary(primary)

PRIMARY = Name(value='primary')

TYPE_ = Name(value='hydra.python.syntax.TPrimaryAndArguments')

arguments: object

static builder()

primary: TPrimary

with_arguments(arguments)

with_primary(primary)

class hydra.python.syntax.TPrimaryAndGenexp(primary: 'TPrimary', genexp: 'Genexp')

Bases: object

class Builder(_primary: 'TPrimary' = None, _genexp: 'Genexp' = None)

Bases: object

build()

genexp(genexp)

primary(primary)

GENEXP = Name(value='genexp')

PRIMARY = Name(value='primary')

TYPE_ = Name(value='hydra.python.syntax.TPrimaryAndGenexp')

static builder()

genexp: Genexp

primary: TPrimary

with_genexp(genexp)

with_primary(primary)

class hydra.python.syntax.TPrimaryAndName(primary: 'TPrimary', name: 'Name')

Bases: object

class Builder(_primary: 'TPrimary' = None, _name: 'Name' = None)

Bases: object

build()

name(name)

primary(primary)

NAME = Name(value='name')

PRIMARY = Name(value='primary')

TYPE_ = Name(value='hydra.python.syntax.TPrimaryAndName')

static builder()

name: Name

primary: TPrimary

with_name(name)

with_primary(primary)

class hydra.python.syntax.TPrimaryAndSlices(primary: 'TPrimary', slices: 'Slices')

Bases: object

class Builder(_primary: 'TPrimary' = None, _slices: 'Slices' = None)

Bases: object

build()

primary(primary)

slices(slices)

PRIMARY = Name(value='primary')

SLICES = Name(value='slices')

TYPE_ = Name(value='hydra.python.syntax.TPrimaryAndSlices')

static builder()

primary: TPrimary

slices: Slices

with_primary(primary)

with_slices(slices)

class hydra.python.syntax.TPrimaryAtom(value: T)

Bases: Node[Atom]

class hydra.python.syntax.TPrimaryPrimaryAndArguments(value: T)

Bases: Node[TPrimaryAndArguments]

class hydra.python.syntax.TPrimaryPrimaryAndGenexp(value: T)

Bases: Node[TPrimaryAndGenexp]

class hydra.python.syntax.TPrimaryPrimaryAndName(value: T)

Bases: Node[TPrimaryAndName]

class hydra.python.syntax.TPrimaryPrimaryAndSlices(value: T)

Bases: Node[TPrimaryAndSlices]

class hydra.python.syntax.TargetWithStarAtom

Bases: object

TargetWithStarAtomProject | TargetWithStarAtomSlices | TargetWithStarAtomAtom

ATOM = Name(value='atom')

PROJECT = Name(value='project')

SLICES = Name(value='slices')

TYPE_ = Name(value='hydra.python.syntax.TargetWithStarAtom')

class hydra.python.syntax.TargetWithStarAtomAtom(value: T)

Bases: Node[StarAtom]

class hydra.python.syntax.TargetWithStarAtomProject(value: T)

Bases: Node[TPrimaryAndName]

class hydra.python.syntax.TargetWithStarAtomSlices(value: T)

Bases: Node[TPrimaryAndSlices]

class hydra.python.syntax.Term(lhs: 'Optional[TermLhs]', rhs: 'Factor')

Bases: object

class Builder(_lhs: 'Optional[TermLhs]' = None, _rhs: 'Factor' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.python.syntax.Term')

static builder()

lhs: object

rhs: Factor

with_lhs(lhs)

with_rhs(rhs)

class hydra.python.syntax.TermLhs(operand: 'Term', operator: 'TermOp')

Bases: object

class Builder(_operand: 'Term' = None, _operator: 'TermOp' = None)

Bases: object

build()

operand(operand)

operator(operator)

OPERAND = Name(value='operand')

OPERATOR = Name(value='operator')

TYPE_ = Name(value='hydra.python.syntax.TermLhs')

static builder()

operand: Term

operator: TermOp

with_operand(operand)

with_operator(operator)

class hydra.python.syntax.TermOp(*values)

Bases: Enum

DIV = Name(value='div')

FLOORDIV = Name(value='floordiv')

MATMUL = Name(value='matmul')

MOD = Name(value='mod')

MUL = Name(value='mul')

TYPE_ = Name(value='hydra.python.syntax.TermOp')

class hydra.python.syntax.TryExceptStarStatement(body: 'Block', excepts: 'Sequence[ExceptStarBlock]', else_: 'Optional[Block]', finally_: 'Optional[Block]')

Bases: object

BODY = Name(value='body')

class Builder(_body: 'Block' = None, _excepts: 'Sequence[ExceptStarBlock]' = None, _else_: 'Optional[Block]' = None, _finally_: 'Optional[Block]' = None)

Bases: object

body(body)

build()

else_(else_)

excepts(excepts)

finally_(finally_)

ELSE = Name(value='else')

EXCEPTS = Name(value='excepts')

FINALLY = Name(value='finally')

TYPE_ = Name(value='hydra.python.syntax.TryExceptStarStatement')

body: Block

static builder()

else_: object

excepts: Sequence[ExceptStarBlock]

finally_: object

with_body(body)

with_else_(else_)

with_excepts(excepts)

with_finally_(finally_)

class hydra.python.syntax.TryExceptStatement(body: 'Block', excepts: 'Sequence[ExceptBlock]', else_: 'Optional[Block]', finally_: 'Optional[Block]')

Bases: object

BODY = Name(value='body')

class Builder(_body: 'Block' = None, _excepts: 'Sequence[ExceptBlock]' = None, _else_: 'Optional[Block]' = None, _finally_: 'Optional[Block]' = None)

Bases: object

body(body)

build()

else_(else_)

excepts(excepts)

finally_(finally_)

ELSE = Name(value='else')

EXCEPTS = Name(value='excepts')

FINALLY = Name(value='finally')

TYPE_ = Name(value='hydra.python.syntax.TryExceptStatement')

body: Block

static builder()

else_: object

excepts: Sequence[ExceptBlock]

finally_: object

with_body(body)

with_else_(else_)

with_excepts(excepts)

with_finally_(finally_)

class hydra.python.syntax.TryFinallyStatement(body: 'Block', finally_: 'Block')

Bases: object

BODY = Name(value='body')

class Builder(_body: 'Block' = None, _finally_: 'Block' = None)

Bases: object

body(body)

build()

finally_(finally_)

FINALLY = Name(value='finally')

TYPE_ = Name(value='hydra.python.syntax.TryFinallyStatement')

body: Block

static builder()

finally_: Block

with_body(body)

with_finally_(finally_)

class hydra.python.syntax.TryStatement

Bases: object

TryStatementFinally | TryStatementExcept | TryStatementExceptStar

EXCEPT = Name(value='except')

EXCEPT_STAR = Name(value='exceptStar')

FINALLY = Name(value='finally')

TYPE_ = Name(value='hydra.python.syntax.TryStatement')

class hydra.python.syntax.TryStatementExcept(value: T)

Bases: Node[TryExceptStatement]

class hydra.python.syntax.TryStatementExceptStar(value: T)

Bases: Node[TryExceptStarStatement]

class hydra.python.syntax.TryStatementFinally(value: T)

Bases: Node[TryFinallyStatement]

class hydra.python.syntax.Tuple(value: T)

Bases: Node[Sequence[StarNamedExpression]]

TYPE_ = Name(value='hydra.python.syntax.Tuple')

class hydra.python.syntax.TypeAlias(name: 'Name', type_params: 'Sequence[TypeParameter]', expression: 'Expression')

Bases: object

class Builder(_name: 'Name' = None, _type_params: 'Sequence[TypeParameter]' = None, _expression: 'Expression' = None)

Bases: object

build()

expression(expression)

name(name)

type_params(type_params)

EXPRESSION = Name(value='expression')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.python.syntax.TypeAlias')

TYPE_PARAMS = Name(value='typeParams')

static builder()

expression: Expression

name: Name

type_params: Sequence[TypeParameter]

with_expression(expression)

with_name(name)

with_type_params(type_params)

class hydra.python.syntax.TypeComment(value: T)

Bases: Node[str]

TYPE_ = Name(value='hydra.python.syntax.TypeComment')

class hydra.python.syntax.TypeExpression

Bases: object

TypeExpressionExpression | TypeExpressionStarredExpression | TypeExpressionDoubleStarredExpression

DOUBLE_STARRED_EXPRESSION = Name(value='doubleStarredExpression')

EXPRESSION = Name(value='expression')

STARRED_EXPRESSION = Name(value='starredExpression')

TYPE_ = Name(value='hydra.python.syntax.TypeExpression')

class hydra.python.syntax.TypeExpressionDoubleStarredExpression(value: T)

Bases: Node[Expression]

class hydra.python.syntax.TypeExpressionExpression(value: T)

Bases: Node[Expression]

class hydra.python.syntax.TypeExpressionStarredExpression(value: T)

Bases: Node[Expression]

class hydra.python.syntax.TypeParameter

Bases: object

TypeParameterSimple | TypeParameterStar | TypeParameterDoubleStar

DOUBLE_STAR = Name(value='doubleStar')

SIMPLE = Name(value='simple')

STAR = Name(value='star')

TYPE_ = Name(value='hydra.python.syntax.TypeParameter')

class hydra.python.syntax.TypeParameterDoubleStar(value: T)

Bases: Node[DoubleStarTypeParameter]

class hydra.python.syntax.TypeParameterSimple(value: T)

Bases: Node[SimpleTypeParameter]

class hydra.python.syntax.TypeParameterStar(value: T)

Bases: Node[StarTypeParameter]

class hydra.python.syntax.TypedAssignment(lhs: 'SingleTarget', type: 'Expression', rhs: 'Optional[AnnotatedRhs]')

Bases: object

class Builder(_lhs: 'SingleTarget' = None, _type: 'Expression' = None, _rhs: 'Optional[AnnotatedRhs]' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

type(type)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.python.syntax.TypedAssignment')

static builder()

lhs: SingleTarget

rhs: object

type: Expression

with_lhs(lhs)

with_rhs(rhs)

with_type(type)

class hydra.python.syntax.UntypedAssignment(targets: 'Sequence[StarTarget]', rhs: 'AnnotatedRhs', type_comment: 'Optional[TypeComment]')

Bases: object

class Builder(_targets: 'Sequence[StarTarget]' = None, _rhs: 'AnnotatedRhs' = None, _type_comment: 'Optional[TypeComment]' = None)

Bases: object

build()

rhs(rhs)

targets(targets)

type_comment(type_comment)

RHS = Name(value='rhs')

TARGETS = Name(value='targets')

TYPE_ = Name(value='hydra.python.syntax.UntypedAssignment')

TYPE_COMMENT = Name(value='typeComment')

static builder()

rhs: AnnotatedRhs

targets: Sequence[StarTarget]

type_comment: object

with_rhs(rhs)

with_targets(targets)

with_type_comment(type_comment)

class hydra.python.syntax.ValuePattern(value: T)

Bases: Node[Attribute]

TYPE_ = Name(value='hydra.python.syntax.ValuePattern')

class hydra.python.syntax.WhileStatement(condition: 'NamedExpression', body: 'Block', else_: 'Optional[Block]')

Bases: object

BODY = Name(value='body')

class Builder(_condition: 'NamedExpression' = None, _body: 'Block' = None, _else_: 'Optional[Block]' = None)

Bases: object

body(body)

build()

condition(condition)

else_(else_)

CONDITION = Name(value='condition')

ELSE = Name(value='else')

TYPE_ = Name(value='hydra.python.syntax.WhileStatement')

body: Block

static builder()

condition: NamedExpression

else_: object

with_body(body)

with_condition(condition)

with_else_(else_)

class hydra.python.syntax.WithItem(expression: 'Expression', as_: 'Optional[StarTarget]')

Bases: object

AS = Name(value='as')

class Builder(_expression: 'Expression' = None, _as_: 'Optional[StarTarget]' = None)

Bases: object

as_(as_)

build()

expression(expression)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.python.syntax.WithItem')

as_: object

static builder()

expression: Expression

with_as_(as_)

with_expression(expression)

class hydra.python.syntax.WithStatement(async_: 'bool', items: 'Sequence[WithItem]', type_comment: 'Optional[TypeComment]', body: 'Block')

Bases: object

ASYNC = Name(value='async')

BODY = Name(value='body')

class Builder(_async_: 'bool' = None, _items: 'Sequence[WithItem]' = None, _type_comment: 'Optional[TypeComment]' = None, _body: 'Block' = None)

Bases: object

async_(async_)

body(body)

build()

items(items)

type_comment(type_comment)

ITEMS = Name(value='items')

TYPE_ = Name(value='hydra.python.syntax.WithStatement')

TYPE_COMMENT = Name(value='typeComment')

async_: bool

body: Block

static builder()

items: Sequence[WithItem]

type_comment: object

with_async_(async_)

with_body(body)

with_items(items)

with_type_comment(type_comment)

class hydra.python.syntax.YieldExpression

Bases: object

YieldExpressionFrom | YieldExpressionSimple

FROM = Name(value='from')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.python.syntax.YieldExpression')

class hydra.python.syntax.YieldExpressionFrom(value: T)

Bases: Node[Expression]

class hydra.python.syntax.YieldExpressionSimple(value: T)

Bases: Node[Sequence[StarExpression]]

class hydra.python.syntax.YieldStatement(value: T)

Bases: Node[YieldExpression]

TYPE_ = Name(value='hydra.python.syntax.YieldStatement')