src/eric7/QScintilla/Lexers/__init__.py

branch
eric7
changeset 9482
a2bc06a54d9d
parent 9413
80c06d472826
child 9484
d2eb8f0a5bf0
diff -r 0b936ff1bbb9 -r a2bc06a54d9d src/eric7/QScintilla/Lexers/__init__.py
--- a/src/eric7/QScintilla/Lexers/__init__.py	Sun Nov 06 11:22:39 2022 +0100
+++ b/src/eric7/QScintilla/Lexers/__init__.py	Mon Nov 07 17:19:58 2022 +0100
@@ -289,149 +289,151 @@
     if not pyname:
         try:
             if language in ["Python", "Python3", "Cython", "MicroPython"]:
-                from .LexerPython import LexerPython
+                from .LexerPython import LexerPython  # __IGNORE_WARNING_I101__
 
                 return LexerPython(language, parent)
             elif language == "C++":
-                from .LexerCPP import LexerCPP
+                from .LexerCPP import LexerCPP  # __IGNORE_WARNING_I101__
 
                 return LexerCPP(
                     parent, Preferences.getEditor("CppCaseInsensitiveKeywords")
                 )
             elif language == "C#":
-                from .LexerCSharp import LexerCSharp
+                from .LexerCSharp import LexerCSharp  # __IGNORE_WARNING_I101__
 
                 return LexerCSharp(parent)
             elif language == "IDL":
-                from .LexerIDL import LexerIDL
+                from .LexerIDL import LexerIDL  # __IGNORE_WARNING_I101__
 
                 return LexerIDL(parent)
             elif language == "Java":
-                from .LexerJava import LexerJava
+                from .LexerJava import LexerJava  # __IGNORE_WARNING_I101__
 
                 return LexerJava(parent)
             elif language == "JavaScript":
-                from .LexerJavaScript import LexerJavaScript
+                from .LexerJavaScript import LexerJavaScript  # __IGNORE_WARNING_I101__
 
                 return LexerJavaScript(parent)
             elif language == "SQL":
-                from .LexerSQL import LexerSQL
+                from .LexerSQL import LexerSQL  # __IGNORE_WARNING_I101__
 
                 return LexerSQL(parent)
             elif language == "HTML":
-                from .LexerHTML import LexerHTML
+                from .LexerHTML import LexerHTML  # __IGNORE_WARNING_I101__
 
                 return LexerHTML(parent)
             elif language == "Perl":
-                from .LexerPerl import LexerPerl
+                from .LexerPerl import LexerPerl  # __IGNORE_WARNING_I101__
 
                 return LexerPerl(parent)
             elif language == "Bash":
-                from .LexerBash import LexerBash
+                from .LexerBash import LexerBash  # __IGNORE_WARNING_I101__
 
                 return LexerBash(parent)
             elif language == "Ruby":
-                from .LexerRuby import LexerRuby
+                from .LexerRuby import LexerRuby  # __IGNORE_WARNING_I101__
 
                 return LexerRuby(parent)
             elif language == "Lua":
-                from .LexerLua import LexerLua
+                from .LexerLua import LexerLua  # __IGNORE_WARNING_I101__
 
                 return LexerLua(parent)
             elif language == "CSS":
-                from .LexerCSS import LexerCSS
+                from .LexerCSS import LexerCSS  # __IGNORE_WARNING_I101__
 
                 return LexerCSS(parent)
             elif language == "TeX":
-                from .LexerTeX import LexerTeX
+                from .LexerTeX import LexerTeX  # __IGNORE_WARNING_I101__
 
                 return LexerTeX(parent)
             elif language == "Diff":
-                from .LexerDiff import LexerDiff
+                from .LexerDiff import LexerDiff  # __IGNORE_WARNING_I101__
 
                 return LexerDiff(parent)
             elif language == "Makefile":
-                from .LexerMakefile import LexerMakefile
+                from .LexerMakefile import LexerMakefile  # __IGNORE_WARNING_I101__
 
                 return LexerMakefile(parent)
             elif language == "Properties":
