ver 2009.12.14 → 2010.02

data/config/syntax/Prototype & Script.aculo.us (JavaScript) Bracketed.rb

@@ -0,0 +1,100 @@
+# Encoding: UTF-8
+
+{comment: 
+  "This is a wrapper for and adds nested bracket scopes to Prototype & Script.aculo.us (JavaScript). It also allow for embedded ruby source. By Thomas Aylott",
+ foldingStartMarker: /(\{[^\}]*$|\([^\)]*$|<%)/,
+ foldingStopMarker: /(^[^\{]*\}|^\s*\)|%>)/,
+ keyEquivalent: "^~J",
+ name: "Prototype & Script.aculo.us (JavaScript) Bracketed",
+ patterns: 
+  [{begin: /<%=/,
+    beginCaptures: {0 => {name: "punctuation.section.embedded.begin.js"}},
+    end: "%>",
+    endCaptures: {0 => {name: "punctuation.section.embedded.end.js"}},
+    name: "meta.source.embedded.return-value",
+    patterns: 
+     [{begin: /(?<=<%=)/,
+       end: "(?=%>)",
+       name: "source.ruby.rails.embedded.html",
+       patterns: [{include: "source.ruby.rails"}]}]},
+   {begin: /<%(?![=#])/,
+    beginCaptures: {0 => {name: "punctuation.section.embedded.begin.js"}},
+    end: "%>",
+    endCaptures: {0 => {name: "punctuation.section.embedded.end.js"}},
+    name: "meta.source.embedded",
+    patterns: 
+     [{begin: /(?<=<%)/,
+       end: "(?=%>)",
+       name: "source.ruby.rails.embedded.html",
+       patterns: [{include: "source.ruby.rails"}]}]},
+   {include: "#conditional-compilation"},
+   {include: "#round-brackets"},
+   {include: "source.js.prototype"}],
+ repository: 
+  {:"conditional-compilation" => 
+    {patterns: 
+      [{begin: /\/\*(?=@)/,
+        captures: {0 => {name: "punctuation.definition.comment.js"}},
+        end: "(?<=@)\\*/",
+        name: "comment.block.conditional.js",
+        patterns: [{include: "$base"}]},
+       {captures: {1 => {name: "punctuation.definition.keyword.js"}},
+        match: /(@)(if|elif|else|end)/,
+        name: "keyword.control.conditional.js"},
+       {captures: {1 => {name: "punctuation.definition.keyword.js"}},
+        match: /(@)(cc_on|set)/,
+        name: "keyword.operator.conditional.js"},
+       {captures: {1 => {name: "punctuation.definition.variable.js"}},
+        match: 
+         /(@)(_win32|_win16|_mac|_alpha|_x86|_mc680x0|_PowerPC|_jscript_build|_jscript_version|_jscript|_debug|_fast|[a-zA-Z]\w+)/,
+        name: "variable.other.conditional.js"}]},
+   :"round-brackets" => 
+    {patterns: 
+      [{begin: /(?<=\))\s*+(\{)/,
+        captures: 
+         {1 => {name: "punctuation.section.function.js.prototype"},
+          2 => {name: "punctuation.separator.objects.js.prototype"}},
+        end: "(\\})(,)?\\s*",
+        name: "meta.group.braces.curly.function.js.prototype",
+        patterns: [{include: "$base"}]},
+       {begin: /(\{)/,
+        captures: 
+         {1 => {name: "punctuation.section.scope.js"},
+          2 => {name: "punctuation.separator.objects.js.prototype"}},
+        end: "(\\})(,)?\\s*",
+        name: "meta.group.braces.curly",
+        patterns: 
+         [{captures: 
+            {1 => {name: "invalid.illegal.delimiter.object.comma.js"}},
+           match: /(,)\s*+(?=\})/},
+          {captures: 
+            {1 => {name: "string.quoted.double.js.prototype"},
+             2 => {name: "punctuation.definition.string.js.prototype"},
+             3 => {name: "constant.other.object.key.js.prototype"},
+             4 => {name: "punctuation.definition.string.js.prototype"},
+             5 => {name: "punctuation.separator.objects.js.prototype"}},
+           match: /((")([^"]*)(")\s*)(:)\s*+(?!function)/},
+          {captures: 
+            {1 => {name: "string.quoted.single.js.prototype"},
+             2 => {name: "punctuation.definition.string.js.prototype"},
+             3 => {name: "constant.other.object.key.js.prototype"},
+             4 => {name: "punctuation.definition.string.js.prototype"},
+             5 => {name: "punctuation.separator.objects.js.prototype"}},
+           match: /((')([^']*)(')\s*)(:)\s*+(?!function)/},
+          {captures: 
+            {1 => {name: "constant.other.object.key.js.prototype"},
+             2 => {name: "punctuation.separator.objects.js.prototype"}},
+           match: /\b(\w+\b\s*)(:)\s*+(?!function)/},
+          {include: "$base"}]},
+       {begin: /(\()(?!\))/,
+        captures: {1 => {name: "punctuation.section.scope.js"}},
+        end: "(\\))",
+        name: "meta.group.braces.round",
+        patterns: [{include: "$base"}]},
+       {begin: /(\[)(?!\])/,
+        captures: {1 => {name: "punctuation.section.scope.js"}},
+        end: "(\\])",
+        name: "meta.group.braces.square",
+        patterns: [{include: "$base"}]}]}},
+ scopeName: "source.js.prototype.bracketed",
+ uuid: "1FD22341-8BAA-4F89-8257-92CBDD7DE29D"}

data/config/syntax/Prototype & Script.aculo.us (JavaScript).rb

@@ -0,0 +1,56 @@
+# Encoding: UTF-8
+
+{comment: 
+  "Prototype and Scriptaculous Javascript Frameworks. By Justin Palmer, Thomas Aylott & Martin Ström",
+ foldingStartMarker: /(^.*{[^}]*$|^.*\([^\)]*$|^.*\/\*(?!.*\*\/).*$)/,
+ foldingStopMarker: /(^\s*\}|^\s*\)|^(?!.*\/\*).*\*\/)/,
+ keyEquivalent: "^~J",
+ name: "Prototype & Script.aculo.us (JavaScript)",
+ patterns: 
+  [{match: 
+     /\b(Prototype|Class|Abstract|Try|PeriodicalExecuter|Enumerable|Hash|ObjectRange|Element|Ajax|Responders|Base|Request|Updater|PeriodicalUpdater|Toggle|Insertion|Before|Top|Bottom|After|ClassNames|Form|Serializers|TimedObserver|Observer|EventObserver|Event|Position|Effect|Effect2|Transitions|ScopedQueue|Queues|DefaultOptions|Parallel|Opacity|Move|MoveBy|Scale|Highlight|ScrollTo|Fade|Appear|Puff|BlindUp|BlindDown|SwitchOff|DropOut|Shake|SlideDown|SlideUp|Squish|Grow|Shrink|Pulsate|Fold|console)\b/,
+    name: "support.class.prototype.js"},
+   {match: 
+     /\b(Version|ScriptFragment|emptyFunction|K|create|toColorPart|succ|times|these|initialize|registerCallback|onTimerEvent|stripTags|stripScripts|extractScripts|evalScripts|escapeHTML|unescapeHTML|toQueryParams|toArray|camelize|inspect|each|inGroupsOf|eachSlice|all|any|collect|detect|findAll|grep|include|inject|invoke|max|min|partition|pluck|reject|sortBy|toArray|zip|inspect|map|find|select|member|entries|_each|_reverse|reverse|clear|first|last|compact|flatten|without|indexOf|reverse|shift|inspect|keys|values|merge|toQueryString|inspect|include|getTransport|activeRequestCount|responders|register|unregister|dispatch|onComplete|setOptions|responseIsSuccess|responseIsFailure|request|setRequestHeaders|onStateChange|header|evalJSON|evalResponse|respondToReadyState|dispatchException|updateContent|start|stop|updateComplete|toggle|hide|show|remove|update|getHeight|classNames|hasClassName|addClassName|removeClassName|cleanWhitespace|empty|scrollTo|getStyle|setStyle|getDimensions|makePositioned|undoPositioned|makeClipping|undoClipping|recursivelyCollect|ancestors|descendants|previousSiblings|nextSiblings|siblings|match|up|down|previous|next|getElementsBySelector|getElementsByClassName|contentFromAnonymousTable|initializeRange|insertContent|set|add|toString|focus|present|activate|serialize|getElements|getInputs|disable|enable|findFirstElement|focusFirstElement|reset|getValue|input|inputSelector|textarea|selectOne|selectMany|onElementEvent|registerFormCallbacks|element|isLeftClick|pointerX|pointerY|findElement|observers|unloadCache|observe|stopObserving|includeScrollOffsets|prepare|realOffset|cumulativeOffset|positionedOffset|offsetParent|within|withinIncludingScrolloffsets|overlap|clone|page|clone|absolutize|relativize)\b/,
+    name: "support.function.js.prototype"},
+   {include: "source.js"},
+   {match: 
+     /((?<=var\s)\b[a-zA-Z]\w*\b|\b[a-zA-Z]\w*\b(?=(\[|\s*(&|\*|\-\-|\-|\+\+|\+|~|===|==|=|!=|!==|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\|\||\?\:|\*=|\/=|%=|\+=|\-=|&=|\^=))))/,
+    name: "variable.other.js.prototype"},
+   {include: "#leading-space"}],
+ repository: 
+  {:"leading-space" => 
+    {patterns: 
+      [{begin: /^(?=(\t|  ))/,
+        end: "(?=[^\\t\\s])",
+        name: "meta.leading-tabs",
+        patterns: 
+         [{captures: 
+            {1 => {name: "meta.odd-tab.group1.spaces"},
+             10 => {name: "meta.even-tab.group10.spaces"},
+             11 => {name: "meta.odd-tab.group11.spaces"},
+             2 => {name: "meta.even-tab.group2.spaces"},
+             3 => {name: "meta.odd-tab.group3.spaces"},
+             4 => {name: "meta.even-tab.group4.spaces"},
+             5 => {name: "meta.odd-tab.group5.spaces"},
+             6 => {name: "meta.even-tab.group6.spaces"},
+             7 => {name: "meta.odd-tab.group7.spaces"},
+             8 => {name: "meta.even-tab.group8.spaces"},
+             9 => {name: "meta.odd-tab.group9.spaces"}},
+           match: /(  )(  )?(  )?(  )?(  )?(  )?(  )?(  )?(  )?(  )?(  )?/},
+          {captures: 
+            {1 => {name: "meta.odd-tab.group1.tab"},
+             10 => {name: "meta.even-tab.group10.tab"},
+             11 => {name: "meta.odd-tab.group11.tab"},
+             2 => {name: "meta.even-tab.group2.tab"},
+             3 => {name: "meta.odd-tab.group3.tab"},
+             4 => {name: "meta.even-tab.group4.tab"},
+             5 => {name: "meta.odd-tab.group5.tab"},
+             6 => {name: "meta.even-tab.group6.tab"},
+             7 => {name: "meta.odd-tab.group7.tab"},
+             8 => {name: "meta.even-tab.group8.tab"},
+             9 => {name: "meta.odd-tab.group9.tab"}},
+           match: 
+            /(\t)(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?/}]}]}},
+ scopeName: "source.js.prototype",
+ uuid: "0BD60463-DDF6-436F-9295-89DEF577FF30"}

data/config/syntax/Python Django.rb

@@ -0,0 +1,25 @@
+# Encoding: UTF-8
+
+{fileTypes: [],
+ foldingStartMarker: 
+  /^\s*(def|class)\s+([.a-zA-Z0-9_ b]+)\s*(\((.*)\))?\s*:|\{\s*$|\(\s*$|\[\s*$/,
+ foldingStopMarker: /^\s*$|^\s*\}|^\s*\]|^\s*\)/,
+ keyEquivalent: "^~P",
+ name: "Python Django",
+ patterns: 
+  [{match: 
+     /(meta|models)\.(Admin|AutoField|BooleanField|CharField|CommaSeparatedIntegerField|DateField|DateTimeField|DecimalField|EmailField|FileField|FilePathField|FloatField|ForeignKey|ImageField|IntegerField|IPAddressField|ManyToManyField|NullBooleanField|OneToOneField|PhoneNumberField|PositiveIntegerField|PositiveSmallIntegerField|SlugField|SmallIntegerField|TextField|TimeField|URLField|USStateField|XMLField)/,
+    name: "support.type.django.model"},
+   {match: /django(\.[a-z]+){1,} /, name: "support.other.django.module"},
+   {match: 
+     /(ABSOLUTE_URL_OVERRIDES|ADMIN_FOR|ADMIN_MEDIA_PREFIX|ADMINS|ALLOWED_INCLUDE_ROOTS|APPEND_SLASH|AUTHENTICATION_BACKENDS|AUTH_PROFILE_MODULE|CACHE_BACKEND|CACHE_MIDDLEWARE_KEY_PREFIX|CACHE_MIDDLEWARE_SECONDS|DATABASE_ENGINE|DATABASE_HOST|DATABASE_NAME|DATABASE_OPTIONS|DATABASE_PASSWORD|DATABASE_PORT|DATABASE_USER|DATE_FORMAT|DATETIME_FORMAT|DEBUG|DEFAULT_CHARSET|DEFAULT_CONTENT_TYPE|DEFAULT_FROM_EMAIL|DEFAULT_TABLESPACE|DEFAULT_INDEX_TABLESPACE|DISALLOWED_USER_AGENTS|EMAIL_HOST_PASSWORD|EMAIL_HOST_USER|EMAIL_HOST|EMAIL_PORT|EMAIL_SUBJECT_PREFIX|EMAIL_USE_TLS|FILE_CHARSET|FIXTURE_DIRS|IGNORABLE_404_ENDS|IGNORABLE_404_STARTS|INSTALLED_APPS|INTERNAL_IPS|JING_PATH|LANGUAGE_CODE|LANGUAGE_COOKIE_NAME|LANGUAGES|LOCALE_PATHS|LOGIN_REDIRECT_URL|LOGIN_URL|LOGOUT_URL|MANAGERS|MEDIA_ROOT|MEDIA_URL|MIDDLEWARE_CLASSES|MONTH_DAY_FORMAT|PREPEND_WWW|PROFANITIES_LIST|ROOT_URLCONF|SECRET_KEY|SEND_BROKEN_LINK_EMAILS|SERIALIZATION_MODULES|SERVER_EMAIL|SESSION_ENGINE|SESSION_COOKIE_AGE|SESSION_COOKIE_DOMAIN|SESSION_COOKIE_NAME|SESSION_COOKIE_PATH|SESSION_COOKIE_SECURE|SESSION_EXPIRE_AT_BROWSER_CLOSE|SESSION_FILE_PATH|SESSION_SAVE_EVERY_REQUEST|SITE_ID|TEMPLATE_CONTEXT_PROCESSORS|TEMPLATE_DEBUG|TEMPLATE_DIRS|TEMPLATE_LOADERS|TEMPLATE_STRING_IF_INVALID|TEST_DATABASE_CHARSET|TEST_DATABASE_COLLATION|TEST_DATABASE_NAME|TEST_RUNNER|TIME_FORMAT|TIME_ZONE|URL_VALIDATOR_USER_AGENT|USE_ETAGS|USE_I18N|YEAR_MONTH_FORMAT)/,
+    name: "variable.other.django.settings"},
+   {match: 
+     /(get_list_or_404|get_object_or_404|load_and_render|loader|render_to_response)/,
+    name: "support.function.django.view"},
+   {match: 
+     /[a-z_]+\.get_(object|list|iterator|count|values|values_iterator|in_bulk)/,
+    name: "support.function.django.model"},
+   {include: "source.python"}],
+ scopeName: "source.python.django",
+ uuid: "5326D56C-6F76-4758-8DB7-D818527919AC"}

data/config/syntax/Python.rb

@@ -0,0 +1,836 @@
+# Encoding: UTF-8
+
+{bundleUUID: "E3BADC20-6B0E-11D9-9DC9-000D93589AF6",
+ comment: 
+  "\n\ttodo:\n\t\tlist comprehension / generator comprehension scope.\n\t\t\n\t",
+ fileTypes: 
+  ["py",
+   "rpy",
+   "pyw",
+   "cpy",
+   "SConstruct",
+   "Sconstruct",
+   "sconstruct",
+   "SConscript"],
+ firstLineMatch: "^#!/.*\\bpython\\b",
+ foldingStartMarker: 
+  /^\s*(def|class)\s+([.a-zA-Z0-9_ <]+)\s*(\((.*)\))?\s*:|\{\s*$|\(\s*$|\[\s*$|^\s*"""(?=.)(?!.*""")/,
+ foldingStopMarker: /^\s*$|^\s*\}|^\s*\]|^\s*\)|^\s*"""\s*$/,
+ keyEquivalent: /^~P/,
+ name: "Python",
+ patterns: 
+  [{captures: {1 => {name: "punctuation.definition.comment.python"}},
+    match: /(#).*$\n?/,
+    name: "comment.line.number-sign.python"},
+   {match: /\b(?i:(0x\h*)L)/,
+    name: "constant.numeric.integer.long.hexadecimal.python"},
+   {match: /\b(?i:(0x\h*))/,
+    name: "constant.numeric.integer.hexadecimal.python"},
+   {match: /\b(?i:(0[0-7]+)L)/,
+    name: "constant.numeric.integer.long.octal.python"},
+   {match: /\b(0[0-7]+)/, name: "constant.numeric.integer.octal.python"},
+   {match: 
+     /\b(?i:(((\d+(\.(?=[^a-zA-Z_])\d*)?|(?<=[^0-9a-zA-Z_])\.\d+)(e[\-\+]?\d+)?))J)/,
+    name: "constant.numeric.complex.python"},
+   {match: /\b(?i:(\d+\.\d*(e[\-\+]?\d+)?))(?=[^a-zA-Z_])/,
+    name: "constant.numeric.float.python"},
+   {match: /(?<=[^0-9a-zA-Z_])(?i:(\.\d+(e[\-\+]?\d+)?))/,
+    name: "constant.numeric.float.python"},
+   {match: /\b(?i:(\d+e[\-\+]?\d+))/, name: "constant.numeric.float.python"},
+   {match: /\b(?i:([1-9]+[0-9]*|0)L)/,
+    name: "constant.numeric.integer.long.decimal.python"},
+   {match: /\b([1-9]+[0-9]*|0)/,
+    name: "constant.numeric.integer.decimal.python"},
+   {captures: {1 => {name: "storage.modifier.global.python"}},
+    match: /\b(global)\b/},
+   {captures: 
+     {1 => {name: "keyword.control.import.python"},
+      2 => {name: "keyword.control.import.from.python"}},
+    match: /\b(?:(import)|(from))\b/},
+   {comment: "keywords that delimit flow blocks",
+    match: /\b(elif|else|except|finally|for|if|try|while|with)\b/,
+    name: "keyword.control.flow.python"},
+   {comment: "keywords that alter flow from within a block",
+    match: /\b(break|continue|pass|raise|return|yield)\b/,
+    name: "keyword.control.flow.python"},
+   {comment: "keyword operators that evaluate to True or False",
+    match: /\b(and|in|is|not|or)\b/,
+    name: "keyword.operator.logical.python"},
+   {captures: {1 => {name: "keyword.other.python"}},
+    comment: "keywords that haven't fit into other groups (yet).",
+    match: /\b(as|assert|del|exec|print)\b/},
+   {match: /<\=|>\=|\=\=|<|>|<>/, name: "keyword.operator.comparison.python"},
+   {match: /\+\=|-\=|\*\=|\/\=|\/\/\=|%\=|&\=|\|\=|\^\=|>>\=|<<\=|\*\*\=/,
+    name: "keyword.operator.assignment.augmented.python"},
+   {match: /\+|\-|\*|\*\*|\/|\/\/|%|<<|>>|&|\||\^|~/,
+    name: "keyword.operator.arithmetic.python"},
+   {match: /\=/, name: "keyword.operator.assignment.python"},
+   {begin: /^\s*(class)\s+(?=[a-zA-Z_][a-zA-Z_0-9]*\s*\:)/,
+    beginCaptures: {1 => {name: "storage.type.class.python"}},
+    contentName: "entity.name.type.class.python",
+    end: "\\s*(:)",
+    endCaptures: {1 => {name: "punctuation.section.class.begin.python"}},
+    name: "meta.class.old-style.python",
+    patterns: [{include: "#entity_name_class"}]},
+   {begin: /^\s*(class)\s+(?=[a-zA-Z_][a-zA-Z_0-9]*\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"}},
+    name: "meta.class.python",
+    patterns: 
+     [{begin: /(?=[A-Za-z_][A-Za-z0-9_]*)/,
+       contentName: "entity.name.type.class.python",
+       end: "(?![A-Za-z0-9_])",
+       patterns: [{include: "#entity_name_class"}]},
+      {begin: /(\()/,
+       beginCaptures: 
+        {1 => {name: "punctuation.definition.inheritance.begin.python"}},
+       contentName: "meta.class.inheritance.python",
+       end: "(?=\\)|:)",
+       patterns: 
+        [{begin: /(?<=\(|,)\s*/,
+          contentName: "entity.other.inherited-class.python",
+          end: "\\s*(?:(,)|(?=\\)))",
+          endCaptures: 
+           {1 => {name: "punctuation.separator.inheritance.python"}},
+          patterns: [{include: "$self"}]}]}]},
+   {begin: /^\s*(class)\s+(?=[a-zA-Z_][a-zA-Z_0-9])/,
+    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"}},
+    name: "meta.class.python",
+    patterns: 
+     [{begin: /(?=[A-Za-z_][A-Za-z0-9_]*)/,
+       contentName: "entity.name.type.class.python",
+       end: "(?![A-Za-z0-9_])",
+       patterns: [{include: "#entity_name_function"}]}]},
+   {begin: /^\s*(def)\s+(?=[A-Za-z_][A-Za-z0-9_]*\s*\()/,
+    beginCaptures: {1 => {name: "storage.type.function.python"}},
+    end: "(\\))\\s*(?:(\\:)|(.*$\\n?))",
+    endCaptures: 
+     {1 => {name: "punctuation.definition.parameters.end.python"},
+      2 => {name: "punctuation.section.function.begin.python"},
+      3 => {name: "invalid.illegal.missing-section-begin.python"}},
+    name: "meta.function.python",
+    patterns: 
+     [{begin: /(?=[A-Za-z_][A-Za-z0-9_]*)/,
+       contentName: "entity.name.function.python",
+       end: "(?![A-Za-z0-9_])",
+       patterns: [{include: "#entity_name_function"}]},
+      {begin: /(\()/,
+       beginCaptures: 
+        {1 => {name: "punctuation.definition.parameters.begin.python"}},
+       contentName: "meta.function.parameters.python",
+       end: "(?=\\)\\s*\\:)",
+       patterns: 
+        [{include: "#keyword_arguments"},
+         {captures: 
+           {1 => {name: "variable.parameter.function.python"},
+            2 => {name: "punctuation.separator.parameters.python"}},
+          match: /\b([a-zA-Z_][a-zA-Z_0-9]*)\s*(?:(,)|(?=[\n\)]))/}]}]},
+   {begin: /^\s*(def)\s+(?=[A-Za-z_][A-Za-z0-9_]*)/,
+    beginCaptures: {1 => {name: "storage.type.function.python"}},
+    end: "(\\()|\\s*($\\n?|#.*$\\n?)",
+    endCaptures: 
+     {1 => {name: "punctuation.definition.parameters.begin.python"},
+      2 => {name: "invalid.illegal.missing-parameters.python"}},
+    name: "meta.function.python",
+    patterns: 
+     [{begin: /(?=[A-Za-z_][A-Za-z0-9_]*)/,
+       contentName: "entity.name.function.python",
+       end: "(?![A-Za-z0-9_])",
+       patterns: [{include: "#entity_name_function"}]}]},
+   {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"}},
+    name: "meta.function.inline.python",
+    patterns: 
+     [{begin: /\s+/,
+       contentName: "meta.function.inline.parameters.python",
+       end: "(?=\\:)",
+       patterns: 
+        [{include: "#keyword_arguments"},
+         {captures: 
+           {1 => {name: "variable.parameter.function.python"},
+            2 => {name: "punctuation.separator.parameters.python"}},
+          match: /\b([a-zA-Z_][a-zA-Z_0-9]*)\s*(?:(,)|(?=[\n\)\:]))/}]}]},
+   {begin: 
+     /^\s*(?=@\s*[A-Za-z_][A-Za-z0-9_]*(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*\s*\()/,
+    comment: "a decorator may be a function call which returns a decorator.",
+    end: "(\\))",
+    endCaptures: {1 => {name: "punctuation.definition.arguments.end.python"}},
+    name: "meta.function.decorator.python",
+    patterns: 
+     [{begin: 
+        /(?=(@)\s*[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*\s*\()/,
+       beginCaptures: {1 => {name: "punctuation.definition.decorator.python"}},
+       contentName: "entity.name.function.decorator.python",
+       end: "(?=\\s*\\()",
+       patterns: [{include: "#dotted_name"}]},
+      {begin: /(\()/,
+       beginCaptures: 
+        {1 => {name: "punctuation.definition.arguments.begin.python"}},
+       contentName: "meta.function.decorator.arguments.python",
+       end: "(?=\\))",
+       patterns: [{include: "#keyword_arguments"}, {include: "$self"}]}]},
+   {begin: /^\s*(?=@\s*[A-Za-z_][A-Za-z0-9_]*(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*)/,
+    contentName: "entity.name.function.decorator.python",
+    end: "(?=\\s|$\\n?|#)",
+    name: "meta.function.decorator.python",
+    patterns: 
+     [{begin: /(?=(@)\s*[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*)/,
+       beginCaptures: {1 => {name: "punctuation.definition.decorator.python"}},
+       end: "(?=\\s|$\\n?|#)",
+       patterns: [{include: "#dotted_name"}]}]},
+   {begin: /(?<=\)|\])\s*(\()/,
+    beginCaptures: 
+     {1 => {name: "punctuation.definition.arguments.begin.python"}},
+    contentName: "meta.function-call.arguments.python",
+    end: "(\\))",
+    endCaptures: {1 => {name: "punctuation.definition.arguments.end.python"}},
+    name: "meta.function-call.python",
+    patterns: [{include: "#keyword_arguments"}, {include: "$self"}]},
+   {begin: /(?=[A-Za-z_][A-Za-z0-9_]*(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*\s*\()/,
+    end: "(\\))",
+    endCaptures: {1 => {name: "punctuation.definition.arguments.end.python"}},
+    name: "meta.function-call.python",
+    patterns: 
+     [{begin: /(?=[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*\s*\()/,
+       end: "(?=\\s*\\()",
+       patterns: [{include: "#dotted_name"}]},
+      {begin: /(\()/,
+       beginCaptures: 
+        {1 => {name: "punctuation.definition.arguments.begin.python"}},
+       contentName: "meta.function-call.arguments.python",
+       end: "(?=\\))",
+       patterns: [{include: "#keyword_arguments"}, {include: "$self"}]}]},
+   {begin: /(?=[A-Za-z_][A-Za-z0-9_]*(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*\s*\[)/,
+    end: "(\\])",
+    endCaptures: {1 => {name: "punctuation.definition.arguments.end.python"}},
+    name: "meta.item-access.python",
+    patterns: 
+     [{begin: /(?=[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*\s*\[)/,
+       end: "(?=\\s*\\[)",
+       patterns: [{include: "#dotted_name"}]},
+      {begin: /(\[)/,
+       beginCaptures: 
+        {1 => {name: "punctuation.definition.arguments.begin.python"}},
+       contentName: "meta.item-access.arguments.python",
+       end: "(?=\\])",
+       patterns: [{include: "$self"}]}]},
+   {begin: /(?<=\)|\])\s*(\[)/,
+    beginCaptures: 
+     {1 => {name: "punctuation.definition.arguments.begin.python"}},
+    contentName: "meta.item-access.arguments.python",
+    end: "(\\])",
+    endCaptures: {1 => {name: "punctuation.definition.arguments.end.python"}},
+    name: "meta.item-access.python",
+    patterns: [{include: "$self"}]},
+   {captures: {1 => {name: "storage.type.function.python"}},
+    match: /\b(def|lambda)\b/},
+   {captures: {1 => {name: "storage.type.class.python"}},
+    match: /\b(class)\b/},
+   {include: "#line_continuation"},
+   {include: "#language_variables"},
+   {match: /\b(None|True|False|Ellipsis|NotImplemented)\b/,
+    name: "constant.language.python"},
+   {include: "#string_quoted_single"},
+   {include: "#string_quoted_double"},
+   {include: "#dotted_name"},
+   {begin: /(\()/, end: "(\\))", patterns: [{include: "$self"}]},
+   {captures: 
+     {1 => {name: "punctuation.definition.list.begin.python"},
+      2 => {name: "meta.empty-list.python"},
+      3 => {name: "punctuation.definition.list.end.python"}},
+    match: /(\[)(\s*(\]))\b/},
+   {begin: /(\[)/,
+    beginCaptures: {1 => {name: "punctuation.definition.list.begin.python"}},
+    end: "(\\])",
+    endCaptures: {1 => {name: "punctuation.definition.list.end.python"}},
+    name: "meta.structure.list.python",
+    patterns: 
+     [{begin: /(?<=\[|\,)\s*(?![\],])/,
+       contentName: "meta.structure.list.item.python",
+       end: "\\s*(?:(,)|(?=\\]))",
+       endCaptures: {1 => {name: "punctuation.separator.list.python"}},
+       patterns: [{include: "$self"}]}]},
+   {captures: 
+     {1 => {name: "punctuation.definition.tuple.begin.python"},
+      2 => {name: "meta.empty-tuple.python"},
+      3 => {name: "punctuation.definition.tuple.end.python"}},
+    match: /(\()(\s*(\)))/,
+    name: "meta.structure.tuple.python"},
+   {captures: 
+     {1 => {name: "punctuation.definition.dictionary.begin.python"},
+      2 => {name: "meta.empty-dictionary.python"},
+      3 => {name: "punctuation.definition.dictionary.end.python"}},
+    match: /(\{)(\s*(\}))/,
+    name: "meta.structure.dictionary.python"},
+   {begin: /(\{)/,
+    beginCaptures: 
+     {1 => {name: "punctuation.definition.dictionary.begin.python"}},
+    end: "(\\})",
+    endCaptures: {1 => {name: "punctuation.definition.dictionary.end.python"}},
+    name: "meta.structure.dictionary.python",
+    patterns: 
+     [{begin: /(?<=\{|\,|^)\s*(?![\},])/,
+       contentName: "meta.structure.dictionary.key.python",
+       end: "\\s*(?:(?=\\})|(\\:))",
+       endCaptures: 
+        {1 => {name: "punctuation.separator.valuepair.dictionary.python"}},
+       patterns: [{include: "$self"}]},
+      {begin: /(?<=\:|^)\s*/,
+       contentName: "meta.structure.dictionary.value.python",
+       end: "\\s*(?:(?=\\})|(,))",
+       endCaptures: {1 => {name: "punctuation.separator.dictionary.python"}},
+       patterns: [{include: "$self"}]}]}],
+ repository: 
+  {builtin_exceptions: 
+    {match: 
+      /(?x)\b((Arithmetic|Assertion|Attribute|EOF|Environment|FloatingPoint|IO|Import|Indentation|Index|Key|Lookup|Memory|Name|OS|Overflow|NotImplemented|Reference|Runtime|Standard|Syntax|System|Tab|Type|UnboundLocal|Unicode(Translate|Encode|Decode)?|Value|ZeroDivision)Error|(Deprecation|Future|Overflow|PendingDeprecation|Runtime|Syntax|User)?Warning|KeyboardInterrupt|NotImplemented|StopIteration|SystemExit|(Base)?Exception)\b/,
+     name: "support.type.exception.python"},
+   builtin_functions: 
+    {match: 
+      /(?x)\b(
+                __import__|all|abs|any|apply|callable|chr|cmp|coerce|compile|delattr|dir|
+                divmod|eval|execfile|filter|getattr|globals|hasattr|hash|hex|id|
+                input|intern|isinstance|issubclass|iter|len|locals|map|max|min|oct|
+                ord|pow|range|raw_input|reduce|reload|repr|round|setattr|sorted|
+                sum|unichr|vars|zip
+	)\b/,
+     name: "support.function.builtin.python"},
+   builtin_types: 
+    {match: 
+      /(?x)\b(
+	basestring|bool|buffer|classmethod|complex|dict|enumerate|file|
+	float|frozenset|int|list|long|object|open|property|reversed|set|
+	slice|staticmethod|str|super|tuple|type|unicode|xrange
+	)\b/,
+     name: "support.type.python"},
+   constant_placeholder: 
+    {match: 
+      /(?i:%(\([a-z_]+\))?#?0?\-?[ ]?\+?([0-9]*|\*)(\.([0-9]*|\*))?[hL]?[a-z%])/,
+     name: "constant.other.placeholder.python"},
+   docstrings: 
+    {patterns: 
+      [{begin: /^\s*(?=[uU]?[rR]?""")/,
+        end: "(?<=\"\"\")",
+        name: "comment.block.python",
+        patterns: [{include: "#string_quoted_double"}]},
+       {begin: /^\s*(?=[uU]?[rR]?''')/,
+        end: "(?<=''')",
+        name: "comment.block.python",
+        patterns: [{include: "#string_quoted_single"}]}]},
+   dotted_name: 
+    {begin: /(?=[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)/,
+     end: "(?![A-Za-z0-9_\\.])",
+     patterns: 
+      [{begin: /(\.)(?=[A-Za-z_][A-Za-z0-9_]*)/,
+        end: "(?![A-Za-z0-9_])",
+        patterns: 
+         [{include: "#magic_function_names"},
+          {include: "#magic_variable_names"},
+          {include: "#illegal_names"},
+          {include: "#generic_names"}]},
+       {begin: /(?<!\.)(?=[A-Za-z_][A-Za-z0-9_]*)/,
+        end: "(?![A-Za-z0-9_])",
+        patterns: 
+         [{include: "#builtin_functions"},
+          {include: "#builtin_types"},
+          {include: "#builtin_exceptions"},
+          {include: "#illegal_names"},
+          {include: "#magic_function_names"},
+          {include: "#magic_variable_names"},
+          {include: "#language_variables"},
+          {include: "#generic_names"}]}]},
+   entity_name_class: 
+    {patterns: [{include: "#illegal_names"}, {include: "#generic_names"}]},
+   entity_name_function: 
+    {patterns: 
+      [{include: "#magic_function_names"},
+       {include: "#illegal_names"},
+       {include: "#generic_names"}]},
+   escaped_char: 
+    {captures: 
+      {1 => {name: "constant.character.escape.hex.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"},
+       2 => {name: "constant.character.escape.octal.python"},
+       3 => {name: "constant.character.escape.newline.python"},
+       4 => {name: "constant.character.escape.backlash.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"}},
+     match: 
+      /(\\x[0-9A-F]{2})|(\\[0-7]{3})|(\\\n)|(\\\\)|(\\\")|(\\')|(\\a)|(\\b)|(\\f)|(\\n)|(\\r)|(\\t)|(\\v)/},
+   escaped_unicode_char: 
+    {captures: 
+      {1 => {name: "constant.character.escape.unicode.16-bit-hex.python"},
+       2 => {name: "constant.character.escape.unicode.32-bit-hex.python"},
+       3 => {name: "constant.character.escape.unicode.name.python"}},
+     match: /(\\U[0-9A-Fa-f]{8})|(\\u[0-9A-Fa-f]{4})|(\\N\{[a-zA-Z ]+\})/},
+   function_name: 
+    {patterns: 
+      [{include: "#magic_function_names"},
+       {include: "#magic_variable_names"},
+       {include: "#builtin_exceptions"},
+       {include: "#builtin_functions"},
+       {include: "#builtin_types"},
+       {include: "#generic_names"}]},
+   generic_names: {match: /[A-Za-z_][A-Za-z0-9_]*/},
+   illegal_names: 
+    {match: 
+      /\b(and|as|assert|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+     name: "invalid.illegal.name.python"},
+   keyword_arguments: 
+    {begin: /\b([a-zA-Z_][a-zA-Z_0-9]*)\s*(=)(?!=)/,
+     beginCaptures: 
+      {1 => {name: "variable.parameter.function.python"},
+       2 => {name: "keyword.operator.assignment.python"}},
+     end: "\\s*(?:(,)|(?=$\\n?|[\\)\\:]))",
+     endCaptures: {1 => {name: "punctuation.separator.parameters.python"}},
+     patterns: [{include: "$self"}]},
+   language_variables: 
+    {match: /\b(self|cls)\b/, name: "variable.language.python"},
+   line_continuation: 
+    {captures: 
+      {1 => {name: "punctuation.separator.continuation.line.python"},
+       2 => {name: "invalid.illegal.unexpected-text.python"}},
+     match: /(\\)(.*)$\n?/},
+   magic_function_names: 
+    {comment: 
+      "these methods have magic interpretation by python and are generally called indirectly through syntactic constructs",
+     match: 
+      /(?x)\b(__(?:
+	abs|add|and|call|cmp|coerce|complex|contains|del|delattr|
+	delete|delitem|delslice|div|divmod|enter|eq|exit|float|
+	floordiv|ge|get|getattr|getattribute|getitem|getslice|gt|
+	hash|hex|iadd|iand|idiv|ifloordiv|ilshift|imod|imul|init|
+	int|invert|ior|ipow|irshift|isub|iter|itruediv|ixor|le|len|
+	long|lshift|lt|mod|mul|ne|neg|new|nonzero|oct|or|pos|pow|
+	radd|rand|rdiv|rdivmod|repr|rfloordiv|rlshift|rmod|rmul|ror|
+	rpow|rrshift|rshift|rsub|rtruediv|rxor|set|setattr|setitem|
+	setslice|str|sub|truediv|unicode|xor
+	)__)\b/,
+     name: "support.function.magic.python"},
+   magic_variable_names: 
+    {comment: "magic variables which a class/module may have.",
+     match: 
+      /\b__(all|bases|class|debug|dict|doc|file|members|metaclass|methods|name|slots|weakref)__\b/,
+     name: "support.variable.magic.python"},
+   regular_expressions: 
+    {comment: 
+      "Changed disabled to 1 to turn off syntax highlighting in “r” strings.",
+     disabled: 0,
+     patterns: [{include: "source.regexp.python"}]},
+   string_quoted_double: 
+    {patterns: 
+      [{begin: /([uU]r)(""")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted unicode-raw string",
+        end: "((?<=\"\"\")(\")\"\"|\"\"\")",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"}},
+        name: "string.quoted.double.block.unicode-raw-regex.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"},
+          {include: "#regular_expressions"}]},
+       {begin: /([uU]R)(""")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: 
+         "single quoted unicode-raw string without regular expression highlighting",
+        end: "((?<=\"\"\")(\")\"\"|\"\"\")",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"}},
+        name: "string.quoted.double.block.unicode-raw.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"}]},
+       {begin: /(r)(""")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double quoted raw string",
+        end: "((?<=\"\"\")(\")\"\"|\"\"\")",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"}},
+        name: "string.quoted.double.block.raw-regex.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_char"},
+          {include: "#regular_expressions"}]},
+       {begin: /(R)(""")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double quoted raw string",
+        end: "((?<=\"\"\")(\")\"\"|\"\"\")",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"}},
+        name: "string.quoted.double.block.raw.python",
+        patterns: 
+         [{include: "#constant_placeholder"}, {include: "#escaped_char"}]},
+       {begin: /([uU])(""")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double quoted unicode string",
+        end: "((?<=\"\"\")(\")\"\"|\"\"\")",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"}},
+        name: "string.quoted.double.block.unicode.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"}]},
+       {begin: /([uU]r)(")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double-quoted raw string",
+        end: "((?<=\")(\")|\")|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"},
+          3 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.double.single-line.unicode-raw-regex.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"},
+          {include: "#regular_expressions"}]},
+       {begin: /([uU]R)(")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double-quoted raw string",
+        end: "((?<=\")(\")|\")|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"},
+          3 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.double.single-line.unicode-raw.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"}]},
+       {begin: /(r)(")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double-quoted raw string",
+        end: "((?<=\")(\")|\")|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"},
+          3 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.double.single-line.raw-regex.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_char"},
+          {include: "#regular_expressions"}]},
+       {begin: /(R)(")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double-quoted raw string",
+        end: "((?<=\")(\")|\")|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"},
+          3 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.double.single-line.raw.python",
+        patterns: 
+         [{include: "#constant_placeholder"}, {include: "#escaped_char"}]},
+       {begin: /([uU])(")/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double quoted unicode string",
+        end: "((?<=\")(\")|\")|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"},
+          3 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.double.single-line.unicode.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"}]},
+       {begin: 
+         /(""")(?=\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|REPLACE|ALTER))/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double quoted string",
+        end: "((?<=\"\"\")(\")\"\"|\"\"\")",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"}},
+        name: "string.quoted.double.block.sql.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_char"},
+          {include: "source.sql"}]},
+       {begin: /(")(?=\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|REPLACE|ALTER))/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double quoted string",
+        end: "((?<=\")(\")|\")|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"},
+          3 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.double.single-line.sql.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_char"},
+          {include: "source.sql"}]},
+       {begin: /(""")/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double quoted string",
+        end: "((?<=\"\"\")(\")\"\"|\"\"\")",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"}},
+        name: "string.quoted.double.block.python",
+        patterns: 
+         [{include: "#constant_placeholder"}, {include: "#escaped_char"}]},
+       {begin: /(")/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "double quoted string",
+        end: "((?<=\")(\")|\")|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.double.python"},
+          3 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.double.single-line.python",
+        patterns: 
+         [{include: "#constant_placeholder"}, {include: "#escaped_char"}]}]},
+   string_quoted_single: 
+    {patterns: 
+      [{captures: 
+         {1 => {name: "punctuation.definition.string.begin.python"},
+          2 => {name: "punctuation.definition.string.end.python"},
+          3 => {name: "meta.empty-string.single.python"}},
+        match: /(?<!')(')(('))(?!')/,
+        name: "string.quoted.single.single-line.python"},
+       {begin: /([uU]r)(''')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted unicode-raw string",
+        end: "((?<=''')(')''|''')",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.single.python"}},
+        name: "string.quoted.single.block.unicode-raw-regex.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"},
+          {include: "#regular_expressions"}]},
+       {begin: /([uU]R)(''')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted unicode-raw string",
+        end: "((?<=''')(')''|''')",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.single.python"}},
+        name: "string.quoted.single.block.unicode-raw.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"}]},
+       {begin: /(r)(''')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted raw string",
+        end: "((?<=''')(')''|''')",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.single.python"}},
+        name: "string.quoted.single.block.raw-regex.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_char"},
+          {include: "#regular_expressions"}]},
+       {begin: /(R)(''')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted raw string",
+        end: "((?<=''')(')''|''')",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.single.python"}},
+        name: "string.quoted.single.block.raw.python",
+        patterns: 
+         [{include: "#constant_placeholder"}, {include: "#escaped_char"}]},
+       {begin: /([uU])(''')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted unicode string",
+        end: "((?<=''')(')''|''')",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.single.python"}},
+        name: "string.quoted.single.block.unicode.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"}]},
+       {begin: /([uU]r)(')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted raw string",
+        end: "(')|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.single.single-line.unicode-raw-regex.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"},
+          {include: "#regular_expressions"}]},
+       {begin: /([uU]R)(')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted raw string",
+        end: "(')|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.single.single-line.unicode-raw.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"}]},
+       {begin: /(r)(')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted raw string",
+        end: "(')|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.single.single-line.raw-regex.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_char"},
+          {include: "#regular_expressions"}]},
+       {begin: /(R)(')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted raw string",
+        end: "(')|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.single.single-line.raw.python",
+        patterns: 
+         [{include: "#constant_placeholder"}, {include: "#escaped_char"}]},
+       {begin: /([uU])(')/,
+        beginCaptures: 
+         {1 => {name: "storage.type.string.python"},
+          2 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted unicode string",
+        end: "(')|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.single.single-line.unicode.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_unicode_char"},
+          {include: "#escaped_char"}]},
+       {begin: 
+         /(''')(?=\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|REPLACE|ALTER))/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted string",
+        end: "((?<=''')(')''|''')",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.single.python"}},
+        name: "string.quoted.single.block.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_char"},
+          {include: "source.sql"}]},
+       {begin: /(')(?=\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|REPLACE|ALTER))/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted string",
+        end: "(')|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.single.single-line.python",
+        patterns: 
+         [{include: "#constant_placeholder"},
+          {include: "#escaped_char"},
+          {include: "source.sql"}]},
+       {begin: /(''')/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted string",
+        end: "((?<=''')(')''|''')",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "meta.empty-string.single.python"}},
+        name: "string.quoted.single.block.python",
+        patterns: 
+         [{include: "#constant_placeholder"}, {include: "#escaped_char"}]},
+       {begin: /(')/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.string.begin.python"}},
+        comment: "single quoted string",
+        end: "(')|(\\n)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.string.end.python"},
+          2 => {name: "invalid.illegal.unclosed-string.python"}},
+        name: "string.quoted.single.single-line.python",
+        patterns: 
+         [{include: "#constant_placeholder"}, {include: "#escaped_char"}]}]},
+   strings: 
+    {patterns: 
+      [{include: "#string_quoted_double"},
+       {include: "#string_quoted_single"}]}},
+ scopeName: "source.python",
+ uuid: "F23DB5B2-7D08-11D9-A709-000D93B6E43C"}