---

name: MagicPython

scopeName: source.python

# NOTE: remember to update package.json with VSCode file types.

fileTypes: [py, py3, rpy, pyw, cpy, pyi,

SConstruct, Sconstruct, sconstruct, SConscript,

gyp, gypi, wsgi, kv, Snakefile, smk, tac]

firstLineMatch: ^#![ \t]*/.*\bpython[\d\.]*\b

uuid: 742deb57-6e38-4192-bed6-410746efd85d

patterns:

- include: '#statement'

- include: '#expression'

repository:

$apply:

- file: 'regexp-common.inc.syntax.yaml'

- file: 'comment.inc.syntax.yaml'

vars:

suffix: '-base'

marker: ""

- file: 'comment.inc.syntax.yaml'

vars:

suffix: '-string-single-three'

marker: "|(?=''')"

- file: 'comment.inc.syntax.yaml'

vars:

suffix: '-string-double-three'

marker: '|(?=""")'

- file: 'regexp.inc.syntax.yaml'

vars:

prefix: 'single-one-'

basename: 'regexp'

marker: "|(?=\\')"

nested: ''

guard: "|((?=(?<!\\\\)\\n))"

- file: 'regexp.inc.syntax.yaml'

vars:

prefix: 'single-three-'

basename: 'regexp'

marker: "|(?=\\'\\'\\')"

nested: "- include: '#comments-string-single-three'"

guard: ""

- file: 'regexp.inc.syntax.yaml'

vars:

prefix: 'double-one-'

basename: 'regexp'

marker: '|(?=")'

nested: ''

guard: "|((?=(?<!\\\\)\\n))"

- file: 'regexp.inc.syntax.yaml'

vars:

prefix: 'double-three-'

basename: 'regexp'

marker: '|(?=""")'

nested: "- include: '#comments-string-double-three'"

guard: ""

- file: 'regexp.wrapper.syntax.yaml'

vars:

scopename: string.regexp.quoted.single.python

prefix: 'single-one-'

basename: 'regexp'

nested: ''

modifier: '[bB]'

bquote: "(\\')"

equote: "(\\')|(?<!\\\\)(\\n)"

- file: 'regexp.wrapper.syntax.yaml'

vars:

scopename: string.regexp.quoted.multi.python

prefix: 'single-three-'

basename: 'regexp'

nested: "- include: '#comments-string-single-three'"

modifier: '[bB]'

bquote: "(\\'\\'\\')"

equote: "(\\'\\'\\')"

- file: 'regexp.wrapper.syntax.yaml'

vars:

scopename: string.regexp.quoted.single.python

prefix: 'double-one-'

basename: 'regexp'

nested: ''

modifier: '[bB]'

bquote: '(")'

equote: '(")|(?<!\\)(\n)'

- file: 'regexp.wrapper.syntax.yaml'

vars:

scopename: string.regexp.quoted.multi.python

prefix: 'double-three-'

basename: 'regexp'

nested: "- include: '#comments-string-double-three'"

modifier: '[bB]'

bquote: '(""")'

equote: '(""")'

- file: 'pystring.inc.syntax.yaml'

vars:

line: single