-                from .LexerProperties import LexerProperties
+                from .LexerProperties import LexerProperties  # __IGNORE_WARNING_I101__
 
                 return LexerProperties(parent)
             elif language == "Batch":
-                from .LexerBatch import LexerBatch
+                from .LexerBatch import LexerBatch  # __IGNORE_WARNING_I101__
 
                 return LexerBatch(parent)
             elif language == "D":
-                from .LexerD import LexerD
+                from .LexerD import LexerD  # __IGNORE_WARNING_I101__
 
                 return LexerD(parent)
             elif language == "Povray":
-                from .LexerPOV import LexerPOV
+                from .LexerPOV import LexerPOV  # __IGNORE_WARNING_I101__
 
                 return LexerPOV(parent)
             elif language == "CMake":
-                from .LexerCMake import LexerCMake
+                from .LexerCMake import LexerCMake  # __IGNORE_WARNING_I101__
 
                 return LexerCMake(parent)
             elif language == "VHDL":
-                from .LexerVHDL import LexerVHDL
+                from .LexerVHDL import LexerVHDL  # __IGNORE_WARNING_I101__
 
                 return LexerVHDL(parent)
             elif language == "TCL":
-                from .LexerTCL import LexerTCL
+                from .LexerTCL import LexerTCL  # __IGNORE_WARNING_I101__
 
                 return LexerTCL(parent)
             elif language == "Fortran":
-                from .LexerFortran import LexerFortran
+                from .LexerFortran import LexerFortran  # __IGNORE_WARNING_I101__
 
                 return LexerFortran(parent)
             elif language == "Fortran77":
-                from .LexerFortran77 import LexerFortran77
+                from .LexerFortran77 import LexerFortran77  # __IGNORE_WARNING_I101__
 
                 return LexerFortran77(parent)
             elif language == "Pascal":
-                from .LexerPascal import LexerPascal
+                from .LexerPascal import LexerPascal  # __IGNORE_WARNING_I101__
 
                 return LexerPascal(parent)
             elif language == "PostScript":
-                from .LexerPostScript import LexerPostScript
+                from .LexerPostScript import LexerPostScript  # __IGNORE_WARNING_I101__
 
                 return LexerPostScript(parent)
             elif language == "XML":
-                from .LexerXML import LexerXML
+                from .LexerXML import LexerXML  # __IGNORE_WARNING_I101__
 
                 return LexerXML(parent)
             elif language == "YAML":
-                from .LexerYAML import LexerYAML
+                from .LexerYAML import LexerYAML  # __IGNORE_WARNING_I101__
 
                 return LexerYAML(parent)
             elif language == "Matlab":
-                from .LexerMatlab import LexerMatlab
+                from .LexerMatlab import LexerMatlab  # __IGNORE_WARNING_I101__
 
                 return LexerMatlab(parent)
             elif language == "Octave":
-                from .LexerOctave import LexerOctave
+                from .LexerOctave import LexerOctave  # __IGNORE_WARNING_I101__
 
                 return LexerOctave(parent)
             elif language == "QSS":
-                from .LexerQSS import LexerQSS
+                from .LexerQSS import LexerQSS  # __IGNORE_WARNING_I101__
 
                 return LexerQSS(parent)
             elif language == "Gettext":
-                from .LexerPO import LexerPO
+                from .LexerPO import LexerPO  # __IGNORE_WARNING_I101__
 
                 return LexerPO(parent)
             elif language == "CoffeeScript":
-                from .LexerCoffeeScript import LexerCoffeeScript
+                from .LexerCoffeeScript import (  # __IGNORE_WARNING_I101__
+                    LexerCoffeeScript,
+                )
 
                 return LexerCoffeeScript(parent)
             elif language == "JSON":
-                from .LexerJSON import LexerJSON
+                from .LexerJSON import LexerJSON  # __IGNORE_WARNING_I101__
 
                 return LexerJSON(parent)
             elif language == "Markdown":
-                from .LexerMarkdown import LexerMarkdown
+                from .LexerMarkdown import LexerMarkdown  # __IGNORE_WARNING_I101__
 
                 return LexerMarkdown(parent)
 

eric ide

mercurial