# AUTOGENERATED FROM grammars/src/MagicPython.syntax.yaml

name: "MagicPython"

scopeName: "source.python"

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:

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?"

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":