marker: (['"])

guard: "|((?<!\\\\)\\n)"

- file: 'pystring.inc.syntax.yaml'

vars:

line: multi

marker: "'''|\"\"\""

guard: ""

- file: 'pyfstring.inc.syntax.yaml'

vars:

line: single

marker: (['"])

fguard: "|(?=\\n)"

guard: "|((?<!\\\\)\\n)"

- file: 'pyfstring.inc.syntax.yaml'

vars:

line: multi

marker: "'''|\"\"\""

fguard: ""

guard: ""

impossible:

comment: This is a special rule that should be used where no match

is desired. It is not a good idea to match something like

'1{0}' because in some cases that can result in infinite

loops in token generation. So the rule instead matches

and impossible expression to allow a match to fail and

move to the next token.

match: '$.^'

statement:

patterns:

- include: '#import'

- include: '#class-declaration'

- include: '#function-declaration'

- include: '#generator'

- include: '#statement-keyword'

- include: '#assignment-operator'

- include: '#decorator'

- include: '#docstring-statement'

- include: '#semicolon'

semicolon:

patterns:

- name: invalid.deprecated.semicolon.python

match: '\;$'

comments:

patterns:

- name: comment.line.number-sign.python

contentName: meta.typehint.comment.python

begin: |

(?x)

(?:

\# \s* (type:)

\s*+ (?# we want `\s*+` which is possessive quantifier since

we do not actually want to backtrack when matching

whitespace here)

(?! $ | \#)

)

end: (?:$|(?=\#))

beginCaptures:

'0': {name: meta.typehint.comment.python}

'1': {name: comment.typehint.directive.notation.python}

patterns:

- name: comment.typehint.ignore.notation.python

match: |

(?x)

\G ignore

(?= \s* (?: $ | \#))

- name: comment.typehint.type.notation.python

match: |

(?x)

(?<!\.)\b(

bool | bytes | float | int | object | str

| List | Dict | Iterable | Sequence | Set

| FrozenSet | Callable | Union | Tuple

| Any | None

)\b

- name: comment.typehint.punctuation.notation.python

match: ([\[\]\(\),\.\=\*]|(->))

- name: comment.typehint.variable.notation.python

match: ([[:alpha:]_]\w*)

- include: '#comments-base'

docstring-statement:

begin: ^(?=\s*[rR]?(\'\'\'|\"\"\"|\'|\"))

comment: the string either terminates correctly or by the

beginning of a new line (this is for single line

docstrings that aren't terminated) AND it's not followed

by another docstring

end: ((?<=\1)|^)(?!\s*[rR]?(\'\'\'|\"\"\"|\'|\"))

patterns:

- include: '#docstring'

docstring:

patterns:

- name: string.quoted.docstring.multi.python

begin: (\'\'\'|\"\"\")

end: (\1)

beginCaptures:

'1': {name: punctuation.definition.string.begin.python}

endCaptures:

'1': {name: punctuation.definition.string.end.python}

patterns:

- include: '#docstring-prompt'

- include: '#codetags'

- include: '#docstring-guts-unicode'

- name: string.quoted.docstring.raw.multi.python

begin: ([rR])(\'\'\'|\"\"\")

end: (\2)

beginCaptures:

'1': {name: storage.type.string.python}

'2': {name: punctuation.definition.string.begin.python}

endCaptures:

'1': {name: punctuation.definition.string.end.python}

patterns:

- include: '#string-consume-escape'

- include: '#docstring-prompt'

- include: '#codetags'

- name: string.quoted.docstring.single.python

begin: (\'|\")

end: (\1)|(\n)

beginCaptures:

'1': {name: punctuation.definition.string.begin.python}

endCaptures:

'1': {name: punctuation.definition.string.end.python}

'2': {name: invalid.illegal.newline.python}

patterns:

- include: '#codetags'

- include: '#docstring-guts-unicode'

- name: string.quoted.docstring.raw.single.python

begin: ([rR])(\'|\")

end: (\2)|(\n)

beginCaptures:

'1': {name: storage.type.string.python}

'2': {name: punctuation.definition.string.begin.python}

endCaptures:

'1': {name: punctuation.definition.string.end.python}

'2': {name: invalid.illegal.newline.python}

patterns:

- include: '#string-consume-escape'

- include: '#codetags'

docstring-guts-unicode:

patterns:

- include: '#escape-sequence-unicode'

- include: '#escape-sequence'

- include: '#string-line-continuation'

docstring-prompt:

match: |

(?x)

(?:

(?:^|\G) \s* (?# '\G' is necessary for ST)

((?:>>>|\.\.\.) \s) (?=\s*\S)

)

captures:

'1': {name: keyword.control.flow.python}

statement-keyword:

patterns:

- name: storage.type.function.python

match: \b((async\s+)?\s*def)\b

- name: keyword.control.flow.python

comment: |

if `as` is eventually followed by `:` or line continuation

it's probably control flow like:

with foo as bar, \

Foo as Bar:

try:

do_stuff()

except Exception as e:

pass

match: \b(?<!\.)as\b(?=.*[:\\])

- name: keyword.control.import.python

comment: other legal use of `as` is in an import

match: \b(?<!\.)as\b

- name: keyword.control.flow.python

match: |

(?x)

\b(?<!\.)(

async | continue | del | assert | break | finally | for

| from | elif | else | if | except | pass | raise

| return | try | while | with

)\b

- name: storage.modifier.declaration.python

match: |

(?x)

\b(?<!\.)(

global | nonlocal

)\b

- name: storage.type.class.python

match: \b(?<!\.)(class)\b

- match: |

(?x)

^\s*(

case | match

)(?=\s*([-+\w\d(\[{'":#]|$))\b

captures:

'1': {name: keyword.control.flow.python}

expression-bare:

comment: valid Python expressions w/o comments and line continuation

patterns:

- include: '#backticks'

- include: '#illegal-anno'

- include: '#literal'

- include: '#regexp'

- include: '#string'

- include: '#lambda'

- include: '#generator'

- include: '#illegal-operator'

- include: '#operator'

- include: '#curly-braces'

- include: '#item-access'

- include: '#list'

- include: '#odd-function-call'

- include: '#round-braces'

- include: '#function-call'

- include: '#builtin-functions'

- include: '#builtin-types'

- include: '#builtin-exceptions'

- include: '#magic-names'

- include: '#special-names'

- include: '#illegal-names'

- include: '#special-variables'

- include: '#ellipsis'

- include: '#punctuation'

- include: '#line-continuation'

expression-base:

comment: valid Python expressions with comments and line continuation

patterns:

- include: '#comments'

- include: '#expression-bare'

- include: '#line-continuation'

expression:

comment: All valid Python expressions

patterns:

- include: '#expression-base'

- include: '#member-access'

- comment: Tokenize identifiers to help linters

match: (?x) \b ([[:alpha:]_]\w*) \b

member-access:

name: meta.member.access.python

begin: (\.)\s*(?!\.)

end: |

(?x)

# stop when you've just read non-whitespace followed by non-word

# i.e. when finished reading an identifier or function call

(?<=\S)(?=\W) |

# stop when seeing the start of something that's not a word,

# i.e. when seeing a non-identifier

(^|(?<=\s))(?=[^\\\w\s]) |

$

beginCaptures:

'1': {name: punctuation.separator.period.python}

patterns:

- include: '#function-call'

- include: '#member-access-base'

- include: '#member-access-attribute'

member-access-base:

patterns:

- include: '#magic-names'

- include: '#illegal-names'

- include: '#illegal-object-name'

- include: '#special-names'

- include: '#line-continuation'

- include: '#item-access'

member-access-attribute:

comment: Highlight attribute access in otherwise non-specialized cases.

name: meta.attribute.python

match: |

(?x)

\b ([[:alpha:]_]\w*) \b

special-names:

name: constant.other.caps.python

match: |

(?x)

\b

# we want to see "enough", meaning 2 or more upper-case

# letters in the beginning of the constant

#

# for more details refer to:

# https://github.com/MagicStack/MagicPython/issues/42

(

_* [[:upper:]] [_\d]* [[:upper:]]

)

[[:upper:]\d]* (_\w*)?

\b

curly-braces:

begin: \{

end: \}

beginCaptures:

'0': {name: punctuation.definition.dict.begin.python}

endCaptures:

'0': {name: punctuation.definition.dict.end.python}

patterns:

- name: punctuation.separator.dict.python

match: ":"

- include: '#expression'

list:

begin: \[

end: \]

beginCaptures:

'0': {name: punctuation.definition.list.begin.python}

endCaptures:

'0': {name: punctuation.definition.list.end.python}

patterns:

- include: '#expression'

odd-function-call:

comment: |

A bit obscured function call where there may have been an

arbitrary number of other operations to get the function.

E.g. "arr[idx](args)"

begin: |

(?x)

(?<= \] | \) ) \s*

(?=\()

end: (\))

endCaptures:

'1': {name: punctuation.definition.arguments.end.python}

patterns:

- include: '#function-arguments'

round-braces:

begin: \(

end: \)

beginCaptures:

'0': {name: punctuation.parenthesis.begin.python}

endCaptures:

'0': {name: punctuation.parenthesis.end.python}

patterns:

- include: '#expression'

line-continuation:

patterns:

- match: '(\\)\s*(\S.*$\n?)'

captures:

'1': {name: punctuation.separator.continuation.line.python}

'2': {name: invalid.illegal.line.continuation.python}

- begin: '(\\)\s*$\n?'

# Line continuation matching ends on anything that is not a

# potential docstring. For docstring-like strings we explicitly

# match regexp and string.

end: |

(?x)

(?=^\s*$)

|

(?! (\s* [rR]? (\'\'\'|\"\"\"|\'|\"))

|

(\G $) (?# '\G' is necessary for ST)

)

beginCaptures:

'1': {name: punctuation.separator.continuation.line.python}

patterns:

- include: '#regexp'

- include: '#string'

assignment-operator:

name: keyword.operator.assignment.python

match: |

(?x)

<<= | >>= | //= | \*\*=

| \+= | -= | /= | @=

| \*= | %= | ~= | \^= | &= | \|=

| =(?!=)

operator:

match: |

(?x)

\b(?<!\.)

(?:

(and | or | not | in | is) (?# 1)

|

(for | if | else | await | (?:yield(?:\s+from)?)) (?# 2)

)

(?!\s*:)\b

| (<< | >> | & | \| | \^ | ~) (?# 3)

| (\*\* | \* | \+ | - | % | // | / | @) (?# 4)

| (!= | == | >= | <= | < | >) (?# 5)

| (:=) (?# 6)

captures:

'1': {name: keyword.operator.logical.python}

'2': {name: keyword.control.flow.python}

'3': {name: keyword.operator.bitwise.python}

'4': {name: keyword.operator.arithmetic.python}

'5': {name: keyword.operator.comparison.python}

'6': {name: keyword.operator.assignment.python}

punctuation:

patterns:

- name: punctuation.separator.colon.python

match: ":"

- name: punctuation.separator.element.python

match: ","

literal:

patterns:

- name: constant.language.python

match: \b(True|False|None|NotImplemented|Ellipsis)\b

- include: '#number'

number:

name: constant.numeric.python

patterns:

- include: '#number-float'

- include: '#number-dec'

- include: '#number-hex'

- include: '#number-oct'

- include: '#number-bin'

- include: '#number-long'

- name: invalid.illegal.name.python

match: \b[0-9]+\w+

number-float:

name: constant.numeric.float.python

match: |

(?x)

(?<! \w)(?:

(?:

\.[0-9](?: _?[0-9] )*

|

[0-9](?: _?[0-9] )* \. [0-9](?: _?[0-9] )*

|

[0-9](?: _?[0-9] )* \.

) (?: [eE][+-]?[0-9](?: _?[0-9] )* )?

|

[0-9](?: _?[0-9] )* (?: [eE][+-]?[0-9](?: _?[0-9] )* )

)([jJ])?\b

captures:

'1': {name: storage.type.imaginary.number.python}

number-dec:

name: constant.numeric.dec.python

match: |

(?x)

(?<![\w\.])(?:

[1-9](?: _?[0-9] )*

|

0+

|

[0-9](?: _?[0-9] )* ([jJ])

|

0 ([0-9]+)(?![eE\.])

)\b

captures:

'1': {name: storage.type.imaginary.number.python}

'2': {name: invalid.illegal.dec.python}

number-hex:

name: constant.numeric.hex.python

match: |

(?x)

(?<![\w\.])

(0[xX]) (_?[0-9a-fA-F])+

\b

captures:

'1': {name: storage.type.number.python}

number-oct:

name: constant.numeric.oct.python

match: |

(?x)

(?<![\w\.])

(0[oO]) (_?[0-7])+

\b

captures:

'1': {name: storage.type.number.python}

number-bin:

name: constant.numeric.bin.python

match: |

(?x)

(?<![\w\.])

(0[bB]) (_?[01])+

\b

captures:

'1': {name: storage.type.number.python}

number-long:

name: constant.numeric.bin.python

comment: this is to support python2 syntax for long ints

match: |

(?x)

(?<![\w\.])

([1-9][0-9]* | 0) ([lL])

\b

captures:

'2': {name: storage.type.number.python}

regexp:

patterns:

- include: '#regexp-single-three-line'

- include: '#regexp-double-three-line'

- include: '#regexp-single-one-line'

- include: '#regexp-double-one-line'

string:

patterns:

- include: '#string-quoted-multi-line'

- include: '#string-quoted-single-line'

- include: '#string-bin-quoted-multi-line'

- include: '#string-bin-quoted-single-line'

- include: '#string-raw-quoted-multi-line'

- include: '#string-raw-quoted-single-line'

- include: '#string-raw-bin-quoted-multi-line'

- include: '#string-raw-bin-quoted-single-line'

- include: '#fstring-fnorm-quoted-multi-line'

- include: '#fstring-fnorm-quoted-single-line'

- include: '#fstring-normf-quoted-multi-line'

- include: '#fstring-normf-quoted-single-line'

- include: '#fstring-raw-quoted-multi-line'

- include: '#fstring-raw-quoted-single-line'

string-unicode-guts:

patterns:

- include: '#escape-sequence-unicode'

- include: '#string-entity'

- include: '#string-brace-formatting'

string-consume-escape:

match: \\['"\n\\]

string-raw-guts:

patterns:

- include: '#string-consume-escape'

- include: '#string-formatting'

- include: '#string-brace-formatting'

string-raw-bin-guts:

patterns:

- include: '#string-consume-escape'

- include: '#string-formatting'

string-entity:

patterns:

- include: '#escape-sequence'

- include: '#string-line-continuation'

- include: '#string-formatting'

fstring-guts:

patterns:

- include: '#escape-sequence-unicode'

- include: '#escape-sequence'

- include: '#string-line-continuation'

- include: '#fstring-formatting'

fstring-raw-guts:

patterns:

- include: '#string-consume-escape'

- include: '#fstring-formatting'

fstring-illegal-single-brace:

comment: it is illegal to have a multiline brace inside a single-line

string

begin: (\{)(?=[^\n}]*$\n?)

end: (\})|(?=\n)

beginCaptures:

'1': {name: constant.character.format.placeholder.other.python}

endCaptures:

'1': {name: constant.character.format.placeholder.other.python}

patterns:

- include: '#fstring-terminator-single'

- include: '#f-expression'

fstring-illegal-multi-brace:

patterns:

- include: '#impossible'

f-expression:

comment: All valid Python expressions, except comments and line continuation

patterns:

- include: '#expression-bare'

- include: '#member-access'

- comment: Tokenize identifiers to help linters

match: (?x) \b ([[:alpha:]_]\w*) \b

escape-sequence-unicode:

patterns:

- name: constant.character.escape.python

match: |

(?x)

\\ (

u[0-9A-Fa-f]{4}

| U[0-9A-Fa-f]{8}

| N\{[\w\s]+?\}

)

escape-sequence:

name: constant.character.escape.python

match: |

(?x)

\\ (

x[0-9A-Fa-f]{2}

| [0-7]{1,3}

| [\\"'abfnrtv]

)

string-line-continuation:

name: constant.language.python

match: \\$

string-formatting:

name: meta.format.percent.python

match: |

(?x)

(

% (\([\w\s]*\))?

[-+#0 ]*

(\d+|\*)? (\.(\d+|\*))?

([hlL])?

[diouxXeEfFgGcrsab%]

)

captures:

'1': {name: constant.character.format.placeholder.other.python}

string-brace-formatting:

patterns:

- name: meta.format.brace.python

match: |

(?x)

(

{{ | }}

| (?:

{

\w* (\.[[:alpha:]_]\w* | \[[^\]'"]+\])*

(![rsa])?

( : \w? [<>=^]? [-+ ]? \#?

\d* ,? (\.\d+)? [bcdeEfFgGnosxX%]? )?

})

)

captures:

# We use this awkward scope name instead of perhaps more

# elegant "support.other.format.python" because it appears

# that by default it gives a better visual result in various

# systems (e.g. GitHub). This is due to the fact that

# "storage.type..." is more likely to have special

# highlighting in any given color scheme than

# "support.other..."

'1': {name: constant.character.format.placeholder.other.python}

'3': {name: storage.type.format.python}

'4': {name: storage.type.format.python}

# The reason for 2 separate rules is to establish which one

# should be matched with a higher priority. The rule below is

# more generic, so it should be matched only if the specific one

# didn't.

- name: meta.format.brace.python

match: |

(?x)

(

{

\w* (\.[[:alpha:]_]\w* | \[[^\]'"]+\])*

(![rsa])?

(:)

[^'"{}\n]* (?:

\{ [^'"}\n]*? \} [^'"{}\n]*

)*

}

)

captures:

'1': {name: constant.character.format.placeholder.other.python}

'3': {name: storage.type.format.python}

'4': {name: storage.type.format.python}

fstring-formatting:

patterns:

- include: '#fstring-formatting-braces'

- include: '#fstring-formatting-singe-brace'

fstring-formatting-singe-brace:

name: invalid.illegal.brace.python

match: (}(?!}))

import:

comment: |

Import statements used to correctly mark `from`, `import`, and `as`

patterns:

- begin: \b(?<!\.)(from)\b(?=.+import)

end: $|(?=import)

beginCaptures:

'1': {name: keyword.control.import.python}

patterns:

- name: punctuation.separator.period.python

match: \.+

- include: '#expression'

- begin: \b(?<!\.)(import)\b

end: $

beginCaptures:

'1': {name: keyword.control.import.python}

patterns:

- name: keyword.control.import.python

match: \b(?<!\.)as\b

- include: '#expression'

class-declaration:

patterns:

- name: meta.class.python

begin: |

(?x)

\s*(class)\s+

(?=

[[:alpha:]_]\w* \s* (:|\()

)

end: (:)

beginCaptures:

'1': {name: storage.type.class.python}

endCaptures:

'1': {name: punctuation.section.class.begin.python}

patterns:

- include: '#class-name'

- include: '#class-inheritance'

class-name:

patterns:

- include: '#illegal-object-name'

- include: '#builtin-possible-callables'

- name: entity.name.type.class.python

match: |

(?x)

\b ([[:alpha:]_]\w*) \b

class-inheritance:

name: meta.class.inheritance.python

begin: (\()

end: (\))

beginCaptures:

'1': {name: punctuation.definition.inheritance.begin.python}

endCaptures:

'1': {name: punctuation.definition.inheritance.end.python}

patterns:

- name: keyword.operator.unpacking.arguments.python

match: (\*\*|\*)

- name: punctuation.separator.inheritance.python

match: ','

- name: keyword.operator.assignment.python

match: =(?!=)

- name: support.type.metaclass.python

match: \bmetaclass\b

- include: '#illegal-names'

- include: '#class-kwarg'

- include: '#call-wrapper-inheritance'

- include: '#expression-base'

- include: '#member-access-class'

- include: '#inheritance-identifier'

class-kwarg:

match: |

(?x)

\b ([[:alpha:]_]\w*) \s*(=)(?!=)

captures:

# "variable.parameter.class.python" scope is more important

# and hence we specify it first to highlight class parameters

# as kwargs in Atom/VSCode/GH.

'1': {name: variable.parameter.class.python

entity.other.inherited-class.python}

'2': {name: keyword.operator.assignment.python}

inheritance-identifier:

match: |

(?x)

\b ([[:alpha:]_]\w*) \b

captures:

'1': {name: entity.other.inherited-class.python}

member-access-class:

name: meta.member.access.python

begin: (\.)\s*(?!\.)

end: (?<=\S)(?=\W)|$

beginCaptures:

'1': {name: punctuation.separator.period.python}

patterns:

- include: '#call-wrapper-inheritance'

- include: '#member-access-base'

- include: '#inheritance-identifier'

lambda:

patterns:

- match: ((?<=\.)lambda|lambda(?=\s*[\.=]))

captures:

'1': {name: keyword.control.flow.python}

- match: \b(lambda)\s*?(?=[,\n]|$)

captures:

'1': {name: storage.type.function.lambda.python}

- name: meta.lambda-function.python

begin: |

(?x)

\b (lambda) \b

end: (:)|(\n)

beginCaptures:

'1': {name: storage.type.function.lambda.python}

endCaptures:

'1': {name: punctuation.section.function.lambda.begin.python}

contentName: meta.function.lambda.parameters.python

patterns:

- name: keyword.operator.positional.parameter.python

match: /

- name: keyword.operator.unpacking.parameter.python

match: (\*\*|\*)

- include: '#lambda-nested-incomplete'

- include: '#illegal-names'

- match: ([[:alpha:]_]\w*)\s*(?:(,)|(?=:|$))

captures:

'1': {name: variable.parameter.function.language.python}

'2': {name: punctuation.separator.parameters.python}

- include: '#comments'

- include: '#backticks'

- include: '#illegal-anno'

- include: '#lambda-parameter-with-default'

- include: '#line-continuation'

- include: '#illegal-operator'

lambda-incomplete:

name: storage.type.function.lambda.python

match: \blambda(?=\s*[,)])

lambda-nested-incomplete:

name: storage.type.function.lambda.python

match: \blambda(?=\s*[:,)])

lambda-parameter-with-default:

begin: |

(?x)

\b

([[:alpha:]_]\w*) \s* (=)

end: (,)|(?=:|$)

beginCaptures:

'1': {name: variable.parameter.function.language.python}

'2': {name: keyword.operator.python}

endCaptures:

'1': {name: punctuation.separator.parameters.python}

patterns:

- include: '#expression'

generator:

comment: |

Match "for ... in" construct used in generators and for loops to

correctly identify the "in" as a control flow keyword.

begin: \bfor\b

beginCaptures:

'0': {name: keyword.control.flow.python}

end: \bin\b

endCaptures:

'0': {name: keyword.control.flow.python}

patterns:

- include: '#expression'

function-declaration:

name: meta.function.python

begin: |

(?x)

\s*

(?:\b(async) \s+)? \b(def)\s+

(?=

[[:alpha:]_][[:word:]]* \s* \(

)

end: (:|(?=[#'"\n]))

beginCaptures:

'1': {name: storage.type.function.async.python}