PythonImproved.YAML-tmLanguage

# [PackageDev] target_format: plist, ext: tmLanguage
comment: To make PythonImproved your default Python syntax, open a .py file and select
  View|Syntax|Open all with current extension as...|PythonImproved.
name: PythonImproved
scopeName: source.python
fileTypes: [py, py3, rpy, pyw, cpy, SConstruct, Sconstruct, sconstruct, SConscript]
uuid: 11B0273F-0284-4483-B17B-4B8D0A9294CC

patterns:
- name: support.type.ellipsis.python
  match: (?<!^from\s|^import\s)(\b\.{3}\b)

- name: support.ipython.in.python
  match: (^In \[(\d+)\]\:)
  captures:
    '2': {name: support.ipython.cell-number.python}

- name: support.ipython.out.python
  match: (^Out\[(\d+)\]\:)
  captures:
    '2': {name: support.ipython.cell-number.python}

- include: '#comments'

- comment: Match identifiers in ALL_CAPS as constants, except when followed by `.`, `(`, `'`, or `"`.
  name: constant.other.allcaps.python
  match: \b([[:upper:]_][[:upper:][:digit:]_]*)\b(?![\.\(\'\"])

- name: constant.numeric.integer.hexadecimal.long.python
  match: \b(?i:(0x\h+)L)

- name: constant.numeric.integer.hexadecimal.python
  match: \b(?i:(0x\h+))

- name: constant.numeric.integer.binary.long.python
  match: \b(?i:(0b[01]+)L)

- name: constant.numeric.integer.binary.python
  match: \b(?i:(0b[01]+))

- name: constant.numeric.integer.octal.long.python
  match: \b(?i:(0[o]?[0-7]+)L)

- name: constant.numeric.integer.octal.python
  match: \b(?i:(0[o]?[0-7]+))

- comment: Not quite perfect...
  name: constant.numeric.complex.python
  match: \b(?i:(((\d+(\.(?=[^[:alpha:]_])\d*)?|(?<=[^[:alnum:]_])\.\d+)(e[\-\+]?\d+)?))J)

- comment: Ummm... why do we have three of these? This is one...
  name: constant.numeric.float.python
  match: \b(?i:(\d+\.\d*(e[\-\+]?\d+)?))(?=[^[:alpha:]_])

- comment: This is two...
  name: constant.numeric.float.python
  match: (?<=[^[:alnum:]_])(?i:(\.\d+(e[\-\+]?\d+)?))

- comment: And this is three...
  name: constant.numeric.float.python
  match: \b(?i:(\d+e[\-\+]?\d+))

- name: constant.numeric.integer.decimal.long.python
  match: \b(?i:([1-9]+[0-9]*|0)L)

- name: constant.numeric.integer.decimal.python
  match: \b([1-9]+[0-9]*|0)

- name: constant.language.python
  match: \b(None|True|False|Ellipsis|NotImplemented)\b

- name: storage.modifier.declaration.python
  match: \b(global|nonlocal)\b

- name: keyword.control.import.python
  match: \b(?:(import|from|as))\b

- comment: keyword operators that evaluate to True or False
  name: keyword.operator.logical.python
  match: \b(and|in|is|not|or)\b

- comment: keywords that do not fit into other groups.
  name: keyword.other.python
  match: \b(assert|del)\b

- name: invalid.deprecated.operator.python
  match: <>

- name: invalid.deprecated.function.python
  match: (?<!\.)(apply|buffer|coerce|intern)\s*(?=\()

- name: keyword.operator.comparison.python
  match: <\=|>\=|\=\=|<|>|\!\=

- name: keyword.operator.assignment.augmented.python
  match: \+\=|-\=|\*\=|/\=|//\=|%\=|&\=|\|\=|\^\=|>>\=|<<\=|\*\*\=|@\=

- name: keyword.operator.arithmetic.python
  match: \+|\-|\*|\*\*|/|//|%|<<|>>|&|\||\^|~|(?!^)@

- name: keyword.operator.assignment.python
  match: \=

- name: meta.class.old-style.python
  contentName: entity.name.type.class.python
  begin: \s*(class)\s+(?=[[:alpha:]_][[:alnum:]_]*\s*\:)
  beginCaptures:
    '1': {name: storage.type.class.python}
  end: \s*(:)
  endCaptures:
    '1': {name: punctuation.section.class.begin.python}
  patterns:
  - include: '#entity_name_class'

- name: meta.class.python
  begin: \s*(class)\s+(?=[[:alpha:]_][[:alnum:]_]*\s*\()
  beginCaptures:
    '1': {name: storage.type.class.python}
  end: (\))\s*(?:(\:)|(.*$\n?))
  endCaptures:
    '1': {name: punctuation.definition.inheritance.end.python}
    '2': {name: punctuation.section.class.begin.python}
    '3': {name: invalid.illegal.missing-section-begin.python}
  patterns:
  - contentName: entity.name.type.class.python
    begin: (?=[[:alpha:]_][[:alnum:]_]*)
    end: (?![[:alnum:]_])
    patterns:
    - include: '#entity_name_class'
  - contentName: meta.class.inheritance.python
    begin: (\()
    beginCaptures:
      '1': {name: punctuation.definition.inheritance.begin.python}
    end: (?=\)|:)
    patterns:
    - contentName: entity.other.inherited-class.python
      begin: (?<=\(|,)\s*
      end: \s*(?:(,)|(?=\)))
      endCaptures:
        '1': {name: punctuation.separator.inheritance.python}
      patterns:
      - include: $self

- name: meta.class.python
  begin: \s*(class)\s+(?=[[:alpha:]_][[:alnum:]_]*)
  beginCaptures:
    '1': {name: storage.type.class.python}
  end: (\()|\s*($\n?|#.*$\n?)
  endCaptures:
    '1': {name: punctuation.definition.inheritance.begin.python}
    '2': {name: invalid.illegal.missing-inheritance.python}
  patterns:
  - contentName: entity.name.type.class.python
    begin: (?=[[:alpha:]_][[:alnum:]_]*)
    end: (?![[:alnum:]_])
    patterns:
    - include: '#entity_name_function'

- name: meta.function.python
  begin: \s*(?:(async)\s+)?(def)\s+(?=[[:alpha:]_][[:alnum:]_]*\s*\()
  beginCaptures:
    '1': {name: storage.modifier.async.python}
    '2': {name: storage.type.function.python}
  end: (\:)
  endCaptures:
    '1': {name: punctuation.section.function.begin.python}
  patterns:
  - contentName: entity.name.function.python
    begin: (?=[[:alpha:]_][[:alnum:]_]*)
    end: (?![[:alnum:]_])
    patterns:
    - include: '#entity_name_function'
  - contentName: meta.function.parameters.python
    begin: (\()
    beginCaptures:
      '1': {name: punctuation.definition.parameters.begin.python}
    end: (?=\)\s*(?:\:|-\>))
    patterns:
    - include: '#annotated_arguments'
    - include: '#keyword_arguments'
    - include: '#comments'
    - match: \b(?:(self|cls)|([[:alpha:]_][[:alnum:]_]*))\s*(?:(,)|(?=[\n\)]))
      captures:
        '1': {name: variable.parameter.function.language.python}
        '2': {name: variable.parameter.function.python}
        '3': {name: punctuation.separator.parameters.python}
  - begin: (\))\s*(\->)
    beginCaptures:
      '1': {name: punctuation.definition.parameters.end.python}
      '2': {name: punctuation.separator.annotation.result.python}
    end: (?=\:)
    patterns:
    - include: $self

- name: meta.function.python
  begin: \s*(?:(async)\s+)?(def)\s+(?=[[:alpha:]_][[:alnum:]_]*)
  beginCaptures:
    '1': {name: storage.modifier.async.python}
    '2': {name: storage.type.function.python}
  end: (\()|\s*($\n?|#.*$\n?)
  endCaptures:
    '1': {name: punctuation.definition.parameters.begin.python}
    '2': {name: invalid.illegal.missing-parameters.python}
  patterns:
  - contentName: entity.name.function.python
    begin: (?=[[:alpha:]_][[:alnum:]_]*)
    end: (?![[:alnum:]_])
    patterns:
    - include: '#entity_name_function'

- match: \b(?:(?:(async)\s+)?(def)|(lambda))\b
  captures:
    '1': {name: storage.modifier.async.python}
    '2': {name: storage.type.function.python}
    '3': {name: storage.type.function.inline.python}

- comment: 'Keywords that delimit flow blocks or alter flow from within a
    block. This block should be matched *after* meta.function.python to
    let `async def` be matched *first*.'
  name: keyword.control.flow.python
  match: |-
    (?x) \b(
      async | await | break | continue | elif | else | except | finally |
      for | if | pass | raise | return | try | while | with |
      (yield(?:\s+from)?)
    )\b

- name: meta.function.inline.python
  begin: (lambda)(?=\s+|:)
  beginCaptures:
    '1': {name: storage.type.function.inline.python}
  end: (\:)
  endCaptures:
    '1': {name: punctuation.definition.parameters.end.python}
    '2': {name: punctuation.section.function.begin.python}
    '3': {name: invalid.illegal.missing-section-begin.python}
  patterns:
  - contentName: meta.function.inline.parameters.python
    begin: \s+
    end: (?=\:)
    patterns:
    - include: '#keyword_arguments'
    - match: \b([[:alpha:]_][[:alnum:]_]*)\s*(?:(,)|(?=[\n\)\:]))
      captures:
        '1': {name: variable.parameter.function.python}
        '2': {name: punctuation.separator.parameters.python}

- comment: a decorator may be a function call which returns a decorator.
  name: meta.function.decorator.python
  begin: ^\s*(?=@\s*[[:alpha:]_][[:alnum:]_]*(?:\s*\.\s*[[:alpha:]_][[:alnum:]_]*)*\s*\()
  end: (?<=\))
  endCaptures:
    '1': {name: punctuation.definition.arguments.end.python}
  patterns:
  - contentName: entity.name.function.decorator.python
    begin: (?=(@)\s*[[:alpha:]_][[:alnum:]_]*(?:\s*\.\s*[[:alpha:]_][[:alnum:]_]*)*\s*\()
    beginCaptures:
      '1': {name: punctuation.definition.decorator.python}
    end: (?=\s*\()
    patterns:
    - include: '#dotted_name'
  - contentName: meta.function.decorator.arguments.python
    begin: (\()
    beginCaptures:
      '1': {name: punctuation.definition.arguments.begin.python}
    end: (?=(\)))
    endCaptures:
      '1': {name: punctuation.definition.arguments.end.python}
    patterns:
    - include: '#keyword_arguments'
    - include: $self

- name: meta.function.decorator.python
  contentName: entity.name.function.decorator.python
  begin: ^\s*(?=@\s*[[:alpha:]_][[:alnum:]_]*(?:\s*\.\s*[[:alpha:]_][[:alnum:]_]*)*)
  end: (?=\s|$\n?|#)
  patterns:
  - begin: (?=(@)\s*[[:alpha:]_][[:alnum:]_]*(\s*\.\s*[[:alpha:]_][[:alnum:]_]*)*)
    beginCaptures:
      '1': {name: punctuation.definition.decorator.python}
    end: (?=\s|$\n?|#)
    patterns:
    - include: '#dotted_name'

- name: meta.function-call.python
  contentName: meta.function-call.arguments.python
  begin: (?<=\)|\])\s*(\()
  beginCaptures:
    '1': {name: punctuation.definition.arguments.begin.python}
  end: (\))
  endCaptures:
    '1': {name: punctuation.definition.arguments.end.python}
  patterns:
  - include: '#keyword_arguments'
  - include: $self

- include: '#builtin_types'

- include: '#builtin_functions_name'

- include: '#builtin_functions_call'

- include: '#errors_warnings_exceptions'

- include: '#docstrings'

- include: '#magic_function_names'

- include: '#magic_function_calls'

- include: '#magic_variable_names'

- name: meta.function-call.python
  begin: \b(self|cls)\b\s*(?=(\())
  beginCaptures:
    '1': {name: variable.language.python}
    '2': {name: punctuation.definition.arguments.begin.python}
  end: (\))
  endCaptures:
    '1': {name: punctuation.definition.arguments.end.python}
  patterns:
  - contentName: meta.function-call.arguments.python
    begin: (\()
    beginCaptures:
      '1': {name: punctuation.definition.arguments.begin.python}
    end: (?=(\)))
    endCaptures:
      '1': {name: punctuation.definition.arguments.end.python}
    patterns:
    - include: '#keyword_arguments'
    - include: $self

# this needs to be here, or else cls() is a reg. function and self.foo is not highlighted
- include: '#language_variables'

- include: '#generic_object_names'

- name: meta.function-call.python
  begin: (?:\.)?([[:alpha:]_][[:alnum:]_]*)\s*(?=(\())
  beginCaptures:
    '1': {name: meta.function-call.generic.python}
    '2': {name: punctuation.definition.arguments.begin.python}
  end: (\))
  endCaptures:
    '1': {name: punctuation.definition.arguments.end.python}
  patterns:
  - begin: (?=[[:alpha:]_][[:alnum:]_]*(?:\.[[:alpha:]_][[:alnum:]_]*)*\s*\()
    end: (?=\s*\()
    patterns:
    - include: '#dotted_name'
  - contentName: meta.function-call.arguments.python
    begin: (\()
    beginCaptures:
      '1': {name: punctuation.definition.arguments.begin.python}
    end: (?=(\)))
    endCaptures:
      '1': {name: punctuation.definition.arguments.end.python}
    patterns:
    - include: '#keyword_arguments'
    - include: $self
  - begin: \G
    end: (?=\()
    patterns:
    - include: '#dotted_name'

- comment: Py2 print statement that should only be matched after function calls
  name: keyword.other.print.python
  match: (?<!\.)\b(print)(?=\s|$)

- name: meta.item-access.python
  begin: (?=[[:alpha:]_][[:alnum:]_]*(?:\s*\.\s*[[:alpha:]_][[:alnum:]_]*)*\s*\[)
  end: (\])
  endCaptures:
    '1': {name: punctuation.definition.arguments.end.python}
  patterns:
  - begin: (?=[[:alpha:]_][[:alnum:]_]*(?:\s*\.\s*[[:alpha:]_][[:alnum:]_]*)*\s*\[)
    end: (?=\s*\[)
    patterns:
    - include: '#dotted_name'
  - contentName: meta.item-access.arguments.python
    begin: (\[)
    beginCaptures:
      '1': {name: punctuation.definition.arguments.begin.python}
    end: (?=(\]))
    endCaptures:
      '1': {name: punctuation.definition.arguments.end.python}
    patterns:
    - include: $self
  - begin: \G
    end: (?=\[)
    patterns:
    - include: '#dotted_name'

- match: \b(class)\b
  captures:
    '1': {name: storage.type.class.python}

- include: '#line_continuation'

# not needed?
# - include: '#language_variables'

- include: '#string_quoted_single'

- include: '#string_quoted_double'

- include: '#dotted_name'

- begin: (\()
  end: (\))
  patterns:
  - include: $self

- match: (\[)(\s*(\]))\b
  captures:
    '1': {name: punctuation.definition.list.begin.python}
    '2': {name: meta.empty-list.python}
    '3': {name: punctuation.definition.list.end.python}

- name: meta.structure.list.python
  begin: (\[)
  beginCaptures:
    '1': {name: punctuation.definition.list.begin.python}
  end: (\])
  endCaptures:
    '1': {name: punctuation.definition.list.end.python}
  patterns:
  - contentName: meta.structure.list.item.python
    begin: (?<=\[|\,)\s*(?![\],])
    end: \s*(?:(,)|(?=\]))
    endCaptures:
      '1': {name: punctuation.separator.list.python}
    patterns:
    - include: $self

- name: meta.structure.tuple.python
  match: \b(\()(\s*(\)))\b
  captures:
    '1': {name: punctuation.definition.tuple.begin.python}
    '2': {name: meta.empty-tuple.python}
    '3': {name: punctuation.definition.tuple.end.python}

- name: meta.structure.dictionary.python
  match: (\{)(\s*(\}))
  captures:
    '1': {name: punctuation.definition.dictionary.begin.python}
    '2': {name: meta.empty-dictionary.python}
    '3': {name: punctuation.definition.dictionary.end.python}

- name: meta.structure.dictionary.python
  begin: (\{)
  beginCaptures:
    '1': {name: punctuation.definition.dictionary.begin.python}
  end: (\})
  endCaptures:
    '1': {name: punctuation.definition.dictionary.end.python}
  patterns:
  - contentName: meta.structure.dictionary.key.python
    begin: (?<=\{|\,|^)\s*(?![\},])
    end: \s*(?:(?=\})|(\:))
    endCaptures:
      '1': {name: punctuation.separator.valuepair.dictionary.python}
    patterns:
    - include: $self
  - contentName: meta.structure.dictionary.value.python
    begin: (?<=\:|^)\s*
    end: \s*(?:(?=\})|(,))
    endCaptures:
      '1': {name: punctuation.separator.dictionary.python}
    patterns:
    - include: $self

repository:
  annotated_arguments:
    begin: \b([[:alpha:]_][[:alnum:]_]*)\s*(:)|(?=\()
    beginCaptures:
      '1': {name: variable.parameter.function.python}
      '2': {name: punctuation.separator.annotation.python}
    end: \s*(?:(,)|(?=$\n?|[\)\:]))
    endCaptures:
      '1': {name: punctuation.separator.parameters.python}
    patterns:
    - include: '#annotated_group'
    - name: keyword.operator.assignment.python
      match: '='
    - include: $self

  annotated_group:
    begin: (\()
    beginCaptures:
      '1': {name: punctuation.definition.parameters-group.begin.python}
    end: (\))
    endCaptures:
      '1': {name: punctuation.definition.parameters-group.end.python}
    patterns:
    - begin: \b([[:alpha:]_][[:alnum:]_]*)\s*(:)
      beginCaptures:
        '1': {name: variable.parameter.function.python}
        '2': {name: punctuation.separator.annotation.python}
      end: \s*(?:(,)|(?=$\n?|\)))
      endCaptures:
        '1': {name: punctuation.separator.parameters.python}
      patterns:
      - include: $self
    - begin: \b([[:alpha:]_][[:alnum:]_]*)
      beginCaptures:
        '1': {name: variable.parameter.function.python}
      end: \s*(?:(,)|(?=$\n?|\)))
      endCaptures:
        '1': {name: punctuation.separator.parameters.python}
    - include: '#comments'

  builtin_functions_call:
    patterns:
    - name: meta.function-call.python
      begin: |-
        (?x)
          (?<!\.)\b(
            __import__ | abs | all | any | ascii | basestring | bin | bool |
            bytearray | bytes | callable | chr | classmethod | cmp | compile |
            complex | delattr | dict | dir | divmod | enumerate | eval | exec |
            execfile | file | filter | float | format | frozenset | getattr |
            globals | hasattr | hash | help | hex | id | input | int |
            isinstance | issubclass | iter | len | list | locals | long | map |
            max | memoryview | min | next | object | oct | open | ord | pow |
            print | property | range | raw_input | reduce | reload | repr |
            reversed | round | set | setattr | slice | sorted | staticmethod |
            str | sum | super | tuple | type | unichr | unicode | vars |
            xrange | zip)
          \b\s*(?=(\())
      beginCaptures:
        '1': {name: support.function.builtin.call.python}
        '2': {name: punctuation.definition.arguments.begin.python}
      end: (\))
      endCaptures:
        '1': {name: punctuation.definition.arguments.end.python}
      patterns:
      - begin: (?=[[:alpha:]_][[:alnum:]_]*(?:\s*\.\s*[[:alpha:]_][[:alnum:]_]*)*\s*\()
        end: (?=\s*\()
        patterns:
        - include: '#dotted_name'
      - contentName: meta.function-call.arguments.python
        begin: (\()
        beginCaptures:
          '1': {name: punctuation.definition.arguments.begin.python}
        end: (?=\))
        endCaptures:
          '0': {name: punctuation.definition.arguments.end.python}
        patterns:
        - include: '#keyword_arguments'
        - include: $self

  builtin_functions_name:
    name: support.function.builtin.name.python
    match: |-
      (?x)
        (?<!\.|@)
        \b(
          __import__ | abs | all | any | ascii | basestring | bin | bool |
          bytearray | bytes | callable | chr | classmethod | cmp | compile |
          complex | delattr | dict | dir | divmod | enumerate | eval | exec |
          execfile | file | filter | float | format | frozenset | getattr |
          globals | hasattr | hash | help | hex | id | input | int |
          isinstance | issubclass | iter | len | list | locals | long | map |
          max | memoryview | min | next | object | oct | open | ord | pow |
          property | range | raw_input | reduce | reload | repr |
          reversed | round | set | setattr | slice | sorted | staticmethod |
          str | sum | super | tuple | type | unichr | unicode | vars |
          xrange | zip)
        \b\s*(?!(\())

  builtin_types:
    name: support.type.python
    comment: 'These are from https://docs.python.org/X/library/functions.html
      where X is 2.7 or 3.5 and the item is a class. Also stdtypes.html'
    match: |-
      (?x)
        (?<!\.)
        \b(
          bool | buffer | bytearray | bytes | complex | dict | float |
          frozenset | int | list | long | memoryview | object | property |
          range | set | slice | str | tuple | type | unicode | xrange)
        \b(?!(\s*\())

  character-class:
    patterns:
    - name: constant.character.character-class.regex.python
      match: \\[wWsSdDhH]|\.
    - name: constant.character.escape.backslash.regex.python
      match: \\.
    - name: constant.other.character-class.set.regex.python
      begin: (\[)(\^)?
      beginCaptures:
        '1': {name: punctuation.definition.character-class.regex.python}
        '2': {name: keyword.operator.negation.regex.python}
      end: (\])
      endCaptures:
        '1': {name: punctuation.definition.character-class.regex.python}
      patterns:
      - include: '#character-class'
      - name: constant.other.character-class.range.regex.python
        match: ((\\.)|.)\-((\\.)|[^\]])
        captures:
          '2': {name: constant.character.escape.backslash.regex.python}
          '4': {name: constant.character.escape.backslash.regex.python}

  comments:
    patterns:
    - name: comment.line.note.python
      match: (#+)\s*(BUG|FIXME|TODO|XXX).*$
      captures:
        '1': {name: punctuation.definition.comment.python}
        '2': {name: comment.line.note.notation.python}
    - name: comment.line.number-sign.python
      match: (#+).*$
      captures:
        '1': {name: punctuation.definition.comment.python}

  constant_placeholder:
    name: constant.other.placeholder.python
    match: (?i:%(\([[:lower:]_]+\))?#?0?\-?[ ]?\+?([0-9]*|\*)(\.([0-9]*|\*))?[hL]?[[:lower:]%])

  docstrings:
    patterns:
    - name: comment.block.python
      begin: ^\s*(?=[uU]?[rR]?""")
      end: (?<=""")
      patterns:
      - include: '#string_quoted_double'
    - name: comment.block.python
      begin: ^\s*(?=[uU]?[rR]?''')
      end: (?<=''')
      patterns:
      - include: '#string_quoted_single'

  dotted_name:
    begin: |-
      (?x)(?=
        (?:\.(?!\s+import)\s*)?
        [[:alpha:]_][[:alnum:]_]*
        (?:\s*\.\s*[[:alpha:]_][[:alnum:]_]*)*
      )
    end: (?![[:alnum:]_\.\s])|(?=(?<!\.)\s+[^.])|$
    patterns:
    - begin: (\.)(?=[[:alpha:]_][[:alnum:]_]*)
      beginCaptures:
        '1': {name: meta.dot.python}
      end: (?![[:alnum:]_])
      patterns:
      - include: '#builtin_functions_name'
      - include: '#magic_function_names'
      - include: '#magic_variable_names'
      - include: '#generic_names'
      - include: '#illegal_names'
    - begin: (?<!\.)(?=[[:alpha:]_][[:alnum:]_]*)
      end: (?![[:alnum:]_])
      patterns:
      - include: '#builtin_types'
      - include: '#builtin_functions_name'
      - include: '#builtin_functions_call'
      - include: '#errors_warnings_exceptions'
      - include: '#magic_function_names'
      - include: '#magic_function_calls'
      - include: '#magic_variable_names'
      - include: '#language_variables'
      - include: '#generic_names'
      - include: '#illegal_names'

  entity_name_class:
    patterns:
    - include: '#generic_names'
    - include: '#illegal_names'

  entity_name_function:
    patterns:
    # - include: '#generic_names'
    - include: '#builtin_functions_name'
    - include: '#magic_function_names'
    - include: '#illegal_names'

  errors_warnings_exceptions:
    name: support.type.exception.python
    match: |-
      (?x)
      \b(
        (
            Arithmetic | Assertion | Attribute | Buffer | BlockingIO |
            BrokenPipe | ChildProcess | (Connection(Aborted | Refused | Reset)?) |
            EOF | Environment | FileExists | FileNotFound | FloatingPoint | IO |
            Import | Indentation | Index | Interrupted | IsADirectory |
            NotADirectory | Permission | ProcessLookup | Timeout | Key | Lookup |
            Memory | Name | NotImplemented | OS | Overflow | Reference | Runtime |
            Recursion | Standard | Syntax | System | Tab | Type | UnboundLocal |
            Unicode(Encode | Decode | Translate)? | Value | VMS | Windows |
            ZeroDivision | ([[:alpha:]_][[:alnum:]_]*))
          ?Error
          |
          (
            (Pending)?Deprecation | Bytes | Future | Import | Resource |
            Runtime | Syntax | Unicode | User | [[:alpha:]_][[:alnum:]_]*)
          ?Warning
          |
          SystemExit | Stop(Async)?Iteration | NotImplemented |
          KeyboardInterrupt | GeneratorExit
          |
          ([[:alpha:]_][[:alnum:]_]*)
          ?Exception
        )
      \b

  escaped_char:
    match: |-
      (?x)
        (\\x[\h]{2}) |
        (\\[0-7]{3}) |
        (\\\n) |
        (\\\\) |
        (\\") |
        (\\') |
        (\\a) |
        (\\b) |
        (\\f) |
        (\\n) |
        (\\r) |
        (\\t) |
        (\\v)
    captures:
      '1': {name: constant.character.escape.hex.python}
      '2': {name: constant.character.escape.octal.python}
      '3': {name: constant.character.escape.newline.python}
      '4': {name: constant.character.escape.backslash.python}
      '5': {name: constant.character.escape.double-quote.python}
      '6': {name: constant.character.escape.single-quote.python}
      '7': {name: constant.character.escape.bell.python}
      '8': {name: constant.character.escape.backspace.python}
      '9': {name: constant.character.escape.formfeed.python}
      '10': {name: constant.character.escape.linefeed.python}
      '11': {name: constant.character.escape.return.python}
      '12': {name: constant.character.escape.tab.python}
      '13': {name: constant.character.escape.vertical-tab.python}

  escaped_char_raw_double:
    name: constant.character.escape.quote.python
    match: \\"

  escaped_char_raw_single:
    name: constant.character.escape.quote.python
    match: \\'

  escaped_unicode_char:
    match: (\\U[\h]{8})|(\\u[\h]{4})|(\\N\{[a-zA-Z0-9\, ]+\})
    captures:
      '1': {name: constant.character.escape.unicode.32-bit-hex.python}
      '2': {name: constant.character.escape.unicode.16-bit-hex.python}
      '3': {name: constant.character.escape.unicode.name.python}

  generic_names:
    #name: meta.identifier.python
    match: '[[:alpha:]_][[:alnum:]_]*'

  generic_object_names:
    match: (\.\b([[:alpha:]_][[:alnum:]_]*)\b(?!\(|\[)|\b([[:alpha:]_][[:alnum:]_]*)\b\.)

  illegal_names:
    comment: 'from Lib/keyword.py, in kwlist. `async` and `await` not keywords
      until Python 3.7 (according to PEP-0492)'
    name: invalid.illegal.name.python
    match: |-
      (?x)
      \b (
        False | None | True | and | as | assert | break | class | continue | def |
        del | elif | else | except | exec | finally | for | from | global | if |
        import | in | is | lambda | nonlocal | not | or | pass | print | raise |
        return | try | while | with | yield)
      \b

  keyword_arguments:
    begin: \b([[:alpha:]_][[:alnum:]_]*)\s*(=)(?!=)
    beginCaptures:
      '1': {name: variable.parameter.function.keyword.python}
      '2': {name: keyword.operator.assignment.python}
    end: \s*(?:(,)|(?=[\)\:]))
    endCaptures:
      '1': {name: punctuation.separator.parameters.python}
    patterns:
    - include: $self

  language_variables:
    match: (?<!\.)\b(self|cls)\b(?:\.|\()?
    captures:
      "1": {name: variable.language.python}

  line_continuation:
    match: (\\)(.*)$\n?
    captures:
      '1': {name: punctuation.separator.continuation.line.python}

  magic_function_names:
    comment: 'these methods have magic interpretation by python and are generally
      called indirectly through syntactic constructs. Names are from
      https://docs.python.org/X/reference/datamodel.html where X is 2.7 and 3.5
      See also http://www.rafekettler.com/magicmethods.html'
    match: |-
      (?x)
      (def|\.)?
      \s*\b(
        __(?:
          abs | add | aenter | aexit | aiter | and | anext | await | bool |
          bytes | call | ceil | cmp | coerce | complex | contains | copy |
          deepcopy | del | delattr | delete | delitem | delslice | dir | div |
          divmod | enter | eq | exit | float | floor | floordiv | format | ge |
          get | getattr | getattribute | getinitargs | getitem | getnewargs |
          getnewargs_ex | getslice | getstate | gt | hash | hex | iadd | iand |
          idiv | idivmod | ifloordiv | ilshift | imatmul | imod | imul | index |
          init | instancecheck | int | invert | iop | ior | ipow | irshift |
          isub | iter | itruediv | ixor | le | len | length_hint | long |
          lshift | lt | matmul | missing | mod | mul | ne | neg | new | next |
          nonzero | oct | op | or | pos | pow | prepare | radd | rand | rcmp |
          rdiv | rdivmod | reduce | reduce_ex | repr | reversed | rfloordiv |
          rlshift | rmatmul | rmod | rmul | rop | ror | round | rpow | rrshift |
          rshift | rsub | rtruediv | rxor | set | setattr | setitem | setslice |
          setstate | sizeof | str | sub | subclasscheck | truediv | trunc |
          unicode | xor)
        __)
      \b
    captures:
      '2': {name: support.function.magic.name.python}

  magic_function_calls:
    patterns:
    - name: meta.function-call.python
      begin: |-
        (?x)
          (\.)?
          \b(
            __(?:
              abs | add | aenter | aexit | aiter | and | anext | await | bool |
              bytes | call | ceil | cmp | coerce | complex | contains | copy |
              deepcopy | del | delattr | delete | delitem | delslice | dir | div |
              divmod | enter | eq | exit | float | floor | floordiv | format | ge |
              get | getattr | getattribute | getinitargs | getitem | getnewargs |
              getnewargs_ex | getslice | getstate | gt | hash | hex | iadd | iand |
              idiv | idivmod | ifloordiv | ilshift | imatmul | imod | imul | index |
              init | instancecheck | int | invert | iop | ior | ipow | irshift |
              isub | iter | itruediv | ixor | le | len | length_hint | long |
              lshift | lt | matmul | missing | mod | mul | ne | neg | new | next |
              nonzero | oct | op | or | pos | pow | prepare | radd | rand | rcmp |
              rdiv | rdivmod | reduce | reduce_ex | repr | reversed | rfloordiv |
              rlshift | rmatmul | rmod | rmul | rop | ror | round | rpow | rrshift |
              rshift | rsub | rtruediv | rxor | set | setattr | setitem | setslice |
              setstate | sizeof | str | sub | subclasscheck | truediv | trunc |
              unicode | xor)
            __)
          \s*(?=(\())
      beginCaptures:
        '2': {name: support.function.magic.call.python}
        '4': {name: punctuation.definition.arguments.begin.python}
      end: (\))
      endCaptures:
        '1': {name: punctuation.definition.arguments.end.python}
      patterns:
      - begin: (?=[[:alpha:]_][[:alnum:]_]*(?:\s*\.\s*[[:alpha:]_][[:alnum:]_]*)*\s*\()
        end: (?=\s*\()
        patterns:
        - include: '#dotted_name'
      - contentName: meta.function-call.arguments.python
        begin: (\()
        beginCaptures:
          '1': {name: punctuation.definition.arguments.begin.python}
        end: (?=\))
        endCaptures:
          '0': {name: punctuation.definition.arguments.end.python}
        patterns:
        - include: '#keyword_arguments'
        - include: $self

  magic_variable_names:
    comment: magic attributes which a class/module may have.
    match: |-
      (?x)
      (\.)?
      \b(
        __(?:
          all | annotations | bases | class | closure | code | debug |
          defaults | dict | doc | file | func | globals | kwdefaults |
          members | metaclass | methods | module | mro | name | qualname |
          self | slots | subclasses | version | weakref)
        __) \b
    captures:
      '2': {name: support.variable.magic.python}

  regular_expressions:
    patterns:
    - include: source.regexp.python.improved

  string_formatting:
    comment: Attempt from @sprt to add support for new-style string formatting.
    match: |-
      (?x)
      (?<![^\{]\{)
      \{
      (?<fieldname>
        (
          (?<argname>
            (
              (?<identifier>([[:alpha:]_][[:alnum:]_]*)) |
              (?<integer>
                ([1-9]\d* | 0) |
                (
                  0
                  (
                    (?i:
                      ([o]?[0-7]+) |
                      ([x][0-9a-f]+) |
                      ([b][01]+)
                    )
                  )
                )
              )
            )
          )?
        )
        (
          (?<attributename>
            (\.\g<identifier>)
          ) |
          \[
          (
            (?<elementindex>
              (
                (\g<integer>) |
                (?<indexstring>[^\]\}\{]+)
              )
            )
          )
          \]
        )*
      )?
      (
        ((?<conversion>(\![rsa])))
      )?
      (
        (?<formatspec>
          (
            \:
            (
              (?<fill>.)?
              (?<align>([<>=\^]))
            )?
            (?<sign>([\ +-]))?
            \#?0?
            (?<width>
              (\g<integer>)
            )?
            ,?
            (?<precision>
              \.
              (\g<integer>)
            )?
            (?<type>([bcdEeFfGgnosXx%]))?
          )?
        )
      )?
      \}
      (?!\}[^\}])
    captures:
      '6': {name: identifier}
      '8': {name: constant.numeric.integer.decimal.python}
      '11': {name: constant.numeric.integer.octal.python}
      '12': {name: constant.numeric.integer.hexadecimal.python}
      '13': {name: constant.numeric.integer.binary.python}
      '14': {name: attribute.name}
      '16': {name: attribute.identifier}

  string_quoted_double:
    patterns:
    - name: string.quoted.double.block.unicode-raw-regex.python
      begin: ([uU]r)(""")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=""")(")""|""")
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
      - include: '#regular_expressions'
    - name: string.quoted.double.block.unicode-raw.python
      begin: ([uU]R)(""")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=""")(")""|""")
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
    - name: string.quoted.double.block.bytes-raw-regex.python
      begin: ([bB]r)(""")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=""")(")""|""")
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
      - include: '#regular_expressions'
    - name: string.quoted.double.block.bytes-raw.python
      begin: ([bB]R)(""")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=""")(")""|""")
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
    - name: string.quoted.double.block.raw-regex.python
      begin: (r)(""")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=""")(")""|""")
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
      - include: '#regular_expressions'
    - name: string.quoted.double.block.raw.python
      begin: (R)(""")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=""")(")""|""")
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
    - comment: double quoted unicode string
      name: string.quoted.double.block.unicode.python
      begin: ([uU])(""")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=""")(")""|""")
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'
    - comment: double quoted bytes string
      name: string.quoted.double.block.bytes.python
      begin: ([bB])(""")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=""")(")""|""")
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'
    - name: string.quoted.double.single-line.unicode-raw-regex.python
      begin: ([uU]r)(")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=")(")|")|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
        '3': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
      - include: '#regular_expressions'
    - name: string.quoted.double.single-line.unicode-raw.python
      begin: ([uU]R)(")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=")(")|")|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
        '3': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
    - name: string.quoted.double.single-line.bytes-raw-regex.python
      begin: ([bB]r)(")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=")(")|")|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
        '3': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
      - include: '#regular_expressions'
    - name: string.quoted.double.single-line.bytes-raw.python
      begin: ([bB]R)(")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=")(")|")|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
        '3': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
    - name: string.quoted.double.single-line.raw-regex.python
      begin: (r)(")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=")(")|")|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
        '3': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
      - include: '#regular_expressions'
    - name: string.quoted.double.single-line.raw.python
      begin: (R)(")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=")(")|")|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
        '3': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_double'
    - comment: double quoted unicode string
      name: string.quoted.double.single-line.unicode.python
      begin: ([uU])(")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=")(")|")|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
        '3': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'
    - comment: double quoted bytes string
      name: string.quoted.double.single-line.bytes.python
      begin: ([bB])(")
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=")(")|")|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
        '3': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'
    - comment: double quoted string
      name: string.quoted.double.block.python
      begin: (""")
      beginCaptures:
        '1': {name: punctuation.definition.string.begin.python}
      end: ((?<=""")(")""|""")
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'
    - comment: double quoted string
      name: string.quoted.double.single-line.python
      begin: (")
      beginCaptures:
        '1': {name: punctuation.definition.string.begin.python}
      end: ((?<=")(")|")|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.double.python}
        '3': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'

  string_quoted_single:
    patterns:
    - name: string.quoted.single.single-line.python
      match: (?<!')(')(('))(?!')
      captures:
        '1': {name: punctuation.definition.string.begin.python}
        '2': {name: punctuation.definition.string.end.python}
        '3': {name: meta.empty-string.single.python}
    - name: string.quoted.single.block.unicode-raw-regex.python
      begin: ([uU]r)(''')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=''')(')''|''')
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.single.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
      - include: '#regular_expressions'
    - name: string.quoted.single.block.unicode-raw.python
      begin: ([uU]R)(''')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=''')(')''|''')
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.single.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
    - name: string.quoted.single.block.bytes-raw-regex.python
      begin: ([bB]r)(''')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=''')(')''|''')
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.single.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
      - include: '#regular_expressions'
    - name: string.quoted.single.block.bytes-raw.python
      begin: ([bB]R)(''')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=''')(')''|''')
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.single.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
    - name: string.quoted.single.block.raw-regex.python
      begin: (r)(''')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=''')(')''|''')
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.single.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
      - include: '#regular_expressions'
    - name: string.quoted.single.block.raw.python
      begin: (R)(''')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=''')(')''|''')
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.single.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
    - name: string.quoted.single.block.unicode.python
      begin: ([uU])(''')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=''')(')''|''')
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.single.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'
    - comment: single quoted bytes string
      name: string.quoted.single.block.bytes.python
      begin: ([bB])(''')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: ((?<=''')(')''|''')
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.single.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char'
      - include: '#escaped_unicode_char'
    - name: string.quoted.single.single-line.unicode-raw-regex.python
      begin: ([uU]r)(')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: (')|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
      - include: '#regular_expressions'
    - name: string.quoted.single.single-line.unicode-raw.python
      begin: ([uU]R)(')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: (')|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
    - name: string.quoted.single.single-line.bytes-raw-regex.python
      begin: ([bB]r)(')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: (')|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
      - include: '#regular_expressions'
    - name: string.quoted.single.single-line.bytes-raw.python
      begin: ([bB]R)(')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: (')|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
    - name: string.quoted.single.single-line.raw-regex.python
      begin: (r)(')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: (')|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
      - include: '#regular_expressions'
    - name: string.quoted.single.single-line.raw.python
      begin: (R)(')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: (')|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_char_raw_single'
    - comment: single quoted unicode string
      name: string.quoted.single.single-line.unicode.python
      begin: ([uU])(')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: (')|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'
    - comment: single quoted bytes string
      name: string.quoted.single.single-line.bytes.python
      begin: ([bB])(')
      beginCaptures:
        '1': {name: storage.type.string.python}
        '2': {name: punctuation.definition.string.begin.python}
      end: (')|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'
    - comment: single quoted string
      name: string.quoted.single.block.python
      begin: (''')
      beginCaptures:
        '1': {name: punctuation.definition.string.begin.python}
      end: ((?<=''')(')''|''')
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: meta.empty-string.single.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'
    - comment: single quoted string
      name: string.quoted.single.single-line.python
      begin: (')
      beginCaptures:
        '1': {name: punctuation.definition.string.begin.python}
      end: (')|(\n)
      endCaptures:
        '1': {name: punctuation.definition.string.end.python}
        '2': {name: invalid.illegal.unclosed-string.python}
      patterns:
      - include: '#constant_placeholder'
      - include: '#escaped_unicode_char'
      - include: '#escaped_char'

  strings:
    patterns:
    - include: '#string_quoted_double'
    - include: '#string_quoted_single'

author: Matt Morrison @MattDMo mattdmo@pigimal.com
bundleUUID: EB590797-FBEE-4BEA-A140-8339AFD2CE1B
firstLineMatch: ^#!/.*\bpython[0-9.-]*\b
foldingStartMarker: ^\s*(((?:async\s+)?def)|class)\s+([.[:alnum:]_ <]+)\s*(\((.*)\))?\s*:|\{\s*$|\(\s*$|\[\s*$|^\s*"""(?=.)(?!.*""")
foldingStopMarker: ^\s*$|^\s*\}|^\s*\]|^\s*\)|^\s*"""\s*$
keyEquivalent: ^~P